src/MEDCoupling_Swig/MEDCouplingBasicsTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2013  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         a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2673         self.assertEqual(renum,list(a.getValues()))
2674         self.assertTrue(b==None);
2675         mesh2.setCoords(mesh1.getCoords())
2676         a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2677         self.assertEqual(renum,list(a.getValues()))
2678         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2679         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2680         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2681         mesh2.renumberCells(renum,False);
2682         mesh2.renumberNodes(renum2,11);
2683         cellCor=None
2684         nodeCor=None
2685         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2686         self.assertTrue(cellCor==None);
2687         self.assertTrue(nodeCor==None);
2688         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2689         self.assertTrue(cellCor==None);
2690         self.assertTrue(nodeCor==None);
2691         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2692         self.assertTrue(cellCor);
2693         self.assertEqual(10,cellCor.getNumberOfTuples());
2694         self.assertEqual(1,cellCor.getNumberOfComponents());
2695         self.assertEqual(renum,list(cellCor.getValues()))
2696         self.assertTrue(nodeCor);
2697         self.assertEqual(11,nodeCor.getNumberOfTuples());
2698         self.assertEqual(1,nodeCor.getNumberOfComponents());
2699         self.assertEqual(renum2,list(nodeCor.getValues()))
2700         cellCor=0;
2701         nodeCor=0;
2702         #5th test : modification of the last cell to check fastCheck detection.
2703         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2704         renum3=[0,2,1,3,4,5,6,8,9,7]
2705         mesh2.renumberCells(renum3,False);
2706         mesh2.renumberNodes(renum2,11);
2707         cellCor=None
2708         nodeCor=None
2709         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2710         self.assertTrue(cellCor==None);
2711         self.assertTrue(nodeCor==None);
2712         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2713         self.assertTrue(cellCor==None);
2714         self.assertTrue(nodeCor==None);
2715         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2716         self.assertTrue(cellCor!=None);
2717         self.assertEqual(10,cellCor.getNumberOfTuples());
2718         self.assertEqual(1,cellCor.getNumberOfComponents());
2719         self.assertEqual(renum3,list(cellCor.getValues()))
2720         self.assertTrue(nodeCor!=None);
2721         self.assertEqual(11,nodeCor.getNumberOfTuples());
2722         self.assertEqual(1,nodeCor.getNumberOfComponents());
2723         self.assertEqual(renum2,list(nodeCor.getValues()));
2724         pass
2725
2726     def testCheckGeoEquivalWith2(self):
2727         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2728         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2729         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2730         self.assertEqual(None,cellCor);
2731         self.assertNotEqual(None,nodeCor);
2732         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2733         for i in xrange(9):
2734             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2735             pass
2736         pass
2737
2738     def testCopyTinyStringsFromOnFields(self):
2739         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2740         nbOfCells=m.getNumberOfCells();
2741         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2742         f.setMesh(m);
2743         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2744         f.setName("a");
2745         f.setDescription("b");
2746         a1=DataArrayDouble.New();
2747         a1.alloc(nbOfCells,2);
2748         a1.fillWithZero();
2749         a1.setInfoOnComponent(0,"c");
2750         a1.setInfoOnComponent(1,"d");
2751         a2=a1.deepCpy();
2752         a2.setInfoOnComponent(0,"e");
2753         a2.setInfoOnComponent(1,"f");
2754         f.setArray(a1);
2755         f.setEndArray(a2);
2756         f.setEndTime(3.,3,4);
2757         m.setName("g");
2758         m.getCoords().setInfoOnComponent(0,"h");
2759         m.getCoords().setInfoOnComponent(1,"i");
2760         m.getCoords().setInfoOnComponent(2,"j");
2761         #
2762         f.checkCoherency();
2763         f2=f.clone(True);
2764         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2765         f2.setName("smth");
2766         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2767         f2.copyTinyStringsFrom(f);
2768         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2769         f2.setDescription("GGG");
2770         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2771         f2.copyTinyStringsFrom(f);
2772         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2773         f2.getArray().setInfoOnComponent(0,"mmmm");
2774         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2775         f2.copyTinyStringsFrom(f);
2776         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2777         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2778         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2779         f2.copyTinyStringsFrom(f);
2780         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2781         m2=m.clone(True);
2782         self.assertTrue(m2.isEqual(m,1e-12));
2783         m2.setName("123");
2784         self.assertTrue(not m2.isEqual(m,1e-12));
2785         m2.copyTinyStringsFrom(m);
2786         self.assertTrue(m2.isEqual(m,1e-12));
2787         m2.getCoords().setInfoOnComponent(1,"eee");
2788         self.assertTrue(not m2.isEqual(m,1e-12));
2789         m2.copyTinyStringsFrom(m);
2790         self.assertTrue(m2.isEqual(m,1e-12));
2791         pass
2792
2793     def testTryToShareSameCoordsPermute(self):
2794         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2795         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2796         #self.assertTrue(m.getCoords()!=m2.getCoords());
2797         m.tryToShareSameCoordsPermute(m2,1e-12);
2798         #self.assertTrue(m.getCoords()==m2.getCoords());
2799         self.assertTrue(m2.isEqual(m,1e-12));
2800         renum1=[1,2,0,5,8,7,4,3,6]
2801         r1=DataArrayInt.New()
2802         r1.setValues(renum1,len(renum1),1)
2803         m.renumberNodes(r1,9);
2804         #self.assertTrue(m.getCoords()!=m2.getCoords());
2805         self.assertTrue(not m2.isEqual(m,1e-12));
2806         m.tryToShareSameCoordsPermute(m2,1e-12);
2807         #self.assertTrue(m.getCoords()==m2.getCoords());
2808         self.assertTrue(m2.isEqual(m,1e-12));
2809         pass
2810
2811     def testTryToShareSameCoordsPermute2(self):
2812         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2813         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2814         targetConn=[0,2,3,1]
2815         m2=MEDCouplingUMesh.New();
2816         m2.setMeshDimension(2);
2817         m2.allocateCells(1);
2818         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2819         m2.finishInsertingCells();
2820         myCoords=DataArrayDouble.New();
2821         myCoords.setValues(targetCoords,4,2);
2822         m2.setCoords(myCoords);
2823         m2.checkCoherency();
2824         m1.checkCoherency();
2825         #
2826         expected1=[0.25,0.125,0.125,0.25,0.25]
2827         f1=m1.getMeasureField(False);
2828         f2=m2.getMeasureField(False);
2829         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2830         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2831         for i in xrange(5):
2832             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2833             pass
2834         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2835         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2836         # Let's go for deeper test of tryToShareSameCoordsPermute
2837         m2.tryToShareSameCoordsPermute(m1,1e-12);
2838         f1=m1.getMeasureField(False);
2839         f2=m2.getMeasureField(False);
2840         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2841         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2842         for i in xrange(5):
2843             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2844             pass
2845         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2846         pass
2847
2848     def testChangeUnderlyingMesh1(self):
2849         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2850         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2851         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2852         f1.setMesh(mesh1);
2853         array=DataArrayDouble.New();
2854         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2855         array.setValues(arr,mesh1.getNumberOfCells(),2);
2856         f1.setArray(array);
2857         #
2858         renum=[0,2,1,3,4,5,6,8,7,9]
2859         mesh2.renumberCells(renum,False);
2860         #self.assertTrue(f1.getMesh()==mesh1);
2861         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2862         #self.assertTrue(f1.getMesh()==mesh1);
2863         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2864         #self.assertTrue(f1.getMesh()==mesh2);
2865         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2866         for i in xrange(20):
2867             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2868             pass
2869         #
2870         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2871         f1.setMesh(mesh1);
2872         array=DataArrayDouble.New();
2873         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2874         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2875         f1.setArray(array);
2876         #
2877         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2878         mesh2.renumberNodes(renum2,11);
2879         #self.assertTrue(f1.getMesh()==mesh1);
2880         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2881         #self.assertTrue(f1.getMesh()==mesh2);
2882         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2883         for i in xrange(22):
2884             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
2885             pass
2886         pass
2887
2888     def testGetMaxValue1(self):
2889         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2890         nbOfCells=m.getNumberOfCells();
2891         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2892         f.setMesh(m);
2893         a1=DataArrayDouble.New();
2894         val1=[3.,4.,5.,6.,7.]
2895         a1.setValues(val1,nbOfCells,1);
2896         a2=DataArrayDouble.New();
2897         val2=[0.,1.,2.,8.,7.]
2898         a2.setValues(val2,nbOfCells,1);
2899         f.setArray(a1);
2900         f.setEndArray(a2);
2901         f.setEndTime(3.,3,4);
2902         f.checkCoherency();
2903         #
2904         self.assertAlmostEqual(8.,f.getMaxValue(),14);
2905         self.assertAlmostEqual(0.,f.getMinValue(),14);
2906         self.assertAlmostEqual(5.,f.getAverageValue(),14);
2907         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
2908         a1.setIJ(0,2,9.5);
2909         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2910         self.assertAlmostEqual(0.,f.getMinValue(),14);
2911         a2.setIJ(0,0,9.);
2912         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2913         self.assertAlmostEqual(1.,f.getMinValue(),14);
2914         pass
2915
2916     def testSubstractInPlaceDM1(self):
2917         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2918         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2919         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2920         f1.setMesh(mesh1);
2921         array=DataArrayDouble.New();
2922         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2923         array.setValues(arr,mesh1.getNumberOfCells(),2);
2924         f1.setArray(array);
2925         #
2926         self.assertEqual(10,f1.getNumberOfTuples());
2927         self.assertEqual(2,f1.getNumberOfComponents());
2928         self.assertEqual(20,f1.getNumberOfValues());
2929         #
2930         renum=[0,2,3,1,4,5,6,8,7,9]
2931         mesh2.renumberCells(renum,False);
2932         #
2933         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2934         f2.setMesh(mesh2);
2935         array=DataArrayDouble.New();
2936         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]
2937         array.setValues(arr2,mesh2.getNumberOfCells(),2);
2938         f2.setArray(array);
2939         #
2940         f1.substractInPlaceDM(f2,10,1e-12);
2941         f1.applyFunc(1,"abs(x+y+0.2)");
2942         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
2943         pass
2944
2945     def testDotCrossProduct1(self):
2946         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2947         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2948         f1.setTime(2.3,5,6);
2949         f1.setMesh(mesh1);
2950         array=DataArrayDouble.New();
2951         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.]
2952         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2953         f1.setArray(array);
2954         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2955         f2.setTime(7.8,4,5);
2956         f2.setMesh(mesh1);
2957         array=DataArrayDouble.New();
2958         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.]
2959         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2960         f2.setArray(array);
2961         #
2962         f3=f1.dot(f2);
2963         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
2964         for i in xrange(10):
2965             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
2966             pass
2967         #
2968         f4=f1.crossProduct(f2);
2969         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.]
2970         for i in xrange(30):
2971             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2972             pass
2973         pass
2974
2975     def testMinMaxFields1(self):
2976         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2977         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2978         f1.setTime(2.3,5,6);
2979         f1.setMesh(mesh1);
2980         array=DataArrayDouble.New();
2981         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.]
2982         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2983         f1.setArray(array);
2984         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2985         f2.setTime(7.8,4,5);
2986         f2.setMesh(mesh1);
2987         array=DataArrayDouble.New();
2988         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.]
2989         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2990         f2.setArray(array);
2991         #
2992         f3=f1.max(f2);
2993         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.]
2994         for i in xrange(30):
2995             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
2996             pass
2997         #
2998         f4=f1.min(f2);
2999         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.]
3000         for i in xrange(30):
3001             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3002             pass
3003         #
3004         pass
3005
3006     def testApplyLin1(self):
3007         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3008         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3009         f1.setMesh(mesh1);
3010         array=DataArrayDouble.New();
3011         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3012         array.setValues(arr,mesh1.getNumberOfCells(),2);
3013         f1.setArray(array);
3014         #
3015         f1.applyLin(2.,3.,0);
3016         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3017         for i in xrange(20):
3018             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3019             pass
3020         #
3021         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3022         array=DataArrayDouble.New();
3023         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3024         f1.setEndArray(array);
3025         #
3026         f1.applyLin(4.,5.,1);
3027         #
3028         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3029         for i in xrange(20):
3030             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3031             pass
3032         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3033         for i in xrange(20):
3034             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3035             pass
3036         #
3037         pass
3038
3039     def testGetIdsInRange1(self):
3040         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3041         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3042         f1.setTime(2.3,5,6);
3043         f1.setMesh(mesh1);
3044         array=DataArrayDouble.New();
3045         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3046         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3047         f1.setArray(array);
3048         #
3049         f1.checkCoherency();
3050         da=f1.getIdsInRange(2.9,7.1);
3051         self.failUnlessEqual(5,da.getNbOfElems());
3052         expected1=[2,3,5,7,9]
3053         self.failUnlessEqual(expected1,list(da.getValues()));
3054         da=f1.getIdsInRange(8.,12.);
3055         self.failUnlessEqual(4,da.getNbOfElems());
3056         expected2=[1,4,6,8]
3057         self.failUnlessEqual(expected2,list(da.getValues()));
3058         #
3059         pass
3060
3061     def testBuildSubPart1(self):
3062         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3063         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3064         f1.setTime(2.3,5,6);
3065         f1.setMesh(mesh1);
3066         array=DataArrayDouble.New();
3067         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3068         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3069         f1.setArray(array);
3070         #
3071         part1=[2,1,4]
3072         f2=f1[part1];
3073         f2.zipCoords()
3074         self.failUnlessEqual(3,f2.getNumberOfTuples());
3075         self.failUnlessEqual(2,f2.getNumberOfComponents());
3076         expected1=[5.,105.,4.,104.,7.,107.]
3077         for i in xrange(6):
3078             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3079             pass
3080         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3081         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3082         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3083         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3084         m2C=f2.getMesh();
3085         self.failUnlessEqual(13,m2C.getMeshLength());
3086         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]
3087         for i in xrange(12):
3088             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3089             pass
3090         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3091         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3092         expected4=[0,4,8,13]
3093         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3094         # Test with field on nodes.
3095         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3096         f1.setTime(2.3,5,6);
3097         f1.setMesh(mesh1);
3098         array=DataArrayDouble.New();
3099         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3100         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3101         f1.setArray(array);
3102         part2=[1,2]
3103         f2=f1.buildSubPart(part2);
3104         self.failUnlessEqual(4,f2.getNumberOfTuples());
3105         self.failUnlessEqual(2,f2.getNumberOfComponents());
3106         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3107         for i in xrange(8):
3108             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3109             pass
3110         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3111         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3112         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3113         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3114         m2C=f2.getMesh();
3115         self.failUnlessEqual(8,m2C.getMeshLength());
3116         for i in xrange(8):#8 is not an error
3117             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3118             pass
3119         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3120         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3121         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3122         #idem previous because nodes of cell#4 are not fully present in part3
3123         part3=[1,2]
3124         arrr=DataArrayInt.New();
3125         arrr.setValues(part3,2,1);
3126         f2=f1.buildSubPart(arrr);
3127         self.failUnlessEqual(4,f2.getNumberOfTuples());
3128         self.failUnlessEqual(2,f2.getNumberOfComponents());
3129         for i in xrange(8):
3130             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3131             pass
3132         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3133         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3134         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3135         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3136         m2C=f2.getMesh();
3137         self.failUnlessEqual(8,m2C.getMeshLength());
3138         for i in xrange(8):#8 is not an error
3139             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3140             pass
3141         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3142         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3143         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3144         #
3145         part4=[1,2,4]
3146         f2=f1.buildSubPart(part4);
3147         self.failUnlessEqual(6,f2.getNumberOfTuples());
3148         self.failUnlessEqual(2,f2.getNumberOfComponents());
3149         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3150         for i in xrange(12):
3151             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3152             pass
3153         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3154         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3155         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3156         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3157         m2C=f2.getMesh();
3158         self.failUnlessEqual(13,m2C.getMeshLength());
3159         for i in xrange(12):
3160             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3161             pass
3162         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3163         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3164         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3165         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3166         pass
3167
3168     def testDoublyContractedProduct1(self):
3169         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3170         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3171         f1.setMesh(mesh1);
3172         array=DataArrayDouble.New();
3173         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]
3174         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3175         f1.setArray(array);
3176         f1.checkCoherency();
3177         #
3178         f2=f1.doublyContractedProduct();
3179         f2.checkCoherency();
3180         self.assertEqual(1,f2.getNumberOfComponents());
3181         self.assertEqual(5,f2.getNumberOfTuples());
3182         for i in xrange(5):
3183             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3184             pass
3185         #
3186         pass
3187
3188     def testDeterminant1(self):
3189         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3190         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3191         f1.setTime(2.3,5,6);
3192         f1.setEndTime(3.8,7,3);
3193         f1.setMesh(mesh1);
3194         array=DataArrayDouble.New();
3195         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]
3196         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3197         f1.setArray(array);
3198         #4 components
3199         f1.checkCoherency();
3200         f2=f1.determinant();
3201         f2.checkCoherency();
3202         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3203         self.assertEqual(1,f2.getNumberOfComponents());
3204         self.assertEqual(5,f2.getNumberOfValues());
3205         for i in xrange(5):
3206             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3207             pass
3208         #6 components multi arrays with end array not defined
3209         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3210         f1.setTime(2.3,5,6);
3211         f1.setEndTime(3.8,7,3);
3212         f1.setMesh(mesh1);
3213         array=DataArrayDouble.New();
3214         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,
3215               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]
3216         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3217         f1.setArray(array);
3218         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3219         #
3220         f2=f1.determinant();
3221         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3222         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3223         self.assertEqual(9,f2.getNumberOfTuples());
3224         for i in xrange(9):
3225             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3226             pass
3227         #6 components multi arrays with end array defined
3228         array=DataArrayDouble.New();
3229         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,
3230               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]
3231         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3232         f1.setEndArray(array);
3233         f1.checkCoherency();
3234         f2=f1.determinant();
3235         f2.checkCoherency();
3236         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3237         self.assertEqual(1,f2.getNumberOfComponents());
3238         self.assertEqual(9,f2.getNumberOfTuples());
3239         time2,it,order=f2.getTime()
3240         self.assertAlmostEqual(2.3,time2,12);
3241         self.assertEqual(5,it);
3242         self.assertEqual(6,order);
3243         time2,it,order=f2.getEndTime()
3244         self.assertAlmostEqual(3.8,time2,12);
3245         self.assertEqual(7,it);
3246         self.assertEqual(3,order);
3247         for i in xrange(9):
3248             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3249             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3250             pass
3251         #9 components
3252         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3253         f1.setTime(7.8,10,2);
3254         f1.setMesh(mesh1);
3255         array=DataArrayDouble.New();
3256         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]
3257         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3258         f1.setArray(array);
3259         #
3260         f1.checkCoherency();
3261         f2=f1.determinant();
3262         f2.checkCoherency();
3263         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3264         self.assertEqual(1,f2.getNumberOfComponents());
3265         self.assertEqual(5,f2.getNumberOfTuples());
3266         time2,it,order=f2.getTime()
3267         self.assertAlmostEqual(7.8,time2,12);
3268         self.assertEqual(10,it);
3269         self.assertEqual(2,order);
3270         for i in xrange(5):
3271             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3272             pass
3273         pass
3274
3275     def testEigenValues1(self):
3276         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3277         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3278         f1.setMesh(mesh1);
3279         array=DataArrayDouble.New();
3280         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]
3281         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3282         f1.setArray(array);
3283         f1.checkCoherency();
3284         #
3285         f2=f1.eigenValues();
3286         f2.checkCoherency();
3287         self.assertEqual(3,f2.getNumberOfComponents());
3288         self.assertEqual(5,f2.getNumberOfTuples());
3289         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3290         for i in xrange(5):
3291             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3292             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3293             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3294             pass
3295         pass
3296
3297     def testEigenVectors1(self):
3298         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3299         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3300         f1.setMesh(mesh1);
3301         array=DataArrayDouble.New();
3302         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]
3303         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3304         f1.setArray(array);
3305         f1.checkCoherency();
3306         #
3307         f2=f1.eigenVectors();
3308         f2.checkCoherency();
3309         self.assertEqual(9,f2.getNumberOfComponents());
3310         self.assertEqual(5,f2.getNumberOfTuples());
3311         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3312                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3313                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3314                    ]
3315         for i in xrange(5):
3316             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3317             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3318             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3319             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3320             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3321             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3322             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3323             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3324             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3325             pass
3326         #
3327         pass
3328
3329     def testInverse1(self):
3330         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3331         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3332         f1.setMesh(mesh1);
3333         array=DataArrayDouble.New();
3334         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]
3335         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3336         f1.setArray(array);
3337         f1.checkCoherency();
3338         #
3339         f2=f1.inverse();
3340         f2.checkCoherency();
3341         self.assertEqual(9,f2.getNumberOfComponents());
3342         self.assertEqual(5,f2.getNumberOfTuples());
3343         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3344         for i in xrange(5):
3345             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3346             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3347             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3348             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3349             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3350             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3351             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3352             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3353             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3354             pass
3355         #
3356         array=DataArrayDouble.New();
3357         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]
3358         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3359         f1.setArray(array);
3360         f1.checkCoherency();
3361         #
3362         f2=f1.inverse();
3363         f2.checkCoherency();
3364         self.assertEqual(6,f2.getNumberOfComponents());
3365         self.assertEqual(5,f2.getNumberOfTuples());
3366         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3367         for i in xrange(5):
3368             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3369             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3370             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3371             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3372             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3373             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3374             pass
3375         #
3376         array=DataArrayDouble.New();
3377         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]
3378         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3379         f1.setArray(array);
3380         f1.checkCoherency();
3381         #
3382         f2=f1.inverse();
3383         f2.checkCoherency();
3384         self.assertEqual(4,f2.getNumberOfComponents());
3385         self.assertEqual(5,f2.getNumberOfTuples());
3386         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3387         for i in xrange(5):
3388             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3389             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3390             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3391             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3392             pass
3393         #
3394         pass
3395
3396     def testTrace1(self):
3397         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3398         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3399         f1.setMesh(mesh1);
3400         array=DataArrayDouble.New();
3401         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]
3402         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3403         f1.setArray(array);
3404         f1.checkCoherency();
3405         #
3406         f2=f1.trace();
3407         f2.checkCoherency();
3408         self.assertEqual(1,f2.getNumberOfComponents());
3409         self.assertEqual(5,f2.getNumberOfTuples());
3410         for i in xrange(5):
3411             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3412             pass
3413         #
3414         array=DataArrayDouble.New();
3415         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]
3416         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3417         f1.setArray(array);
3418         f1.checkCoherency();
3419         #
3420         f2=f1.trace();
3421         f2.checkCoherency();
3422         self.assertEqual(1,f2.getNumberOfComponents());
3423         self.assertEqual(5,f2.getNumberOfTuples());
3424         for i in xrange(5):
3425             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3426             pass
3427         #
3428         array=DataArrayDouble.New();
3429         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]
3430         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3431         f1.setArray(array);
3432         f1.checkCoherency();
3433         #
3434         f2=f1.trace();
3435         f2.checkCoherency();
3436         self.assertEqual(1,f2.getNumberOfComponents());
3437         self.assertEqual(5,f2.getNumberOfTuples());
3438         for i in xrange(5):
3439             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3440             pass
3441         #
3442         pass
3443
3444     def testDeviator1(self):
3445         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3446         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3447         f1.setMesh(mesh1);
3448         array=DataArrayDouble.New();
3449         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 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]
3450         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3451         f1.setArray(array);
3452         f1.checkCoherency();
3453         #
3454         f2=f1.deviator();
3455         f2.checkCoherency();
3456         self.assertEqual(6,f2.getNumberOfComponents());
3457         self.assertEqual(5,f2.getNumberOfTuples());
3458         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3459         for i in xrange(5):
3460             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3461             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3462             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3463             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3464             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3465             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3466             pass
3467         #
3468         pass
3469
3470     def testMagnitude1(self):
3471         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3472         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3473         f1.setMesh(mesh1);
3474         array=DataArrayDouble.New();
3475         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]
3476         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3477         f1.setArray(array);
3478         f1.checkCoherency();
3479         #
3480         f2=f1.magnitude();
3481         f2.checkCoherency();
3482         self.assertEqual(1,f2.getNumberOfComponents());
3483         self.assertEqual(5,f2.getNumberOfTuples());
3484         for i in xrange(5):
3485             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3486             pass
3487         #
3488         pass
3489
3490     def testMaxPerTuple1(self):
3491         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3492         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3493         f1.setMesh(mesh1);
3494         array=DataArrayDouble.New();
3495         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]
3496         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3497         f1.setArray(array);
3498         f1.checkCoherency();
3499         #
3500         f2=f1.maxPerTuple();
3501         f2.checkCoherency();
3502         self.assertEqual(1,f2.getNumberOfComponents());
3503         self.assertEqual(5,f2.getNumberOfTuples());
3504         for i in xrange(5):
3505             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3506             pass
3507         #
3508         pass
3509
3510     def testChangeNbOfComponents(self):
3511         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3512         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3513         f1.setMesh(mesh1);
3514         array=DataArrayDouble.New();
3515         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]
3516         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3517         f1.setArray(array);
3518         f1.checkCoherency();
3519         #
3520         f1.changeNbOfComponents(3,7.77);
3521         f1.checkCoherency();
3522         self.assertEqual(3,f1.getNumberOfComponents());
3523         self.assertEqual(5,f1.getNumberOfTuples());
3524         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]
3525         for i in xrange(15):
3526             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3527             pass
3528         f1.changeNbOfComponents(4,7.77);
3529         f1.checkCoherency();
3530         self.assertEqual(4,f1.getNumberOfComponents());
3531         self.assertEqual(5,f1.getNumberOfTuples());
3532         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]
3533         for i in xrange(20):
3534             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3535             pass
3536         #
3537         pass
3538
3539     def testSortPerTuple1(self):
3540         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3541         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3542         f1.setMesh(mesh1);
3543         array=DataArrayDouble.New();
3544         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]
3545         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3546         f1.setArray(array);
3547         f1.checkCoherency();
3548         #
3549         f1.sortPerTuple(True);
3550         f1.checkCoherency();
3551         self.assertEqual(5,f1.getNumberOfComponents());
3552         self.assertEqual(5,f1.getNumberOfTuples());
3553         for i in xrange(5):
3554             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3555             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3556             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3557             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3558             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3559             pass
3560         #
3561         f1.sortPerTuple(False);
3562         f1.checkCoherency();
3563         self.assertEqual(5,f1.getNumberOfComponents());
3564         self.assertEqual(5,f1.getNumberOfTuples());
3565         for i in xrange(5):
3566             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3567             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3568             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3569             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3570             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3571             pass
3572         #
3573         pass
3574
3575     def testIsEqualWithoutConsideringStr1(self):
3576         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3577         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3578         #
3579         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3580         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3581         mesh2.setName("rr");
3582         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3583         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3584         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3585         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3586         mesh2.setName("");
3587         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3588         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3589         mesh2.getCoords().setInfoOnComponent(0,"tty");
3590         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3591         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3592         mesh2.getCoords().setInfoOnComponent(0,"");
3593         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3594         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3595         mesh2.getCoords().setInfoOnComponent(1,"tty");
3596         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3597         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3598         mesh2.getCoords().setInfoOnComponent(1,"");
3599         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3600         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3601         tmp=mesh2.getCoords().getIJ(0,3);
3602         mesh2.getCoords().setIJ(0,3,9999.);
3603         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3604         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3605         mesh2.getCoords().setIJ(0,3,tmp);
3606         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3607         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3608         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3609         mesh2.getNodalConnectivity().setIJ(0,4,0);
3610         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3611         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3612         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3613         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3614         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3615         #
3616         f1=mesh1.getMeasureField(True);
3617         f2=mesh2.getMeasureField(True);
3618         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3619         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3620         f2.setName("ftest");
3621         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3622         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3623         f1.setName("ftest");
3624         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3625         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3626         #
3627         f2.getArray().setInfoOnComponent(0,"eee");
3628         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3629         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3630         f2.getArray().setInfoOnComponent(0,"");
3631         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3632         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3633         #
3634         f2.getArray().setIJ(1,0,0.123);
3635         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3636         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3637         f2.getArray().setIJ(1,0,0.125);
3638         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3639         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3640         #
3641         pass
3642
3643     def testGetNodeIdsOfCell1(self):
3644         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3645         li=mesh1.getNodeIdsOfCell(1)
3646         expected1=[1, 4, 2]
3647         self.assertEqual(expected1,list(li))
3648         li=mesh1.getCoordinatesOfNode(4)
3649         self.assertEqual(2,len(li))
3650         self.assertAlmostEqual(0.2,li[0],13);
3651         self.assertAlmostEqual(0.2,li[1],13);
3652         li=mesh1.getCoords().getValuesAsTuple()
3653         self.assertEqual(9,len(li))
3654         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3655         self.assertEqual(6,len(li2))
3656         pass
3657
3658     def testGetEdgeRatioField1(self):
3659         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3660         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
3661         f1=m1.getEdgeRatioField();
3662         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
3663         self.assertEqual("us",f1.getTimeUnit())
3664         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3665         self.assertEqual(5,f1.getNumberOfTuples());
3666         self.assertEqual(1,f1.getNumberOfComponents());
3667         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3668         for i in xrange(5):
3669             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3670             pass
3671         #
3672         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3673         f1=m1.getEdgeRatioField();
3674         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3675         self.assertEqual(5,f1.getNumberOfTuples());
3676         self.assertEqual(1,f1.getNumberOfComponents());
3677         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3678         for i in xrange(5):
3679             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3680             pass
3681         pass
3682
3683     def testFillFromAnalytic3(self):
3684         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3685         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3686         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3687         f1.setMesh(m)
3688         f1.setName("myField");
3689         f1.fillFromAnalytic(1,"y+x");
3690         f1.checkCoherency();
3691         self.assertEqual(f1.getName(),"myField");
3692         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3693         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3694         self.assertEqual(1,f1.getNumberOfComponents());
3695         self.assertEqual(5,f1.getNumberOfTuples());
3696         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3697         tmp=f1.getArray().getValues();
3698         self.assertEqual(len(values1),len(tmp))
3699         for i in xrange(len(values1)):
3700             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3701             pass
3702         #
3703         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3704         f1.setMesh(m)
3705         f1.fillFromAnalytic(1,"y+2*x");
3706         f1.setEndTime(1.2,3,4);
3707         f1.checkCoherency();
3708         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3709         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3710         self.assertEqual(1,f1.getNumberOfComponents());
3711         self.assertEqual(9,f1.getNumberOfTuples());
3712         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3713         tmp=f1.getArray().getValues();
3714         self.assertEqual(len(values2),len(tmp))
3715         for i in xrange(len(values2)):
3716             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3717             pass
3718         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3719         f1.setMesh(m)
3720         f1.fillFromAnalytic(1,"2.*x+y");
3721         f1.setEndTime(1.2,3,4);
3722         f1.checkCoherency();
3723         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3724         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3725         self.assertEqual(1,f1.getNumberOfComponents());
3726         self.assertEqual(9,f1.getNumberOfTuples());
3727         tmp=f1.getArray().getValues();
3728         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3729         self.assertEqual(len(values2Bis),len(tmp))
3730         for i in xrange(len(values2Bis)):
3731             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3732             pass
3733         tmp=f1.getEndArray().getValues();
3734         self.assertEqual(len(values2Bis),len(tmp))
3735         for i in xrange(len(values2Bis)):
3736             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3737             pass
3738         #
3739         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3740         f1.setMesh(m)
3741         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3742         f1.checkCoherency();
3743         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3744         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3745         self.assertEqual(2,f1.getNumberOfComponents());
3746         self.assertEqual(9,f1.getNumberOfTuples());
3747         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]
3748         tmp=f1.getArray().getValues();
3749         self.assertEqual(len(values3),len(tmp))
3750         for i in xrange(len(values3)):
3751             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3752             pass
3753         values4=f1.accumulate();
3754         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3755         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3756         values4=f1.integral(True);
3757         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3758         self.assertTrue(abs(1.-values4[1])<1.e-12);
3759         #
3760         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3761         f1.setMesh(m);
3762         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3763         pass
3764
3765     def testFieldDoubleOpEqual1(self):
3766         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3767         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3768         self.assertRaises(InterpKernelException,f1.assign,0.07);
3769         f1.setMesh(m);
3770         f1.assign(0.07);
3771         f1.checkCoherency();
3772         self.assertEqual(1,f1.getNumberOfComponents());
3773         self.assertEqual(5,f1.getNumberOfTuples());
3774         for i in xrange(5):
3775             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3776             pass
3777         f1.assign(0.09);
3778         f1.checkCoherency();
3779         self.assertEqual(1,f1.getNumberOfComponents());
3780         self.assertEqual(5,f1.getNumberOfTuples());
3781         for i in xrange(5):
3782             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
3783             pass
3784         #
3785         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3786         f1.setEndTime(4.5,2,3);
3787         f1.setMesh(m);
3788         f1.assign(0.08);
3789         f1.checkCoherency();
3790         self.assertEqual(1,f1.getNumberOfComponents());
3791         self.assertEqual(9,f1.getNumberOfTuples());
3792         for i in xrange(9):
3793             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3794             pass
3795         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3796         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3797         for i in xrange(9):
3798             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3799             pass
3800         pass
3801
3802     def testAreaBary3D2(self):
3803         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3804                         -9.755591679144, 23.394927935279, 5.108794294848,
3805                         14.337630157832, 61.705351002702, 160.42422501908,
3806                         -27.273893776752, 167.567731083961, 192.830034145464,
3807                         99.857193154796,264.499264735586,-8.287335493412,
3808                         144.939882761126,156.38626563134,-31.896173894226,
3809                         161.34096835726,182.4654895809,73.832387065572,
3810                         132.680430393685,255.37973247196,96.15235602819];
3811         volHexa8=3258520.29637466;
3812         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3813
3814         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3815                          8.461744647847,76.653979804423,165.00018874933,
3816                          -27.273893776752,167.567731083961,192.830034145464,
3817                          106.586501038965,262.629609408327,13.124533008813,
3818                          155.465082847275,197.414118382622,78.408350795821,
3819                          132.680430393685,255.37973247196,96.15235602819];
3820         volPenta6=944849.868507338;
3821         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3822
3823         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3824                         -27.273893776752,167.567731083961,192.830034145464,
3825                         8.461744647847,76.653979804423,165.00018874933,
3826                         155.465082847275,197.414118382622,78.408350795821,
3827                         -68.199829618726,178.938498373416,62.608505919588];
3828         volPyra5=756943.92980254;
3829         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3830         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3831         coo=DataArrayDouble.New();
3832         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3833         coo.setValues(tmp,19,3);
3834         mesh.setCoords(coo);
3835         #
3836         tmpConn=[0,1,2,3,4,5,6,7]
3837         mesh.allocateCells(3);
3838         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3839         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3840         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3841         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3842         mesh.finishInsertingCells();
3843         mesh.checkCoherency();
3844         mesh.mergeNodes(1e-7)
3845         self.assertEqual(12,mesh.getNumberOfNodes());
3846         vols=mesh.getMeasureField(True);
3847         self.assertEqual(3,vols.getNumberOfTuples());
3848         self.assertEqual(1,vols.getNumberOfComponents());
3849         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3850         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3851         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3852         bary=mesh.getBarycenterAndOwner();
3853         self.assertEqual(3,bary.getNumberOfTuples());
3854         self.assertEqual(3,bary.getNumberOfComponents());
3855         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3856         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3857         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3858         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3859         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3860         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3861         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3862         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3863         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3864         pass
3865
3866     def testGetMeasureFieldCMesh1(self):
3867         m=MEDCouplingCMesh.New();
3868         da=DataArrayDouble.New();
3869         discX=[2.3,3.4,5.8,10.2]
3870         discY=[12.3,23.4,45.8]
3871         discZ=[-0.7,1.2,1.25,2.13,2.67]
3872         da.setValues(discX,4,1);
3873         m.setCoordsAt(0,da);
3874         m.checkCoherency();
3875         self.assertEqual(4,m.getNumberOfNodes());
3876         self.assertEqual(3,m.getNumberOfCells());
3877         self.assertEqual(1,m.getSpaceDimension());
3878         f=m.getMeasureField(True);
3879         self.assertEqual(3,f.getNumberOfTuples());
3880         self.assertEqual(1,f.getNumberOfComponents());
3881         expected1=[1.1,2.4,4.4]
3882         for i in xrange(3):
3883             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
3884             pass
3885         coords=m.getCoordinatesAndOwner();
3886         self.assertEqual(4,coords.getNumberOfTuples());
3887         self.assertEqual(1,coords.getNumberOfComponents());
3888         for i in xrange(4):
3889             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
3890             pass
3891         coords=m.getBarycenterAndOwner();
3892         self.assertEqual(3,coords.getNumberOfTuples());
3893         self.assertEqual(1,coords.getNumberOfComponents());
3894         expected1_3=[2.85,4.6,8.]
3895         for i in xrange(3):
3896             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
3897             pass
3898         #
3899         da=DataArrayDouble.New();
3900         da.setValues(discY,3,1);
3901         m.setCoordsAt(1,da);
3902         m.checkCoherency();
3903         self.assertEqual(12,m.getNumberOfNodes());
3904         self.assertEqual(6,m.getNumberOfCells());
3905         self.assertEqual(2,m.getSpaceDimension());
3906         f=m.getMeasureField(True);
3907         self.assertEqual(6,f.getNumberOfTuples());
3908         self.assertEqual(1,f.getNumberOfComponents());
3909         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
3910         for i in xrange(6):
3911             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
3912             pass
3913         coords=m.getCoordinatesAndOwner();
3914         self.assertEqual(12,coords.getNumberOfTuples());
3915         self.assertEqual(2,coords.getNumberOfComponents());
3916         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]
3917         for i in xrange(24):
3918             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
3919             pass
3920         coords=m.getBarycenterAndOwner();
3921         self.assertEqual(6,coords.getNumberOfTuples());
3922         self.assertEqual(2,coords.getNumberOfComponents());
3923         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
3924         for i in xrange(12):
3925             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
3926             pass
3927         #
3928         da=DataArrayDouble.New();
3929         da.setValues(discZ,5,1);
3930         m.setCoordsAt(2,da);
3931         m.checkCoherency();
3932         self.assertEqual(60,m.getNumberOfNodes());
3933         self.assertEqual(24,m.getNumberOfCells());
3934         self.assertEqual(3,m.getSpaceDimension());
3935         f=m.getMeasureField(True);
3936         self.assertEqual(24,f.getNumberOfTuples());
3937         self.assertEqual(1,f.getNumberOfComponents());
3938         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]
3939         for i in xrange(24):
3940             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
3941             pass
3942         coords=m.getCoordinatesAndOwner();
3943         self.assertEqual(60,coords.getNumberOfTuples());
3944         self.assertEqual(3,coords.getNumberOfComponents());
3945         expected3_2=[
3946             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,
3947             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,
3948             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,
3949             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,
3950             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];
3951         for i in xrange(180):
3952             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
3953             pass
3954         coords=m.getBarycenterAndOwner();
3955         self.assertEqual(24,coords.getNumberOfTuples());
3956         self.assertEqual(3,coords.getNumberOfComponents());
3957         expected3_3=[
3958             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,
3959             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,
3960             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,
3961             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];
3962         for i in xrange(72):
3963             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
3964             pass
3965         pass
3966
3967     def testFieldDoubleZipCoords1(self):
3968         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
3969         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
3970         f.getArray().setInfoOnComponent(0,"titi");
3971         f.getArray().setInfoOnComponent(1,"tutu");
3972         f.checkCoherency();
3973         self.assertEqual(18,f.getNumberOfTuples());
3974         self.assertEqual(2,f.getNumberOfComponents());
3975         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]
3976         for i in xrange(36):
3977             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
3978             pass
3979         self.assertTrue(f.zipCoords());
3980         f.checkCoherency();
3981         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]
3982         for i in xrange(30):
3983             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3984             pass
3985         self.assertTrue(not f.zipCoords());
3986         f.checkCoherency();
3987         for i in xrange(30):
3988             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3989             pass
3990         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
3991         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
3992         pass
3993
3994     def testFieldDoubleZipConnectivity1(self):
3995         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3996         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
3997         cells1=[2,3,4]
3998         m3_1=m2.buildPartOfMySelf(cells1,True);
3999         m3=m3_1;
4000         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
4001         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
4002         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
4003         #
4004         self.assertEqual(10,m6.getNumberOfCells());
4005         self.assertEqual(22,m6.getNumberOfNodes());
4006         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
4007         self.assertEqual(9,m6.getNumberOfNodes());
4008         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
4009         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
4010         self.assertEqual(10,f.getNumberOfTuples());
4011         self.assertEqual(2,f.getNumberOfComponents());
4012         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4013                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
4014                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4015         for i in xrange(20):
4016             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4017             pass
4018         f.getArray().setInfoOnComponent(0,"titi");
4019         f.getArray().setInfoOnComponent(1,"tutu");
4020         f.checkCoherency();
4021         self.assertTrue(f.zipConnectivity(0));
4022         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4023                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4024         self.assertEqual(7,f.getNumberOfTuples());
4025         self.assertEqual(2,f.getNumberOfComponents());
4026         for i in xrange(14):
4027             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4028             pass
4029         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4030         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4031         self.assertTrue(not f.zipConnectivity(0));
4032         #
4033         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,
4034                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
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         self.assertTrue(f2.zipConnectivity(0));
4041         self.assertEqual(9,f2.getNumberOfTuples());
4042         self.assertEqual(2,f2.getNumberOfComponents());
4043         for i in xrange(18):
4044             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4045             pass
4046         pass
4047
4048     def testDaDoubleRenumber1(self):
4049         a=DataArrayDouble.New();
4050         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]
4051         a.setValues(arr1,7,2);
4052         a.setInfoOnComponent(0,"toto");
4053         a.setInfoOnComponent(1,"tata");
4054         #
4055         arr2=[3,1,0,6,5,4,2]
4056         b=a.renumber(arr2);
4057         self.assertEqual(7,b.getNumberOfTuples());
4058         self.assertEqual(2,b.getNumberOfComponents());
4059         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4060         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4061         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]
4062         for i in xrange(14):
4063             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4064             pass
4065         #
4066         c=DataArrayInt.New();
4067         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4068         c.setValues(arr3,7,2);
4069         c.setInfoOnComponent(0,"toto");
4070         c.setInfoOnComponent(1,"tata");
4071         d=c.renumber(arr2);
4072         self.assertEqual(7,d.getNumberOfTuples());
4073         self.assertEqual(2,d.getNumberOfComponents());
4074         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4075         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4076         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4077         for i in xrange(14):
4078             self.assertEqual(expected2[i],d.getIJ(0,i));
4079             pass
4080         pass
4081
4082     def testDaDoubleRenumberAndReduce1(self):
4083         a=DataArrayDouble.New();
4084         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]
4085         a.setValues(arr1,7,2);
4086         a.setInfoOnComponent(0,"toto");
4087         a.setInfoOnComponent(1,"tata");
4088         #
4089         arr2=[2,-1,1,-1,0,4,3]
4090         b=a.renumberAndReduce(arr2,5);
4091         self.assertEqual(5,b.getNumberOfTuples());
4092         self.assertEqual(2,b.getNumberOfComponents());
4093         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4094         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4095         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4096         for i in xrange(10):
4097             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4098             pass
4099         #
4100         c=DataArrayInt.New();
4101         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4102         c.setValues(arr3,7,2);
4103         c.setInfoOnComponent(0,"toto");
4104         c.setInfoOnComponent(1,"tata");
4105         d=c.renumberAndReduce(arr2,5);
4106         self.assertEqual(5,d.getNumberOfTuples());
4107         self.assertEqual(2,d.getNumberOfComponents());
4108         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4109         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4110         expected2=[5,15,3,13,1,11,7,17,6,16]
4111         for i in xrange(10):
4112             self.assertEqual(expected2[i],d.getIJ(0,i));
4113             pass
4114         pass
4115
4116     def testDaDoubleRenumberInPlace1(self):
4117         a=DataArrayDouble.New();
4118         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]
4119         a.setValues(arr1,7,2);
4120         #
4121         arr2=[3,1,0,6,5,4,2]
4122         a.renumberInPlace(arr2);
4123         self.assertEqual(7,a.getNumberOfTuples());
4124         self.assertEqual(2,a.getNumberOfComponents());
4125         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]
4126         for i in xrange(14):
4127             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4128             pass
4129         #
4130         c=DataArrayInt.New();
4131         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4132         c.setValues(arr3,7,2);
4133         c.renumberInPlace(arr2);
4134         self.assertEqual(7,c.getNumberOfTuples());
4135         self.assertEqual(2,c.getNumberOfComponents());
4136         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4137         for i in xrange(14):
4138             self.assertEqual(expected2[i],c.getIJ(0,i));
4139             pass
4140         pass
4141
4142     def testDaDoubleRenumberR1(self):
4143         a=DataArrayDouble.New();
4144         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]
4145         a.setValues(arr1,7,2);
4146         a.setInfoOnComponent(0,"toto");
4147         a.setInfoOnComponent(1,"tata");
4148         #
4149         arr2=[3,1,0,6,5,4,2]
4150         b=a.renumberR(arr2);
4151         self.assertEqual(7,b.getNumberOfTuples());
4152         self.assertEqual(2,b.getNumberOfComponents());
4153         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4154         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4155         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]
4156         for i in xrange(14):
4157             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4158             pass
4159         #
4160         c=DataArrayInt.New();
4161         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4162         c.setValues(arr3,7,2);
4163         c.setInfoOnComponent(0,"toto");
4164         c.setInfoOnComponent(1,"tata");
4165         d=c.renumberR(arr2);
4166         self.assertEqual(7,d.getNumberOfTuples());
4167         self.assertEqual(2,d.getNumberOfComponents());
4168         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4169         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4170         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4171         for i in xrange(14):
4172             self.assertEqual(expected2[i],d.getIJ(0,i));
4173             pass
4174         pass
4175
4176     def testDaDoubleRenumberInPlaceR1(self):
4177         a=DataArrayDouble.New();
4178         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]
4179         a.setValues(arr1,7,2);
4180         #
4181         arr2=[3,1,0,6,5,4,2]
4182         a.renumberInPlaceR(arr2);
4183         self.assertEqual(7,a.getNumberOfTuples());
4184         self.assertEqual(2,a.getNumberOfComponents());
4185         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]
4186         for i in xrange(14):
4187             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4188             pass
4189         #
4190         c=DataArrayInt.New();
4191         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4192         c.setValues(arr3,7,2);
4193         c.renumberInPlaceR(arr2);
4194         self.assertEqual(7,c.getNumberOfTuples());
4195         self.assertEqual(2,c.getNumberOfComponents());
4196         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4197         for i in xrange(14):
4198             self.assertEqual(expected2[i],c.getIJ(0,i));
4199             pass
4200         pass
4201
4202     def testDaDoubleSelectByTupleId1(self):
4203         a=DataArrayDouble.New();
4204         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]
4205         a.setValues(arr1,7,2);
4206         a.setInfoOnComponent(0,"toto");
4207         a.setInfoOnComponent(1,"tata");
4208         #
4209         arr2=[4,2,0,6,5]
4210         b=a.selectByTupleId(arr2);
4211         self.assertEqual(5,b.getNumberOfTuples());
4212         self.assertEqual(2,b.getNumberOfComponents());
4213         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4214         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4215         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4216         for i in xrange(10):
4217             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4218             pass
4219         #
4220         c=DataArrayInt.New();
4221         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4222         c.setValues(arr3,7,2);
4223         c.setInfoOnComponent(0,"toto");
4224         c.setInfoOnComponent(1,"tata");
4225         d=c.selectByTupleId(arr2);
4226         self.assertEqual(5,d.getNumberOfTuples());
4227         self.assertEqual(2,d.getNumberOfComponents());
4228         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4229         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4230         expected2=[5,15,3,13,1,11,7,17,6,16]
4231         for i in xrange(10):
4232             self.assertEqual(expected2[i],d.getIJ(0,i));
4233             pass
4234         pass
4235
4236     def testDaDoubleGetMinMaxValues1(self):
4237         a=DataArrayDouble.New();
4238         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4239         a.setValues(arr1,9,1);
4240         m,where=a.getMaxValue();
4241         self.assertEqual(1,where);
4242         self.assertAlmostEqual(4.56,m,12);
4243         m,ws=a.getMaxValue2();
4244         self.assertAlmostEqual(4.56,m,12);
4245         self.assertEqual(3,ws.getNumberOfTuples());
4246         self.assertEqual(1,ws.getNumberOfComponents());
4247         expected1=[1,4,8]
4248         for i in xrange(3):
4249             self.assertEqual(expected1[i],ws.getIJ(i,0));
4250             pass
4251         a=DataArrayDouble.New();
4252         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4253         a.setValues(arr2,9,1);
4254         m,where=a.getMinValue();
4255         self.assertEqual(1,where);
4256         self.assertAlmostEqual(-4.56,m,12);
4257         m,ws=a.getMinValue2();
4258         self.assertAlmostEqual(-4.56,m,12);
4259         self.assertEqual(3,ws.getNumberOfTuples());
4260         self.assertEqual(1,ws.getNumberOfComponents());
4261         for i in xrange(3):
4262             self.assertEqual(expected1[i],ws.getIJ(i,0));
4263             pass
4264         pass
4265
4266     def testFieldDoubleGetMinMaxValues2(self):
4267         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4268         self.assertEqual(18,m2.getNumberOfCells());
4269         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]
4270         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4271         a=DataArrayDouble.New();
4272         a.setValues(arr1,18,1);
4273         f.setArray(a);
4274         f.setMesh(m2);
4275         #
4276         f.checkCoherency();
4277         m=f.getMaxValue();
4278         self.assertAlmostEqual(8.71,m,12);
4279         m,ws=f.getMaxValue2();
4280         self.assertAlmostEqual(8.71,m,12);
4281         self.assertEqual(4,ws.getNumberOfTuples());
4282         self.assertEqual(1,ws.getNumberOfComponents());
4283         expected1=[0,3,7,17]
4284         for i in xrange(4):
4285             self.assertEqual(expected1[i],ws.getIJ(i,0));
4286             pass
4287         #
4288         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]
4289         a.setValues(arr2,18,1);
4290         f.checkCoherency();
4291         m=f.getMinValue();
4292         self.assertAlmostEqual(-8.71,m,12);
4293         m,ws=f.getMinValue2();
4294         self.assertAlmostEqual(-8.71,m,12);
4295         self.assertEqual(4,ws.getNumberOfTuples());
4296         self.assertEqual(1,ws.getNumberOfComponents());
4297         for i in xrange(4):
4298             self.assertEqual(expected1[i],ws.getIJ(i,0));
4299             pass
4300         pass
4301
4302     def testBuildUnstructuredCMesh1(self):
4303         m=MEDCouplingCMesh.New();
4304         da=DataArrayDouble.New();
4305         discX=[2.3,3.4,5.8,10.2]
4306         discY=[12.3,23.4,45.8]
4307         discZ=[-0.7,1.2,1.25,2.13,2.67]
4308         da.setValues(discX,4,1);
4309         m.setCoordsAt(0,da);
4310         m.checkCoherency();
4311         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4312         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4313         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4314         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4315         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4316         #
4317         m2=m.buildUnstructured();
4318         m2.checkCoherency();
4319         f1=m.getMeasureField(False);
4320         f2=m2.getMeasureField(False);
4321         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4322         self.assertEqual(f1.getNumberOfTuples(),3);
4323         self.assertEqual(f2.getNumberOfTuples(),3);
4324         self.assertEqual(1,m2.getMeshDimension());
4325         self.assertEqual(1,m2.getSpaceDimension());
4326         for i in xrange(3):
4327             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4328             pass
4329         da=DataArrayDouble.New();
4330         da.setValues(discY,3,1);
4331         m.setCoordsAt(1,da);
4332         #
4333         m2=m.buildUnstructured();
4334         m2.checkCoherency();
4335         f1=m.getMeasureField(False);
4336         f2=m2.getMeasureField(False);
4337         self.assertEqual(f1.getNumberOfTuples(),6);
4338         self.assertEqual(f2.getNumberOfTuples(),6);
4339         self.assertEqual(2,m2.getMeshDimension());
4340         self.assertEqual(2,m2.getSpaceDimension());
4341         for i in xrange(6):
4342             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4343             pass
4344         #
4345         da=DataArrayDouble.New();
4346         da.setValues(discZ,5,1);
4347         m.setCoordsAt(2,da);
4348         m2=m.buildUnstructured();
4349         m2.checkCoherency();
4350         f1=m.getMeasureField(False);
4351         f2=m2.getMeasureField(False);
4352         self.assertEqual(f1.getNumberOfTuples(),24);
4353         self.assertEqual(f2.getNumberOfTuples(),24);
4354         self.assertEqual(3,m2.getMeshDimension());
4355         self.assertEqual(3,m2.getSpaceDimension());
4356         for i in xrange(24):
4357             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4358             pass
4359         #
4360         pos1=[5.,30.,2.]
4361         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4362         #
4363         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4364         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4365         #
4366         pt=[2.4,12.7,-3.4]
4367         m.scale(pt,3.7);
4368         m3=m.buildUnstructured();
4369         m2.scale(pt,3.7);
4370         self.assertTrue(m3.isEqual(m2,1e-12));
4371         pass
4372
4373     def testDataArrayIntInvertO2NNO21(self):
4374         arr1=[2,0,4,1,5,3]
4375         da=DataArrayInt.New();
4376         da.setValues(arr1,6,1);
4377         da2=da.invertArrayO2N2N2O(6);
4378         self.assertEqual(6,da2.getNumberOfTuples());
4379         self.assertEqual(1,da2.getNumberOfComponents());
4380         expected1=[1,3,0,5,2,4]
4381         for i in xrange(6):
4382             self.assertEqual(expected1[i],da2.getIJ(i,0));
4383             pass
4384         da3=da2.invertArrayN2O2O2N(6);
4385         for i in xrange(6):
4386             self.assertEqual(arr1[i],da3.getIJ(i,0));
4387             pass
4388         #
4389         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4390         da=DataArrayInt.New();
4391         da.setValues(arr2,10,1);
4392         da2=da.invertArrayO2N2N2O(6);
4393         self.assertEqual(6,da2.getNumberOfTuples());
4394         self.assertEqual(1,da2.getNumberOfComponents());
4395         expected2=[5,7,8,0,3,2]
4396         for i in xrange(6):
4397             self.assertEqual(expected2[i],da2.getIJ(i,0));
4398             pass
4399         da3=da2.invertArrayN2O2O2N(10);
4400         for i in xrange(10):
4401             self.assertEqual(arr2[i],da3.getIJ(i,0));
4402             pass
4403         pass
4404
4405     def testKeepSetSelectedComponent1(self):
4406         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4407         a1=DataArrayDouble.New();
4408         a1.setValues(arr1,5,4);
4409         expp=[21.,22.,23.,24.]
4410         self.assertEqual(4,len(a1.getTuple(2)));
4411         for i in xrange(4):
4412             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4413             pass
4414         a1.setInfoOnComponent(0,"aaaa");
4415         a1.setInfoOnComponent(1,"bbbb");
4416         a1.setInfoOnComponent(2,"cccc");
4417         a1.setInfoOnComponent(3,"dddd");
4418         arr2V=[1,2,1,2,0,0]
4419         a2=a1.keepSelectedComponents(arr2V);
4420         self.assertEqual(6,a2.getNumberOfComponents());
4421         self.assertEqual(5,a2.getNumberOfTuples());
4422         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4423         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4424         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4425         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4426         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4427         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4428         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.]
4429         for i in xrange(30):
4430             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4431             pass
4432         a3=a1.convertToIntArr();
4433         self.assertEqual([21,22,23,24],a3.getTuple(2))
4434         a4=a3.keepSelectedComponents(arr2V);
4435         self.assertEqual(6,a4.getNumberOfComponents());
4436         self.assertEqual(5,a4.getNumberOfTuples());
4437         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4438         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4439         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4440         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4441         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4442         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4443         for i in xrange(30):
4444             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4445             pass
4446         # setSelectedComponents
4447         arr3V=[3,2]
4448         a5=a1.keepSelectedComponents(arr3V);
4449         a5.setInfoOnComponent(0,"eeee");
4450         a5.setInfoOnComponent(1,"ffff");
4451         arr4V=[1,2]
4452         a2.setSelectedComponents(a5,arr4V);
4453         self.assertEqual(6,a2.getNumberOfComponents());
4454         self.assertEqual(5,a2.getNumberOfTuples());
4455         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4456         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4457         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4458         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4459         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4460         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4461         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.]
4462         for i in xrange(30):
4463             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4464             pass
4465         a6=a5.convertToIntArr();
4466         a6.setInfoOnComponent(0,"eeee");
4467         a6.setInfoOnComponent(1,"ffff");
4468         a4.setSelectedComponents(a6,arr4V);
4469         self.assertEqual(6,a4.getNumberOfComponents());
4470         self.assertEqual(5,a4.getNumberOfTuples());
4471         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4472         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4473         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4474         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4475         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4476         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4477         for i in xrange(30):
4478             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4479             pass
4480         # test of throw
4481         arr5V=[2,3,6]
4482         arr6V=[2,7,5]
4483         arr7V=[2,1,4,6]
4484         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4485         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4486         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4487         arr7V=arr7V[0:3]
4488         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4489         #
4490         pass
4491
4492     def testKeepSetSelectedComponent2(self):
4493         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4494         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4495         a1=DataArrayDouble.New();
4496         a1.setValues(arr1,5,4);
4497         a1.setInfoOnComponent(0,"aaaa");
4498         a1.setInfoOnComponent(1,"bbbb");
4499         a1.setInfoOnComponent(2,"cccc");
4500         a1.setInfoOnComponent(3,"dddd");
4501         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4502         f1.setTime(2.3,4,5);
4503         f1.setMesh(m1);
4504         f1.setName("f1");
4505         f1.setArray(a1);
4506         f1.checkCoherency();
4507         #
4508         arr2V=[1,2,1,2,0,0]
4509         f2=f1.keepSelectedComponents(arr2V);
4510         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4511         t,dt,it=f2.getTime()
4512         self.assertAlmostEqual(2.3,t,13);
4513         self.assertEqual(4,dt);
4514         self.assertEqual(5,it);
4515         f2.checkCoherency();
4516         self.assertEqual(6,f2.getNumberOfComponents());
4517         self.assertEqual(5,f2.getNumberOfTuples());
4518         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4519         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4520         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4521         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4522         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4523         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4524         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.]
4525         for i in xrange(30):
4526             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4527             pass
4528         #setSelectedComponents
4529         arr3V=[3,2]
4530         f5=f1.keepSelectedComponents(arr3V);
4531         f5.setTime(6.7,8,9);
4532         f5.getArray().setInfoOnComponent(0,"eeee");
4533         f5.getArray().setInfoOnComponent(1,"ffff");
4534         f5.checkCoherency();
4535         arr4V=[1,2]
4536         f2.setSelectedComponents(f5,arr4V);
4537         self.assertEqual(6,f2.getNumberOfComponents());
4538         self.assertEqual(5,f2.getNumberOfTuples());
4539         f2.checkCoherency();
4540         t,dt,it=f2.getTime()
4541         self.assertAlmostEqual(2.3,t,13);
4542         self.assertEqual(4,dt);
4543         self.assertEqual(5,it);
4544         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4545         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4546         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4547         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4548         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4549         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4550         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.]
4551         for i in xrange(30):
4552             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4553             pass
4554         #
4555         pass
4556
4557     def testElementaryDAThrowAndSpecialCases(self):
4558         da=DataArrayInt.New();
4559         self.assertRaises(InterpKernelException, da.checkAllocated);
4560         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4561         self.assertRaises(InterpKernelException, da.iota, 1);
4562         da.alloc(7,1);
4563         da.fillWithValue(11); #11,11,11,11...
4564         da.iota(10); #10,11,12,13...
4565
4566         db=DataArrayInt.New();
4567         db.alloc(7,2);
4568
4569         dbl2=DataArrayDouble.New();
4570         dbl2.alloc(7,2);
4571         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4572         self.assertRaises(InterpKernelException, dbl2.sort);
4573         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4574
4575         dbl=DataArrayDouble.New();
4576         #DataArrayDouble not allocated yet
4577         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4578         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4579         self.assertRaises(InterpKernelException, dbl.sort);
4580         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4581         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4582
4583         dbl.alloc(7,1);
4584         dbl.iota(10.);
4585         self.assertTrue(not dbl.isUniform(10.,1e-15));
4586         dbl.sort();
4587         self.assertTrue(dbl.isMonotonic(True, .99));
4588         self.assertTrue(dbl.isMonotonic(True, -.99));
4589         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4590         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4591         dbl.reverse();
4592         self.assertTrue(dbl.isMonotonic(False, .99));
4593         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4594         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4595
4596         dc=DataArrayInt.New();
4597         dc.alloc(14,1);
4598
4599         dd=DataArrayDouble.New();
4600         self.assertRaises(InterpKernelException, dd.checkAllocated);
4601         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4602         self.assertRaises(InterpKernelException, dd.iota, 1.);
4603         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4604
4605         dd.alloc(0,1); #Allocated but nbOfElements==0!
4606         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4607         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4608         dd.fillWithValue(11); #?!...ok
4609         dd.iota(10); #?!...ok
4610         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4611         self.assertTrue(dd.isMonotonic(False, 1.));
4612
4613         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4614         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4615         cIds=[2,2]
4616         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4617         cIds[0]=1;
4618         cIds[0]=-1;
4619         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4620
4621         info=["infoOfOneComponent"]*2;
4622         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4623         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4624         db.setInfoOnComponents(info);
4625
4626         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4627         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4628         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4629         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4630         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4631         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4632         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4633
4634         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4635         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4636         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4637         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4638
4639         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4640         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4641         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4642         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4643
4644         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4645         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4646         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4647
4648         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4649         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4650
4651         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4652         db.checkNbOfElems(7*2,"theMessageInThrow");
4653
4654         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4655         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4656         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4657         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4658         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4659
4660         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4661         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4662         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4663
4664         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4665         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4666         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4667
4668         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4669         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4670         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4671         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4672         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4673
4674         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4675         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4676
4677         dbl3=DataArrayDouble.New();
4678         dbl3.alloc(6,2);
4679         dbl3.fillWithValue(11.);
4680         #bad number of components
4681         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4682         self.assertRaises(InterpKernelException, dd.getMaxValue);
4683         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4684         self.assertRaises(InterpKernelException, dd.getMinValue);
4685         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4686         self.assertRaises(InterpKernelException, dd.getAverageValue);
4687         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4688         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4689         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4690         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4691         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4692         self.assertRaises(InterpKernelException, dbl3.determinant);
4693         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4694         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4695         self.assertRaises(InterpKernelException, dbl3.inverse);
4696         self.assertRaises(InterpKernelException, dbl3.trace);
4697         self.assertRaises(InterpKernelException, dbl3.deviator);
4698
4699         dbl3.setIJ(5,1,12.);
4700         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4701         self.assertTrue(dbl3.getMinValueInArray()==11.);
4702
4703         db.fillWithValue(100); #bad Ids
4704         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4705         db.fillWithValue(-1); #bad Ids
4706         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4707         db.fillWithValue(6); #bad Ids for dbl3
4708         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4709
4710         dbl3.checkNoNullValues();
4711         dbl3.setIJ(5,0,0.);
4712         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4713         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4714         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4715         a=[]
4716         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4717         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4718
4719         a=[dbl2,dbl]; #Nb of components mismatch
4720         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4721
4722         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4723
4724         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4725         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4726         dbl4=DataArrayDouble.New();
4727         dbl4.alloc(6,3);
4728         dbl5=DataArrayDouble.New();
4729         dbl5.alloc(7,3);
4730         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4731
4732         a[0]=dbl4; #Nb of tuple mismatch
4733         a[1]=dbl5; #Nb of tuple mismatch
4734         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4735         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4736         pass
4737
4738     def testDAIGetIdsEqual1(self):
4739         tab1=[5,-2,-4,-2,3,2,-2];
4740         da=DataArrayInt.New();
4741         da.setValues(tab1,7,1);
4742         da2=da.getIdsEqual(-2);
4743         self.assertEqual(3,da2.getNumberOfTuples());
4744         self.assertEqual(1,da2.getNumberOfComponents());
4745         expected1=[1,3,6];
4746         self.assertEqual(expected1,da2.getValues());
4747         pass
4748
4749     def testDAIGetIdsEqualList1(self):
4750         tab1=[5,-2,-4,-2,3,2,-2];
4751         da=DataArrayInt.New();
4752         da.setValues(tab1,7,1);
4753         da2=da.getIdsEqualList([3,-2,0]);
4754         self.assertEqual(4,da2.getNumberOfTuples());
4755         self.assertEqual(1,da2.getNumberOfComponents());
4756         expected1=[1,3,4,6];
4757         self.assertEqual(expected1,da2.getValues());
4758         pass
4759
4760     def testDAFromNoInterlace1(self):
4761         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4762         da=DataArrayInt.New();
4763         da.setValues(tab1,5,3);
4764         da2=da.fromNoInterlace();
4765         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4766         self.assertEqual(5,da2.getNumberOfTuples());
4767         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4768         self.assertEqual(expected1,da2.getValues());
4769         da3=da.convertToDblArr();
4770         da4=da3.fromNoInterlace();
4771         self.assertEqual(5,da4.getNumberOfTuples());
4772         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4773         for i in xrange(15):
4774             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4775             pass
4776         pass
4777
4778     def testDAToNoInterlace1(self):
4779         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4780         da=DataArrayInt.New();
4781         da.setValues(tab1,5,3);
4782         da2=da.toNoInterlace();
4783         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4784         self.assertEqual(5,da2.getNumberOfTuples());
4785         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4786         self.assertEqual(expected1,da2.getValues());
4787         da3=da.convertToDblArr();
4788         da4=da3.toNoInterlace();
4789         self.assertEqual(5,da4.getNumberOfTuples());
4790         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4791         for i in xrange(15):
4792             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4793             pass
4794         pass
4795
4796     def testDAIsUniform1(self):
4797         tab1=[1,1,1,1,1]
4798         da=DataArrayInt.New();
4799         da.setValues(tab1,5,1);
4800         self.assertTrue(da.isUniform(1));
4801         da.setIJ(2,0,2);
4802         self.assertTrue(not da.isUniform(1));
4803         da.setIJ(2,0,1);
4804         self.assertTrue(da.isUniform(1));
4805         da2=da.convertToDblArr();
4806         self.assertTrue(da2.isUniform(1.,1.e-12));
4807         da2.setIJ(1,0,1.+1.e-13);
4808         self.assertTrue(da2.isUniform(1.,1.e-12));
4809         da2.setIJ(1,0,1.+1.e-11);
4810         self.assertTrue(not da2.isUniform(1.,1.e-12));
4811         pass
4812
4813     def testDADFromPolarToCart1(self):
4814         tab1=[2.,0.2,2.5,0.7]
4815         da=DataArrayDouble.New();
4816         da.setValues(tab1,2,2);
4817         da2=da.fromPolarToCart();
4818         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4819         for i in xrange(4):
4820             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4821             pass
4822         pass
4823
4824     def testDADFromCylToCart1(self):
4825         tab1=[2.,0.2,4.,2.5,0.7,9.]
4826         da=DataArrayDouble.New();
4827         da.setValues(tab1,2,3);
4828         da2=da.fromCylToCart();
4829         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4830         for i in xrange(6):
4831             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4832             pass
4833         pass
4834
4835     def testDADFromSpherToCart1(self):
4836         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4837         da=DataArrayDouble.New();
4838         da.setValues(tab1,2,3);
4839         da2=da.fromSpherToCart();
4840         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4841         for i in xrange(6):
4842             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4843             pass
4844         pass
4845
4846     def testUnPolyze1(self):
4847         elts=[0,1,2,3,4,5,6,7]
4848         eltsV=elts;
4849         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4850         mesh.convertToPolyTypes(eltsV);
4851         mesh.unPolyze();
4852         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4853         mesh.checkCoherency();
4854         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4855         mesh.convertToPolyTypes(eltsV);
4856         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4857         mesh.getNodalConnectivity().setIJ(0,6,10);
4858         mesh.getNodalConnectivity().setIJ(0,7,9);
4859         mesh.getNodalConnectivity().setIJ(0,8,12);
4860         mesh.getNodalConnectivity().setIJ(0,9,13);
4861         mesh.unPolyze();
4862         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4863         mesh.convertToPolyTypes(eltsV);
4864         mesh.getNodalConnectivity().setIJ(0,6,12);
4865         mesh.getNodalConnectivity().setIJ(0,7,13);
4866         mesh.getNodalConnectivity().setIJ(0,8,10);
4867         mesh.getNodalConnectivity().setIJ(0,9,9);
4868         mesh.unPolyze();
4869         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4870         mesh.convertToPolyTypes(eltsV);
4871         mesh.getNodalConnectivity().setIJ(0,6,12);
4872         mesh.getNodalConnectivity().setIJ(0,7,10);
4873         mesh.getNodalConnectivity().setIJ(0,8,13);
4874         mesh.getNodalConnectivity().setIJ(0,9,9);
4875         mesh.unPolyze();
4876         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4877         # Test for 2D mesh
4878         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4879         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
4880         eltsV=eltsV[:5];
4881         mesh.convertToPolyTypes(eltsV);
4882         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4883         mesh.unPolyze();
4884         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4885         pass
4886
4887     def testConvertDegeneratedCells1(self):
4888         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4889         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]
4890         mesh.allocateCells(4);
4891         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
4892         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
4893         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
4894         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
4895         mesh.finishInsertingCells();
4896         mesh.checkCoherency();
4897         self.assertEqual(4,mesh.getNumberOfCells());
4898         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
4899         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
4900         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
4901         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
4902         f1=mesh.getMeasureField(True);
4903         mesh.convertDegeneratedCells();
4904         mesh.checkCoherency();
4905         f2=mesh.getMeasureField(True);
4906         self.assertEqual(4,mesh.getNumberOfCells());
4907         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
4908         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
4909         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
4910         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
4911         for i in xrange(4):
4912             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
4913             pass
4914         pass
4915
4916     def testGetNodeIdsNearPoints1(self):
4917         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4918         coords=mesh.getCoords();
4919         tmp=DataArrayDouble.New();
4920         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
4921         tmp.setValues(vals,3,2);
4922         tmp2=DataArrayDouble.Aggregate(coords,tmp);
4923         mesh.setCoords(tmp2);
4924         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
4925         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
4926         self.assertEqual([4,9,11],c.getValues());
4927         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
4928         self.assertEqual([0,3,3,4],cI.getValues());
4929         self.assertEqual([4,9,11,6],c.getValues());
4930         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
4931         self.assertEqual([0,3,3,4],cI.getValues());
4932         self.assertEqual([4,9,11,6],c.getValues());
4933         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
4934         self.assertEqual([0,3,3,4],cI.getValues());
4935         self.assertEqual([4,9,11,6],c.getValues());
4936         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
4937         pass
4938
4939     def testFieldCopyTinyAttrFrom1(self):
4940         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4941         f1.setName("f1");
4942         f1.setTimeTolerance(1.e-5);
4943         f1.setDescription("f1Desc");
4944         f1.setTime(1.23,4,5);
4945         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4946         f2.setName("f2");
4947         f2.setDescription("f2Desc");
4948         f2.setTime(6.78,9,10);
4949         f2.setTimeTolerance(4.556e-12);
4950         #
4951         f1.copyTinyAttrFrom(f2);
4952         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4953         t,dt,it=f1.getTime()
4954         self.assertAlmostEqual(6.78,t,12);
4955         self.assertEqual(9,dt);
4956         self.assertEqual(10,it);
4957         self.assertTrue(f1.getName()=="f1");#name unchanged
4958         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4959         #
4960         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4961         f1.setName("f1");
4962         f1.setTimeTolerance(1.e-5);
4963         f1.setDescription("f1Desc");
4964         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4965         f2.setName("f2");
4966         f2.setDescription("f2Desc");
4967         f2.setTimeTolerance(4.556e-12);
4968         #
4969         f1.copyTinyAttrFrom(f2);
4970         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4971         self.assertTrue(f1.getName()=="f1");#name unchanged
4972         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4973         #
4974         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4975         f1.setName("f1");
4976         f1.setTimeTolerance(1.e-5);
4977         f1.setDescription("f1Desc");
4978         f1.setTime(1.23,4,5);
4979         f1.setEndTime(5.43,2,1);
4980         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4981         f2.setName("f2");
4982         f2.setDescription("f2Desc");
4983         f2.setTimeTolerance(4.556e-12);
4984         f2.setTime(6.78,9,10);
4985         f2.setEndTime(10.98,7,6);
4986         #
4987         f1.copyTinyAttrFrom(f2);
4988         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4989         self.assertTrue(f1.getName()=="f1");#name unchanged
4990         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4991         t,dt,it=f1.getTime()
4992         self.assertAlmostEqual(6.78,t,12);
4993         self.assertEqual(9,dt);
4994         self.assertEqual(10,it);
4995         t,dt,it=f1.getEndTime()
4996         self.assertAlmostEqual(10.98,t,12);
4997         self.assertEqual(7,dt);
4998         self.assertEqual(6,it);
4999         #
5000         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5001         f1.setName("f1");
5002         f1.setTimeTolerance(1.e-5);
5003         f1.setDescription("f1Desc");
5004         f1.setTime(1.23,4,5);
5005         f1.setEndTime(5.43,2,1);
5006         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5007         f2.setName("f2");
5008         f2.setDescription("f2Desc");
5009         f2.setTimeTolerance(4.556e-12);
5010         f2.setTime(6.78,9,10);
5011         f2.setEndTime(10.98,7,6);
5012         #
5013         f1.copyTinyAttrFrom(f2);
5014         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5015         self.assertTrue(f1.getName()=="f1");#name unchanged
5016         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5017         t,dt,it=f1.getTime()
5018         self.assertAlmostEqual(6.78,t,12);
5019         self.assertEqual(9,dt);
5020         self.assertEqual(10,it);
5021         t,dt,it=f1.getEndTime()
5022         self.assertAlmostEqual(10.98,t,12);
5023         self.assertEqual(7,dt);
5024         self.assertEqual(6,it);
5025         pass
5026
5027     def testExtrudedMesh5(self):
5028         coo1=[0.,1.,2.,3.5]
5029         a=DataArrayDouble.New();
5030         a.setValues(coo1,4,1);
5031         b=MEDCouplingCMesh.New();
5032         b.setCoordsAt(0,a);
5033         c=b.buildUnstructured();
5034         self.assertEqual(1,c.getSpaceDimension());
5035         c.changeSpaceDimension(2);
5036         #
5037         d=DataArrayDouble.New();
5038         d.alloc(13,1);
5039         d.iota();
5040         e=MEDCouplingCMesh.New();
5041         e.setCoordsAt(0,d);
5042         f=e.buildUnstructured();
5043         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5044         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 !
5045         h=g.fromPolarToCart();
5046         f.setCoords(h);
5047         i=c.buildExtrudedMesh(f,1);
5048         self.assertEqual(52,i.getNumberOfNodes());
5049         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5050         self.assertTrue(tmp2);
5051         self.assertEqual(37,tmp3);
5052         i.convertDegeneratedCells();
5053         i.checkCoherency();
5054         self.assertEqual(36,i.getNumberOfCells());
5055         self.assertEqual(37,i.getNumberOfNodes());
5056         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5057         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5058         expected1=[0.25,0.75,2.0625]
5059         j=i.getMeasureField(True);
5060         for ii in xrange(12):
5061             for k in xrange(3):
5062                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5063                 pass
5064             pass
5065         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]
5066         m=i.getBarycenterAndOwner();
5067         for i in xrange(72):
5068             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5069             pass
5070         #
5071         pass
5072
5073     def testExtrudedMesh6(self):
5074         coo1=[0.,1.,2.,3.5]
5075         a=DataArrayDouble.New();
5076         a.setValues(coo1,4,1);
5077         b=MEDCouplingCMesh.New();
5078         b.setCoordsAt(0,a);
5079         c=b.buildUnstructured();
5080         self.assertEqual(1,c.getSpaceDimension());
5081         c.changeSpaceDimension(2);
5082         #
5083         d=DataArrayDouble.New();
5084         d.alloc(5);
5085         d.iota();
5086         e=MEDCouplingCMesh.New();
5087         e.setCoordsAt(0,d);
5088         f=e.buildUnstructured();
5089         d2=f.getCoords().applyFunc("x*x/2");
5090         f.setCoords(d2);
5091         f.changeSpaceDimension(2);
5092         #
5093         center=[0.,0.]
5094         f.rotate(center,None,pi/3);
5095         g=c.buildExtrudedMesh(f,0);
5096         g.checkCoherency();
5097         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 ]
5098         f1=g.getMeasureField(True);
5099         for i in xrange(12):
5100             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5101             pass
5102         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]
5103         f2=g.getBarycenterAndOwner();
5104         for i in xrange(24):
5105             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5106             pass
5107         pass
5108
5109     def testExtrudedMesh7(self):
5110         coo1=[0.,1.,2.,3.5]
5111         a=DataArrayDouble.New();
5112         a.setValues(coo1,4,1);
5113         b=MEDCouplingCMesh.New();
5114         b.setCoordsAt(0,a);
5115         c=b.buildUnstructured();
5116         self.assertEqual(1,c.getSpaceDimension());
5117         c.changeSpaceDimension(2);
5118         #
5119         d=DataArrayDouble.New();
5120         d.alloc(13,1);
5121         d.iota();
5122         e=MEDCouplingCMesh.New();
5123         e.setCoordsAt(0,d);
5124         f=e.buildUnstructured();
5125         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5126         h=g.fromPolarToCart();
5127         f.setCoords(h);
5128         i=c.buildExtrudedMesh(f,1);
5129         self.assertEqual(52,i.getNumberOfNodes());
5130         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5131         self.assertTrue(tmp2);
5132         self.assertEqual(37,tmp3);
5133         i.convertDegeneratedCells();
5134         vec1=[10.,0]
5135         i.translate(vec1);
5136         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5137         f.setCoords(g2);
5138         i.changeSpaceDimension(3);
5139         i3=i.buildExtrudedMesh(f,1);
5140         f2=i3.getMeasureField(True);
5141         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5142         self.assertTrue(tmp2);
5143         self.assertEqual(444,tmp3);
5144         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]
5145         for ii in xrange(12):
5146             for jj in xrange(36):
5147                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5148                 pass
5149         #
5150         pass
5151
5152     def testSimplexize1(self):
5153         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5154         m.convertToPolyTypes([3]);
5155         da=m.simplexize(0);
5156         self.assertEqual(7,da.getNumberOfTuples());
5157         self.assertEqual(1,da.getNumberOfComponents());
5158         expected2=[0,0,1,2,3,4,4]
5159         for i in xrange(7):
5160             self.assertEqual(expected2[i],da.getIJ(i,0));
5161             pass
5162         m.checkCoherency();
5163         self.assertEqual(7,m.getNumberOfCells());
5164         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5165         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5166         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5167         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5168         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5169         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5170         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5171         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5172         f=m.getMeasureField(False);
5173         for i in xrange(7):
5174             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5175             pass
5176         types=m.getAllTypes();
5177         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5178         #
5179         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5180         m.convertToPolyTypes([3]);
5181         da=m.simplexize(1);
5182         self.assertEqual(7,da.getNumberOfTuples());
5183         self.assertEqual(1,da.getNumberOfComponents());
5184         for i in xrange(7):
5185             self.assertEqual(expected2[i],da.getIJ(i,0));
5186             pass
5187         m.checkCoherency();
5188         types=m.getAllTypes();
5189         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5190         self.assertEqual(7,m.getNumberOfCells());
5191         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5192         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5193         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5194         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5195         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5196         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5197         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5198         f=m.getMeasureField(False);
5199         for i in xrange(7):
5200             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5201             pass
5202         pass
5203
5204     def testSimplexize2(self):
5205         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5206         m.convertToPolyTypes([3]);
5207         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5208         f1.setMesh(m);
5209         arr=DataArrayDouble.New();
5210         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5211         arr.setValues(arr1,5,2);
5212         f1.setArray(arr);
5213         #
5214         f1.checkCoherency();
5215         self.assertTrue(f1.simplexize(0));
5216         f1.checkCoherency();
5217         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5218         for i in xrange(14):
5219             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5220             pass
5221         self.assertTrue(not f1.simplexize(0));
5222         for i in xrange(14):
5223             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5224             pass
5225         #
5226         pass
5227
5228     def testDAMeld1(self):
5229         da1=DataArrayDouble.New();
5230         da1.alloc(7,2);
5231         da2=DataArrayDouble.New();
5232         da2.alloc(7,1);
5233         #
5234         da1.fillWithValue(7.);
5235         da2.iota(0.);
5236         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5237         #
5238         da1.setInfoOnComponent(0,"c0da1");
5239         da1.setInfoOnComponent(1,"c1da1");
5240         da3.setInfoOnComponent(0,"c0da3");
5241         da3.setInfoOnComponent(1,"c1da3");
5242         da3.setInfoOnComponent(2,"c2da3");
5243         #
5244         da1C=da1.deepCpy();
5245         da1.meldWith(da3);
5246         self.assertEqual(5,da1.getNumberOfComponents());
5247         self.assertEqual(7,da1.getNumberOfTuples());
5248         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5249         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5250         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5251         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5252         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5253         #
5254         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.]
5255         for i in xrange(35):
5256             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5257             pass
5258         #
5259         dai1=da1C.convertToIntArr();
5260         dai3=da3.convertToIntArr();
5261         dai1.meldWith(dai3);
5262         self.assertEqual(5,dai1.getNumberOfComponents());
5263         self.assertEqual(7,dai1.getNumberOfTuples());
5264         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5265         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5266         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5267         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5268         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5269         for i in xrange(35):
5270             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5271             pass
5272         # test of static method DataArrayDouble::meld
5273         da4=DataArrayDouble.Meld(da1C,da3);
5274         tmp=DataArrayDouble.Meld([da1C,da3]);
5275         self.assertTrue(da4.isEqual(tmp,1e-10))
5276         self.assertEqual(5,da4.getNumberOfComponents());
5277         self.assertEqual(7,da4.getNumberOfTuples());
5278         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5279         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5280         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5281         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5282         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5283         for i in xrange(35):
5284             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5285             pass
5286         # test of static method DataArrayInt::meld
5287         dai1=da1C.convertToIntArr();
5288         dai4=DataArrayInt.Meld(dai1,dai3);
5289         tmp=DataArrayInt.Meld([dai1,dai3]);
5290         self.assertTrue(dai4.isEqual(tmp))
5291         self.assertEqual(5,dai4.getNumberOfComponents());
5292         self.assertEqual(7,dai4.getNumberOfTuples());
5293         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5294         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5295         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5296         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5297         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5298         for i in xrange(35):
5299             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5300             pass
5301         pass
5302
5303     def testFieldMeld1(self):
5304         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5305         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5306         f1.setMesh(m);
5307         da1=DataArrayDouble.New();
5308         arr1=[12.,23.,34.,45.,56.]
5309         da1.setValues(arr1,5,1);
5310         da1.setInfoOnComponent(0,"aaa");
5311         f1.setArray(da1);
5312         f1.setTime(3.4,2,1);
5313         f1.checkCoherency();
5314         #
5315         f2=f1.deepCpy();
5316         f2.setMesh(f1.getMesh());
5317         f2.checkCoherency();
5318         f2.changeNbOfComponents(2,5.);
5319         f2.assign(5.);
5320         f2.getArray().setInfoOnComponent(0,"bbb");
5321         f2.getArray().setInfoOnComponent(1,"ccc");
5322         f2.checkCoherency();
5323         #
5324         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5325         f3.checkCoherency();
5326         self.assertEqual(5,f3.getNumberOfTuples());
5327         self.assertEqual(3,f3.getNumberOfComponents());
5328         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5329         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5330         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5331         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5332         for i in xrange(15):
5333             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5334             pass
5335         time,dt,it=f3.getTime();
5336         self.assertAlmostEqual(3.4,time,14);
5337         self.assertEqual(2,dt);
5338         self.assertEqual(1,it);
5339         #
5340         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5341         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5342         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5343         f6.checkCoherency();
5344         self.assertEqual(5,f6.getNumberOfTuples());
5345         self.assertEqual(3,f6.getNumberOfComponents());
5346         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5347         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5348         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5349         for i in xrange(15):
5350             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5351             pass
5352         #
5353         pass
5354
5355     def testMergeNodes2(self):
5356         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5357         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5358         vec=[0.002,0.]
5359         m2.translate(vec);
5360         #
5361         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5362         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5363         self.assertEqual(9,m3.getNumberOfNodes());
5364         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]
5365         for i in xrange(18):
5366             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5367             pass
5368         #
5369         pass
5370
5371     def testMergeField2(self):
5372         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5373         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5374         f1.setMesh(m);
5375         arr=DataArrayDouble.New();
5376         arr.alloc(5,2);
5377         arr.fillWithValue(2.);
5378         f1.setArray(arr);
5379         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5380         f2.setMesh(m);
5381         arr=DataArrayDouble.New();
5382         arr.alloc(5,2);
5383         arr.fillWithValue(5.);
5384         f2.setArray(arr);
5385         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5386         f3.setMesh(m);
5387         arr=DataArrayDouble.New();
5388         arr.alloc(5,2);
5389         arr.fillWithValue(7.);
5390         f3.setArray(arr);
5391         #
5392         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5393         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5394         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.]
5395         for i in xrange(30):
5396             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5397             pass
5398         #
5399         pass
5400
5401     def testDAIBuildComplement1(self):
5402         a=DataArrayInt.New();
5403         tab=[3,1,7,8]
5404         a.setValues(tab,4,1);
5405         b=a.buildComplement(12);
5406         self.assertEqual(8,b.getNumberOfTuples());
5407         self.assertEqual(1,b.getNumberOfComponents());
5408         expected1=[0,2,4,5,6,9,10,11]
5409         for i in xrange(8):
5410             self.assertEqual(expected1[i],b.getIJ(0,i));
5411             pass
5412         pass
5413
5414     def testDAIBuildUnion1(self):
5415         a=DataArrayInt.New();
5416         tab1=[3,1,7,8]
5417         a.setValues(tab1,4,1);
5418         c=DataArrayInt.New();
5419         tab2=[5,3,0,18,8]
5420         c.setValues(tab2,5,1);
5421         b=a.buildUnion(c);
5422         self.assertEqual(7,b.getNumberOfTuples());
5423         self.assertEqual(1,b.getNumberOfComponents());
5424         expected1=[0,1,3,5,7,8,18]
5425         for i in xrange(7):
5426             self.assertEqual(expected1[i],b.getIJ(0,i));
5427             pass
5428         b=DataArrayInt.BuildUnion([a,c]);
5429         self.assertEqual(7,b.getNumberOfTuples());
5430         self.assertEqual(1,b.getNumberOfComponents());
5431         expected1=[0,1,3,5,7,8,18]
5432         for i in xrange(7):
5433             self.assertEqual(expected1[i],b.getIJ(0,i));
5434             pass
5435         pass
5436
5437     def testDAIBuildIntersection1(self):
5438         a=DataArrayInt.New();
5439         tab1=[3,1,7,8]
5440         a.setValues(tab1,4,1);
5441         c=DataArrayInt.New();
5442         tab2=[5,3,0,18,8]
5443         c.setValues(tab2,5,1);
5444         b=a.buildIntersection(c);
5445         self.assertEqual(2,b.getNumberOfTuples());
5446         self.assertEqual(1,b.getNumberOfComponents());
5447         expected1=[3,8]
5448         for i in xrange(2):
5449             self.assertEqual(expected1[i],b.getIJ(0,i));
5450             pass
5451         b=DataArrayInt.BuildIntersection([a,c]);
5452         self.assertEqual(2,b.getNumberOfTuples());
5453         self.assertEqual(1,b.getNumberOfComponents());
5454         expected1=[3,8]
5455         for i in xrange(2):
5456             self.assertEqual(expected1[i],b.getIJ(0,i));
5457             pass
5458         pass
5459
5460     def testDAIDeltaShiftIndex1(self):
5461         a=DataArrayInt.New();
5462         tab=[1,3,6,7,7,9,15]
5463         a.setValues(tab,7,1);
5464         b=a.deltaShiftIndex();
5465         self.assertEqual(6,b.getNumberOfTuples());
5466         self.assertEqual(1,b.getNumberOfComponents());
5467         expected1=[2,3,1,0,2,6]
5468         for i in xrange(6):
5469             self.assertEqual(expected1[i],b.getIJ(0,i));
5470             pass
5471         pass
5472
5473     def testDaDoubleSelectByTupleIdSafe1(self):
5474         a=DataArrayDouble.New();
5475         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]
5476         a.setValues(arr1,7,2);
5477         a.setInfoOnComponent(0,"toto");
5478         a.setInfoOnComponent(1,"tata");
5479         #
5480         arr2=[4,2,0,6,5]
5481         b=a.selectByTupleIdSafe(arr2);
5482         self.assertEqual(5,b.getNumberOfTuples());
5483         self.assertEqual(2,b.getNumberOfComponents());
5484         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5485         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5486         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5487         for i in xrange(10):
5488             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5489             pass
5490         arr4=[4,-1,0,6,5]
5491         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5492         arr5=[4,2,0,6,7]
5493         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5494         #
5495         c=DataArrayInt.New();
5496         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5497         c.setValues(arr3,7,2);
5498         c.setInfoOnComponent(0,"toto");
5499         c.setInfoOnComponent(1,"tata");
5500         d=c.selectByTupleIdSafe(arr2);
5501         self.assertEqual(5,d.getNumberOfTuples());
5502         self.assertEqual(2,d.getNumberOfComponents());
5503         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5504         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5505         expected2=[5,15,3,13,1,11,7,17,6,16]
5506         for i in xrange(10):
5507             self.assertEqual(expected2[i],d.getIJ(0,i));
5508             pass
5509         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5510         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5511         pass
5512
5513     def testAreCellsIncludedIn1(self):
5514         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5515         pt=[1,3]
5516         m2=m.buildPartOfMySelf(pt,True);
5517         ret,tmp=m.areCellsIncludedIn(m2,0)
5518         self.assertTrue(ret);
5519         self.assertEqual(2,tmp.getNumberOfTuples());
5520         self.assertEqual(1,tmp.getNumberOfComponents());
5521         self.assertEqual(pt[0],tmp.getIJ(0,0));
5522         self.assertEqual(pt[1],tmp.getIJ(0,1));
5523         ret,tmp=m2.areCellsIncludedIn(m,0)
5524         self.assertTrue(not ret);
5525         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
5526         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
5527         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
5528         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
5529         pass
5530
5531     def testSwigErrorProtection1(self):
5532         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5533         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5534         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5535         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5536         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5537         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5538         m2=m.buildPartOfMySelf([2,5],True)
5539         m3=m.buildPartOfMySelf((2,5),True)
5540         self.assertTrue(m2.isEqual(m3,1e-12))
5541         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5542         da1=m.getCoords().keepSelectedComponents([1])
5543         da2=m.getCoords().keepSelectedComponents((1,))
5544         self.assertTrue(da1.isEqual(da2,1e-12))
5545         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5546         pass
5547
5548     def testDAIBuildSubstraction1(self):
5549         a=DataArrayInt.New()
5550         aa=[2,3,6,8,9]
5551         a.setValues(aa,5,1)
5552         b=DataArrayInt.New()
5553         bb=[1,3,5,9,11]
5554         b.setValues(bb,5,1)
5555         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5556         pass
5557
5558     def testBuildOrthogonalField2(self):
5559         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5560         d1=DataArrayInt.New();
5561         d2=DataArrayInt.New();
5562         d3=DataArrayInt.New();
5563         d4=DataArrayInt.New();
5564         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5565         #
5566         f1=m1.buildOrthogonalField();
5567         da1=f1.getArray();
5568         self.assertEqual(2,da1.getNumberOfComponents());
5569         self.assertEqual(13,da1.getNumberOfTuples());
5570         #
5571         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.];
5572         for i in xrange(26):
5573             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5574             pass
5575         pass
5576
5577     def testSwigErrorProtection2(self):
5578         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5579         coo=m.getCoords()
5580         c=m.getNodalConnectivity()
5581         ci=m.getNodalConnectivityIndex()
5582         del m
5583         self.assertEqual(2,coo.getNumberOfComponents());
5584         self.assertEqual(6,ci.getNumberOfTuples());
5585         self.assertEqual(23,c.getNumberOfTuples());
5586         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5587         f=m.getMeasureField(True)
5588         c=f.getArray()
5589         del f
5590         self.assertEqual(1,c.getNumberOfComponents());
5591         m=MEDCouplingCMesh.New()
5592         x=DataArrayDouble.New()
5593         x.setValues([1.,2.,4.],3,1)
5594         m.setCoordsAt(0,x)
5595         del x
5596         xx=m.getCoordsAt(0)
5597         del m
5598         self.assertEqual(3,xx.getNumberOfTuples());
5599         #
5600         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5601         f=m.getMeasureField(True)
5602         m2=f.getMesh()
5603         del m
5604         del f
5605         self.assertEqual(5,m2.getNumberOfCells());
5606         pass
5607
5608     def testUMInsertNextCell1(self):
5609         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 ]
5610         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5611         targetMesh=MEDCouplingUMesh.New();
5612         targetMesh.allocateCells(5);
5613         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5614         targetMesh.setMeshDimension(2);
5615         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5616         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5617         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5618         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5619         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5620         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5621         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5622         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5623         targetMesh.finishInsertingCells();
5624         myCoords=DataArrayDouble.New();
5625         myCoords.setValues(targetCoords,9,2);
5626         targetMesh.setCoords(myCoords);
5627         targetMesh.checkCoherency();
5628         pass
5629
5630     def testFieldOperatorDivDiffComp1(self):
5631         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5632         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5633         #
5634         f1=m1.buildOrthogonalField();
5635         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5636         arr=DataArrayDouble.New();
5637         arr.setValues(arr1,13,1);
5638         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5639         f2.setArray(arr);
5640         f2.setMesh(m1);
5641         f2.checkCoherency();
5642         #
5643         f3=f1/f2;
5644         self.assertRaises(InterpKernelException,f2.__div__,f1)
5645         f3.checkCoherency();
5646         f1/=f2;
5647         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5648         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5649         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]
5650         for i in xrange(26):
5651             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5652             pass
5653         pass
5654
5655     def testDARearrange1(self):
5656         da1=DataArrayInt.New();
5657         da1.alloc(12,1);
5658         da1.iota(0);
5659         #
5660         self.assertEqual(12,da1.getNbOfElems());
5661         self.assertEqual(1,da1.getNumberOfComponents());
5662         self.assertEqual(12,da1.getNumberOfTuples());
5663         da1.rearrange(4);
5664         self.assertEqual(12,da1.getNbOfElems());
5665         self.assertEqual(4,da1.getNumberOfComponents());
5666         self.assertEqual(3,da1.getNumberOfTuples());
5667         for i in xrange(12):
5668             self.assertEqual(i,da1.getIJ(0,i));
5669         #
5670         da1.rearrange(6);
5671         self.assertEqual(12,da1.getNbOfElems());
5672         self.assertEqual(6,da1.getNumberOfComponents());
5673         self.assertEqual(2,da1.getNumberOfTuples());
5674         for i in xrange(12):
5675             self.assertEqual(i,da1.getIJ(0,i));
5676         #
5677         self.assertRaises(InterpKernelException,da1.rearrange,7);
5678         #
5679         da1.rearrange(12);
5680         self.assertEqual(12,da1.getNbOfElems());
5681         self.assertEqual(12,da1.getNumberOfComponents());
5682         self.assertEqual(1,da1.getNumberOfTuples());
5683         for i in xrange(12):
5684             self.assertEqual(i,da1.getIJ(0,i));
5685         #
5686         da1.rearrange(3);
5687         self.assertEqual(12,da1.getNbOfElems());
5688         self.assertEqual(3,da1.getNumberOfComponents());
5689         self.assertEqual(4,da1.getNumberOfTuples());
5690         for i in xrange(12):
5691             self.assertEqual(i,da1.getIJ(0,i));
5692         #double
5693         da2=da1.convertToDblArr();
5694         st=da2.getHiddenCppPointer()
5695         #
5696         self.assertEqual(12,da2.getNbOfElems());
5697         self.assertEqual(3,da2.getNumberOfComponents());
5698         self.assertEqual(4,da2.getNumberOfTuples());
5699         da2.rearrange(4);
5700         self.assertEqual(12,da2.getNbOfElems());
5701         self.assertEqual(4,da2.getNumberOfComponents());
5702         self.assertEqual(3,da2.getNumberOfTuples());
5703         for i in xrange(12):
5704             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5705         #
5706         da2.rearrange(6);
5707         self.assertEqual(12,da2.getNbOfElems());
5708         self.assertEqual(6,da2.getNumberOfComponents());
5709         self.assertEqual(2,da2.getNumberOfTuples());
5710         for i in xrange(12):
5711             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5712         #
5713         self.assertRaises(InterpKernelException,da2.rearrange,7);
5714         #
5715         da2.rearrange(1);
5716         self.assertEqual(st,da2.getHiddenCppPointer())
5717         self.assertEqual(12,da2.getNbOfElems());
5718         self.assertEqual(1,da2.getNumberOfComponents());
5719         self.assertEqual(12,da2.getNumberOfTuples());
5720         for i in xrange(12):
5721             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5722         #
5723         da2.rearrange(3);
5724         self.assertEqual(12,da2.getNbOfElems());
5725         self.assertEqual(3,da2.getNumberOfComponents());
5726         self.assertEqual(4,da2.getNumberOfTuples());
5727         for i in xrange(12):
5728             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5729         pass
5730
5731     def testDARearrange2(self):
5732         da1=DataArrayInt.New();
5733         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5734         da1.setValues(arr,4,3);
5735         s=da1.getDifferentValues();
5736         expected1=DataArrayInt([1,2,3,5])
5737         self.assertTrue(expected1.isEqual(s));
5738         pass
5739
5740     def testSwigErrorProtection3(self):
5741         da=DataArrayInt.New()
5742         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
5743         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
5744         self.assertEqual(3,da.getNumberOfComponents());
5745         self.assertEqual(4,da.getNumberOfTuples());
5746         da=DataArrayInt.New()
5747         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
5748         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
5749         self.assertEqual(3,da.getNumberOfComponents());
5750         self.assertEqual(4,da.getNumberOfTuples());
5751         da.setValues((10*[1]+290*[2])[:12],4,3)
5752         self.assertEqual(10*[1]+[2,2],da.getValues())
5753         self.assertEqual(3,da.getNumberOfComponents());
5754         self.assertEqual(4,da.getNumberOfTuples());
5755         #
5756         da=DataArrayDouble.New()
5757         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
5758         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5759         self.assertEqual(3,da.getNumberOfComponents());
5760         self.assertEqual(4,da.getNumberOfTuples());
5761         da=DataArrayDouble.New()
5762         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
5763         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5764         self.assertEqual(3,da.getNumberOfComponents());
5765         self.assertEqual(4,da.getNumberOfTuples());
5766         da.setValues((10*[1]+290*[2])[:12],4,3)
5767         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5768         self.assertEqual(3,da.getNumberOfComponents());
5769         self.assertEqual(4,da.getNumberOfTuples());
5770         pass
5771
5772     def testDAIBuildPermutationArr1(self):
5773         a=DataArrayInt.New()
5774         a.setValues([4,5,6,7,8],5,1)
5775         b=DataArrayInt.New()
5776         b.setValues([5,4,8,6,7],5,1)
5777         c=a.buildPermutationArr(b)
5778         self.assertEqual([1,0,4,2,3],c.getValues())
5779         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5780         b.setIJ(0,0,9)
5781         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5782         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5783         a.setIJ(3,0,4)
5784         b.setIJ(0,0,5)
5785         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5786         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5787         c=a.buildPermutationArr(b)
5788         self.assertEqual([1,3,4,2,3],c.getValues())
5789         d=b.convertToDblArr()
5790         expect3=[4,4,5,6,8]
5791         b.sort()
5792         self.assertEqual(expect3,b.getValues())
5793         d.sort()
5794         self.assertEqual(5,d.getNumberOfTuples());
5795         self.assertEqual(1,d.getNumberOfComponents());
5796         for i in xrange(5):
5797             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5798             pass
5799         pass
5800
5801     def testAreCellsIncludedIn2(self):
5802         myName="Vitoo";
5803         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5804         m2=m.buildPartOfMySelf([],True);
5805         self.assertEqual(0,m2.getNumberOfCells());
5806         self.assertEqual(3,m2.getSpaceDimension());
5807         self.assertEqual(2,m2.getMeshDimension());
5808         m2.setName(myName);
5809         test,tmp=m.areCellsIncludedIn(m2,0)
5810         self.assertTrue(test);
5811         self.assertEqual(myName,tmp.getName());
5812         self.assertEqual(0,tmp.getNumberOfTuples())
5813         self.assertEqual(1,tmp.getNumberOfComponents())
5814         pass
5815
5816     def testUMeshGetPartBarycenterAndOwner1(self):
5817         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5818         part1=[1,0,4];
5819         part=DataArrayInt.New();
5820         part.setValues(part1,3,1);
5821         b=m1.getPartBarycenterAndOwner(part);
5822         self.assertEqual(2,b.getNumberOfComponents());
5823         self.assertEqual(3,b.getNumberOfTuples());
5824         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5825         for i in xrange(6):
5826             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5827             pass
5828         pass
5829
5830     def testUMeshGetPartMeasureField1(self):
5831         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5832         part1=[1,0,4];
5833         part=DataArrayInt.New();
5834         part.setValues(part1,3,1);
5835         b=m1.getPartMeasureField(True,part);
5836         self.assertEqual(1,b.getNumberOfComponents());
5837         self.assertEqual(3,b.getNumberOfTuples());
5838         expected1=[0.125,0.25,0.25];
5839         for i in xrange(3):
5840             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5841             pass
5842         pass
5843
5844     def testUMeshBuildPartOrthogonalField1(self):
5845         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5846         m1.changeSpaceDimension(3);
5847         part1=[1,0,4];
5848         part=DataArrayInt.New();
5849         part.setValues(part1,3,1);
5850         b=m1.buildPartOrthogonalField(part);
5851         self.assertEqual(3,b.getArray().getNumberOfComponents());
5852         self.assertEqual(3,b.getArray().getNumberOfTuples());
5853         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5854         for i in xrange(9):
5855             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5856             pass
5857         pass
5858
5859     def testUMeshGetTypesOfPart1(self):
5860         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5861         part1=[0,3,4];
5862         p1=DataArrayInt.New()
5863         p1.setValues(part1,3,1)
5864         s=m1.getTypesOfPart(p1);
5865         self.assertEqual([NORM_QUAD4],s);
5866         part2=[2,2,2,1];
5867         p2=DataArrayInt.New()
5868         p2.setValues(part2,4,1)
5869         s=m1.getTypesOfPart(p2);
5870         self.assertEqual([NORM_TRI3],s);
5871         part3=[3,2,1];
5872         p3=DataArrayInt.New()
5873         p3.setValues(part3,3,1)
5874         s=m1.getTypesOfPart(p3);
5875         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5876         pass
5877
5878     def testUMeshKeepCellIdsByType1(self):
5879         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5880         part1=[0,3,4]
5881         p1=DataArrayInt.New()
5882         p1.setValues(part1,3,1)
5883         p1.setName("p1")
5884         a=m1.keepCellIdsByType(NORM_TRI3,p1);
5885         self.assertEqual("p1",a.getName())
5886         self.assertEqual(1,a.getNumberOfComponents());
5887         self.assertEqual(0,a.getNumberOfTuples());
5888         #
5889         part2=[3,2,0,2,4]
5890         p2=DataArrayInt.New()
5891         p2.setValues(part2,5,1)
5892         p2.setName("p2")
5893         a=m1.keepCellIdsByType(NORM_TRI3,p2);
5894         self.assertEqual("p2",a.getName())
5895         self.assertEqual(1,a.getNumberOfComponents());
5896         self.assertEqual(2,a.getNumberOfTuples());
5897         self.assertEqual(2,a.getIJ(0,0));
5898         self.assertEqual(2,a.getIJ(1,0));
5899         #
5900         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
5901         self.assertEqual("p2",a.getName())
5902         self.assertEqual(1,a.getNumberOfComponents());
5903         self.assertEqual(3,a.getNumberOfTuples());
5904         self.assertEqual(3,a.getIJ(0,0));
5905         self.assertEqual(0,a.getIJ(1,0));
5906         self.assertEqual(4,a.getIJ(2,0));
5907         pass
5908
5909     def testSwigErrorDaIntSelectByTupleId1(self):
5910         a=DataArrayInt.New();
5911         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5912         a.setValues(arr1,7,2);
5913         a.setInfoOnComponent(0,"toto");
5914         a.setInfoOnComponent(1,"tata");
5915         #
5916         arr2=[4,2,0,6,5]
5917         b=a.selectByTupleId(arr2);
5918         self.assertEqual(5,b.getNumberOfTuples());
5919         self.assertEqual(2,b.getNumberOfComponents());
5920         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5921         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5922         expected1=[5,15,3,13,1,11,7,17,6,16]
5923         self.assertEqual(expected1,b.getValues())
5924         #
5925         a2=DataArrayInt.New()
5926         a2.setValues(arr2,5,1)
5927         b=a.selectByTupleId(a2);
5928         self.assertEqual(5,b.getNumberOfTuples());
5929         self.assertEqual(2,b.getNumberOfComponents());
5930         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5931         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5932         expected1=[5,15,3,13,1,11,7,17,6,16]
5933         self.assertEqual(expected1,b.getValues())
5934         pass
5935
5936     def testSwigErrorRenum(self):
5937         da=DataArrayDouble.New()
5938         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
5939         d=DataArrayInt.New()
5940         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
5941         da.renumberInPlace(d)
5942         da.renumber(d)
5943         pass
5944
5945     def testSwigGetItem1(self):
5946         da=DataArrayInt.New()
5947         da.alloc(16,3)
5948         da.rearrange(1)
5949         da.iota(7)
5950         da.rearrange(3)
5951         da.setInfoOnComponent(0,"X [m]")
5952         da.setInfoOnComponent(1,"Y [m]")
5953         da.setInfoOnComponent(2,"Z [km]")
5954         da2=da[5:-1]
5955         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())
5956         da2=da[4]
5957         self.assertEqual([19, 20, 21],da2.getValues())
5958         try:
5959             da2=da[4:17]
5960         except InterpKernelException as e:
5961             self.assertTrue(True)
5962         else:
5963             self.assertTrue(False)
5964             pass
5965         da2=da[5:-2,2]
5966         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
5967         da2=da[5:8,:]
5968         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
5969         da2=da[:]
5970         self.assertTrue(da2.isEqual(da))
5971         da2=da[:,:]
5972         self.assertTrue(da2.isEqual(da))
5973         try:
5974             da2=da[:,:,:]
5975         except InterpKernelException as e:
5976             self.assertTrue(True)
5977         else:
5978             self.assertTrue(False)
5979             pass
5980         try:
5981             da2=da[5:8,-2]
5982         except InterpKernelException as e:
5983             self.assertTrue(True)
5984         else:
5985             self.assertTrue(False)
5986             pass
5987         da2=da[5:8,:-2]
5988         self.assertEqual([22, 25, 28],da2.getValues())
5989         try:
5990             da2=da[5:-18,2]
5991         except InterpKernelException as e:
5992             self.assertTrue(True)
5993         else:
5994             self.assertTrue(False)
5995             pass
5996         da2=da[5:5,2]
5997         self.assertEqual([],da2.getValues())
5998         pass
5999
6000     def testSwigGetItem2(self):
6001         da=DataArrayDouble.New()
6002         da.alloc(16,3)
6003         da.rearrange(1)
6004         da.iota(7)
6005         da.rearrange(3)
6006         da.setInfoOnComponent(0,"X [m]")
6007         da.setInfoOnComponent(1,"Y [m]")
6008         da.setInfoOnComponent(2,"Z [km]")
6009         da2=da[5:-1]
6010         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())
6011         da2=da[4]
6012         self.assertEqual([19., 20., 21],da2.getValues())
6013         try:
6014             da2=da[4:17]
6015         except InterpKernelException as e:
6016             self.assertTrue(True)
6017         else:
6018             self.assertTrue(False)
6019             pass
6020         da2=da[5:-2,2]
6021         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6022         da2=da[5:8,:]
6023         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6024         da2=da[:]
6025         self.assertTrue(da2.isEqual(da,1e-12))
6026         da2=da[:,:]
6027         self.assertTrue(da2.isEqual(da,1e-12))
6028         try:
6029             da2=da[:,:,:]
6030         except InterpKernelException as e:
6031             self.assertTrue(True)
6032         else:
6033             self.assertTrue(False)
6034             pass
6035         try:
6036             da2=da[5:8,-2]
6037         except InterpKernelException as e:
6038             self.assertTrue(True)
6039         else:
6040             self.assertTrue(False)
6041             pass
6042         da2=da[5:8,:-2]
6043         self.assertEqual([22., 25., 28.],da2.getValues())
6044         try:
6045             da2=da[5:-18,2]
6046         except InterpKernelException as e:
6047             self.assertTrue(True)
6048         else:
6049             self.assertTrue(False)
6050             pass
6051         da2=da[5:5,2]
6052         self.assertEqual([],da2.getValues())
6053         pass
6054
6055     def testSwigSetItem1(self):
6056         da=DataArrayInt.New()
6057         da.alloc(20,1)
6058         da.iota(7)
6059         da.rearrange(5)
6060         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6061         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6062         da[:,2]=3
6063         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6064         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6065         da[2]=3
6066         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6067         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6068         da[[0,3]]=-1
6069         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6070         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6071         da[:,[1,3,4]]=-3
6072         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6073         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6074         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6075         da[da2]=-7
6076         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6077         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6078         da[da2,-2:]=-7
6079         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6080         # Let's test with DAI right hand side
6081         da1=DataArrayInt.New()
6082         da1.setValues([25,26,27,125,126,127],2,3)
6083         #
6084         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6085         da[-2:,1:4]=da1
6086         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6087         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6088         da[1:,3]=[225,226,227]
6089         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6090         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6091         da[1,2:]=[225,226,227]
6092         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6093         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6094         da[da2,-2:]=[88,99,1010,1111,1212,1313]
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         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6098         da[da2,-2:]=da3
6099         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6100         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6101         da[da2,[0,2]]=da3
6102         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6103         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6104         da[da2,0:3:2]=da3
6105         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6106         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6107         da[da2,0:3:2]=-8
6108         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6109         pass
6110
6111     def testSwigSetItem2(self):
6112         da=DataArrayDouble.New()
6113         da.alloc(20,1)
6114         da.iota(7)
6115         da.rearrange(5)
6116         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6117         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6118         da[:,2]=3.
6119         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6120         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6121         da[2]=3.
6122         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6123         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6124         da[[0,3]]=-1.
6125         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6126         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6127         da[:,[1,3,4]]=-3.
6128         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6129         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6130         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6131         da[da2]=-7.
6132         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6133         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6134         da[da2,-2:]=-7
6135         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6136         # Let's test with DAI right hand side
6137         da1=DataArrayDouble.New()
6138         da1.setValues([25,26,27,125,126,127],2,3)
6139         #
6140         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6141         da[-2:,1:4]=da1
6142         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6143         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6144         da[1:,3]=[225.,226.,227.]
6145         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6146         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6147         da[1,2:]=[225,226,227]
6148         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6149         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6150         da[da2,-2:]=[88,99,1010,1111,1212,1313]
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         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6154         da[da2,-2:]=da3
6155         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6156         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6157         da[da2,[0,2]]=da3
6158         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6159         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6160         da[da2,0:3:2]=da3
6161         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6162         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6163         da[da2,0:3:2]=-8.
6164         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6165         pass
6166
6167     def testSwigDADOp(self):
6168         da=DataArrayDouble.New()
6169         da.alloc(12,1)
6170         da.iota(7.)
6171         da1=DataArrayDouble.New()
6172         da1.alloc(12,1)
6173         da1.iota(8.)
6174         da2=da+da1
6175         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6176         da2=da+3
6177         da3=3+da
6178         self.assertTrue(da2.isEqual(da3,1e-12))
6179         da2=da-1.
6180         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())
6181         da2=1-da
6182         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())
6183         da2=da*3
6184         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())
6185         da2=3.*da
6186         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())
6187         da2=da*da1
6188         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())
6189         da2=da/4.
6190         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())
6191         da3=4./da
6192         da4=da3*da2
6193         self.assertTrue(da4.isUniform(1.,1e-12))
6194         st1=da.getHiddenCppPointer()
6195         da+=1
6196         st2=da.getHiddenCppPointer()
6197         self.assertEqual(st1,st2)
6198         self.assertTrue(da.isEqual(da1,1e-12))
6199         da-=8
6200         st2=da.getHiddenCppPointer()
6201         self.assertEqual(st1,st2)
6202         self.assertEqual(range(12),da.getValues())
6203         da+=da1
6204         st2=da.getHiddenCppPointer()
6205         self.assertEqual(st1,st2)
6206         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())
6207         da*=0.5
6208         st2=da.getHiddenCppPointer()
6209         self.assertEqual(st1,st2)
6210         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())
6211         da*=da1
6212         st2=da.getHiddenCppPointer()
6213         self.assertEqual(st1,st2)
6214         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())
6215         da/=da1
6216         self.assertEqual(st1,st2)
6217         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())
6218         da/=2
6219         st2=da.getHiddenCppPointer()
6220         self.assertEqual(st1,st2)
6221         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())
6222         da.rearrange(3)
6223         da5=DataArrayDouble.New()
6224         da5.setValues([5.,4.,3.,2.],4,1)
6225         da*=da5 # it works with unmathing number of compo
6226         st2=da.getHiddenCppPointer()
6227         self.assertEqual(st1,st2)
6228         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())
6229         #
6230         da.alloc(30,1)
6231         da.iota(7.)
6232         da.rearrange(3)
6233         ids=DataArrayInt.New()
6234         ids.setValues([3,4,7],3,1)
6235         da[ids,:]=[5.,8.,9.]
6236         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())
6237         #
6238         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6239         da[ids,[1,2]]=[5,8]
6240         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())
6241         pass
6242
6243     def testSwigDAIOp(self):
6244         da=DataArrayInt.New()
6245         da.alloc(12,1)
6246         da.iota(7)
6247         da1=DataArrayInt.New()
6248         da1.alloc(12,1)
6249         da1.iota(8)
6250         da2=da+da1
6251         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6252         da2=da+3
6253         da3=3+da
6254         self.assertTrue(da2.isEqual(da3))
6255         da2=da-1
6256         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6257         da2=1-da
6258         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6259         da2=da*3
6260         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6261         da2=3*da
6262         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6263         da2=da*da1
6264         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6265         da2=da/4
6266         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6267         da3=4/da
6268         da4=da3*da2
6269         self.assertTrue(da4.isUniform(0))
6270         st1=da.getHiddenCppPointer()
6271         da+=1
6272         st2=da.getHiddenCppPointer()
6273         self.assertEqual(st1,st2)
6274         self.assertTrue(da.isEqual(da1))
6275         da-=8
6276         st2=da.getHiddenCppPointer()
6277         self.assertEqual(st1,st2)
6278         self.assertEqual(range(12),da.getValues())
6279         da+=da1
6280         st2=da.getHiddenCppPointer()
6281         self.assertEqual(st1,st2)
6282         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6283         da/=2
6284         st2=da.getHiddenCppPointer()
6285         self.assertEqual(st1,st2)
6286         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6287         da*=da1
6288         st2=da.getHiddenCppPointer()
6289         self.assertEqual(st1,st2)
6290         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6291         da/=da1
6292         self.assertEqual(st1,st2)
6293         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6294         da/=2
6295         st2=da.getHiddenCppPointer()
6296         self.assertEqual(st1,st2)
6297         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6298         da.rearrange(3)
6299         da5=DataArrayInt.New()
6300         da5.setValues([5,4,3,2],4,1)
6301         da*=da5 # it works with unmathing number of compo
6302         st2=da.getHiddenCppPointer()
6303         self.assertEqual(st1,st2)
6304         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6305         da%=6
6306         st2=da.getHiddenCppPointer()
6307         self.assertEqual(st1,st2)
6308         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6309         #
6310         da.alloc(30,1)
6311         da.iota(7)
6312         da.rearrange(3)
6313         ids=DataArrayInt.New()
6314         ids.setValues([3,4,7],3,1)
6315         da[ids,:]=[5,8,9]
6316         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())
6317         #
6318         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6319         da[ids,[1,2]]=[5,8]
6320         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())
6321         pass
6322
6323     def testSwigDAIOp2(self):
6324         da=DataArrayInt.New()
6325         st=da.getHiddenCppPointer()
6326         da.alloc(10,3)
6327         da.rearrange(1)
6328         da.iota(0)
6329         da.rearrange(3)
6330         da[:,1]+=4
6331         da[-2:,2]+=10
6332         da[-2:,2]+=10
6333         da[:,2]+=da[:,0]
6334         da[da[0],:]=7
6335         self.assertEqual(st,da.getHiddenCppPointer())
6336         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])
6337         pass
6338
6339     def testSwigDAIOp3(self):
6340         da=DataArrayInt.New()
6341         self.assertRaises(InterpKernelException,da.__len__)
6342         self.assertRaises(InterpKernelException,da.__int__)
6343         for elt in da:
6344             self.assertTrue(False)
6345             pass
6346         da.alloc(12,3)
6347         da.rearrange(1) ; da.fillWithZero()
6348         l1=list(da)
6349         self.assertEqual(36,len(da));
6350         da.rearrange(3)
6351         tmp=da[0]
6352         self.assertRaises(InterpKernelException,tmp.__int__)
6353         self.assertEqual(12,len(da));
6354         l=list(da)
6355         for elt in enumerate(l):
6356             elt[1][2]=elt[0]
6357             pass
6358         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]
6359         self.assertEqual(ref,da.getValues());
6360         da.rearrange(1)
6361         l=[int(elt) for elt in l1]
6362         self.assertEqual(ref,da.getValues());
6363         self.assertEqual(11,int(da[-1:]))
6364         pass
6365
6366     def testSwigDADOp3(self):
6367         da=DataArrayDouble.New()
6368         self.assertRaises(InterpKernelException,da.__len__)
6369         self.assertRaises(InterpKernelException,da.__float__)
6370         for elt in da:
6371             self.assertTrue(False)
6372             pass
6373         da.alloc(12,3)
6374         da.rearrange(1) ; da.fillWithZero()
6375         l1=list(da)
6376         self.assertEqual(36,len(da));
6377         da.rearrange(3)
6378         tmp=da[0]
6379         self.assertRaises(InterpKernelException,tmp.__float__)
6380         self.assertEqual(12,len(da));
6381         l=list(da)
6382         for elt in enumerate(l):
6383             elt[1][2]=elt[0]
6384             pass
6385         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.]
6386         self.assertEqual(ref,da.getValues());
6387         da.rearrange(1)
6388         l=[float(elt) for elt in l1]
6389         self.assertEqual(ref,da.getValues());
6390         self.assertEqual(11.,float(da[-1:]))
6391         pass
6392
6393     def testSwigDataArrayIntIterator1(self):
6394         da=DataArrayInt.New()
6395         da.alloc(12,1)
6396         da.iota(2)
6397         da.rearrange(3)
6398         # __getitem__ testing
6399         li=[]
6400         for it in da:
6401             li+=it[1:]
6402             pass
6403         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6404         li=[]
6405         for it in da:
6406             li+=[it[-1]]
6407             pass
6408         self.assertEqual([4, 7, 10, 13],li)
6409         li=[]
6410         for it in da:
6411             li+=it[[2,1,0]]
6412             pass
6413         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6414         # __setitem__ testing
6415         da3=da.deepCpy()
6416         da2=DataArrayInt.New()
6417         da2.alloc(12,1)
6418         da2.iota(2002)
6419         da2.rearrange(3)
6420         it2=da2.__iter__()
6421         i=0
6422         for it in da:
6423             pt=it2.next()
6424             it[:]=pt
6425             pass
6426         self.assertTrue(da.isEqual(da2))
6427         da=da3
6428         da3=da.deepCpy()
6429         #
6430         for it in da:
6431             it[:]=5
6432             pass
6433         da.rearrange(1)
6434         self.assertTrue(da.isUniform(5))
6435         da=da3
6436         da3=da.deepCpy()
6437         #
6438         for it in da:
6439             it[:]=[8,9,12]
6440             pass
6441         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6442         da=da3
6443         da3=da.deepCpy()
6444         #
6445         for it in da:
6446             it[2]=[7]
6447             pass
6448         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6449         pass
6450
6451     def testSwigDataArrayDoubleIterator1(self):
6452         da=DataArrayDouble.New()
6453         da.alloc(12,1)
6454         da.iota(2)
6455         da.rearrange(3)
6456         # __getitem__ testing
6457         li=[]
6458         for it in da:
6459             li+=it[1:]
6460             pass
6461         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6462         li=[]
6463         for it in da:
6464             li+=[it[-1]]
6465             pass
6466         self.assertEqual([4, 7, 10, 13],li)
6467         li=[]
6468         for it in da:
6469             li+=it[[2,1,0]]
6470             pass
6471         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6472         # __setitem__ testing
6473         da3=da.deepCpy()
6474         da2=DataArrayDouble.New()
6475         da2.alloc(12,1)
6476         da2.iota(2002)
6477         da2.rearrange(3)
6478         it2=da2.__iter__()
6479         i=0
6480         for it in da:
6481             pt=it2.next()
6482             it[:]=pt
6483             pass
6484         self.assertTrue(da.isEqual(da2,1e-12))
6485         da=da3
6486         da3=da.deepCpy()
6487         #
6488         for it in da:
6489             it[:]=5
6490             pass
6491         da.rearrange(1)
6492         self.assertTrue(da.isUniform(5,1e-12))
6493         da=da3
6494         da3=da.deepCpy()
6495         #
6496         for it in da:
6497             it[:]=[8,9,12]
6498             pass
6499         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6500         da=da3
6501         da3=da.deepCpy()
6502         #
6503         for it in da:
6504             it[2]=[7]
6505             pass
6506         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6507         pass
6508
6509     def testSwigUMeshIterator1(self):
6510         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6511         li1=[]
6512         li2=[]
6513         for cell in m:
6514             li1+=cell.getAllConn()[1:]
6515             li2+=[cell.getType()]
6516             pass
6517         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6518         self.assertEqual(li2,[4, 3, 3, 4, 4])
6519         pass
6520
6521     def testSwigUMeshIterator2(self):
6522         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6523         self.assertRaises(InterpKernelException,m.cellsByType);
6524         m.rearrange2ConsecutiveCellTypes()
6525         li1=[]
6526         li2=[]
6527         li3=[]
6528         for cellsByType in m.cellsByType():
6529             li1.append(cellsByType.getType())
6530             li2.append(cellsByType.getNumberOfElems())
6531             temp=[]
6532             for cell in cellsByType:
6533                 t=[None,None]
6534                 t[0]=cell.getType()
6535                 t[1]=cell.getAllConn()[1:]
6536                 temp.append(t)
6537                 pass
6538             li3.append(temp)
6539             pass
6540         self.assertEqual(li1,[4, 3])
6541         self.assertEqual(li2,[3, 2])
6542         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)]]])
6543         pass
6544
6545     def testDAIAggregateMulti1(self):
6546         a=DataArrayInt.New()
6547         a.setValues(range(4),2,2)
6548         a.setName("aa")
6549         b=DataArrayInt.New()
6550         b.setValues(range(6),3,2)
6551         c=DataArrayInt.Aggregate([a,b])
6552         self.assertEqual(range(4)+range(6),c.getValues())
6553         self.assertEqual("aa",c.getName())
6554         self.assertEqual(5,c.getNumberOfTuples())
6555         self.assertEqual(2,c.getNumberOfComponents())
6556         pass
6557
6558     def testMergeUMeshes2(self):
6559         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6560         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6561         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6562         #
6563         vec1=[0,2,3]
6564         m2_2=m2.buildPartOfMySelf(vec1,False);
6565         vec2=[1,1]
6566         m3_2=m3.buildPartOfMySelf(vec2,False);
6567         #
6568         ms=[m1,m2_2,m3_2];
6569         #
6570         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6571         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6572         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6573         m4.checkCoherency();
6574         self.assertEqual(10,m4.getNumberOfCells());
6575         self.assertEqual(20,m4.getNumberOfNodes());
6576         self.assertEqual(45,m4.getMeshLength());
6577         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6578         self.assertTrue(m4.isEqual(m4bis,1e-12))
6579         del m4bis
6580         #
6581         vec3=[0,1,2,3,4]
6582         m4_1=m4.buildPartOfMySelf(vec3,False);
6583         m4_1.setName(m1.getName());
6584         self.assertTrue(m4_1.isEqual(m1,1e-12));
6585         #
6586         vec4=[5,6,7]
6587         m4_2=m4.buildPartOfMySelf(vec4,False);
6588         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6589         #
6590         vec5=[8,9]
6591         m4_3=m4.buildPartOfMySelf(vec5,False);
6592         self.assertEqual(2,m4_3.getNumberOfCells());
6593         self.assertEqual(3,m4_3.getNumberOfNodes());
6594         m3_2.zipCoords();
6595         m4_3.setName(m3_2.getName());
6596         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6597         #
6598         pass
6599
6600     def testBuild0DMeshFromCoords1(self):
6601         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6602         coo=DataArrayDouble.New();
6603         coo.setValues(sourceCoords,4,3);
6604         coo.setName("My0D");
6605         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6606         m.checkCoherency();
6607         self.assertEqual(4,m.getNumberOfNodes());
6608         self.assertEqual(4,m.getNumberOfCells());
6609         self.assertEqual(3,m.getSpaceDimension());
6610         self.assertEqual(0,m.getMeshDimension());
6611         types1=m.getAllTypes();
6612         self.assertEqual([NORM_POINT1],types1);
6613         for i in xrange(4):
6614             conn=m.getNodeIdsOfCell(i);
6615             self.assertEqual([i],conn);
6616             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6617             pass
6618         self.assertEqual(m.getName(),"My0D");
6619         pass
6620
6621     def testDescriptionInMeshTimeUnit1(self):
6622         text1="totoTTEDD";
6623         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6624         m.setDescription(text1);
6625         self.assertEqual(m.getDescription(),text1);
6626         m2=m.deepCpy();
6627         self.assertTrue(m.isEqual(m2,1e-12));
6628         self.assertEqual(m2.getDescription(),text1);
6629         m2.setDescription("ggg");
6630         self.assertTrue(not m.isEqual(m2,1e-12));
6631         #
6632         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6633         f.setTimeUnit(text1);
6634         self.assertEqual(f.getTimeUnit(),text1);
6635         f2=f.deepCpy();
6636         self.assertEqual(f2.getTimeUnit(),text1);
6637         #
6638         pass
6639
6640     def testMultiFields1(self):
6641         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6642         ms=mfs.getMeshes();
6643         dms,refs=mfs.getDifferentMeshes()
6644         das=mfs.getArrays();
6645         das2,refs2=mfs.getDifferentArrays()
6646         self.assertEqual(5,len(mfs.getFields()))
6647         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6648         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6649         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6650         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6651         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6652         self.assertEqual(5,len(ms));
6653         self.assertEqual(2,len(dms));
6654         self.assertEqual(6,len(das));
6655         self.assertEqual(5,len(das2));
6656         mfs2=mfs.deepCpy();
6657         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6658         pass
6659
6660     def testFieldOverTime1(self):
6661         fs=MEDCouplingDataForTest.buildMultiFields_2();
6662         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6663         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6664         fs[4]=f4bis;
6665         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6666         f4bis.setTime(2.7,20,21);
6667         fot=MEDCouplingFieldOverTime.New(fs);
6668         dt=fot.getDefinitionTimeZone();
6669         hs=dt.getHotSpotsTime();
6670         self.assertEqual(6,len(hs));
6671         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6672         for i in xrange(6):
6673             self.assertAlmostEqual(expected1[i],hs[i],12);
6674             pass
6675         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6676         self.assertEqual(0,meshId);
6677         self.assertEqual(0,arrId);
6678         self.assertEqual(0,arrIdInField);
6679         self.assertEqual(0,fieldId);
6680         #
6681         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6682         self.assertEqual(0,meshId);
6683         self.assertEqual(1,arrId);
6684         self.assertEqual(0,arrIdInField);
6685         self.assertEqual(1,fieldId);
6686         #
6687         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6688         self.assertEqual(0,meshId);
6689         self.assertEqual(2,arrId);
6690         self.assertEqual(1,arrIdInField);
6691         self.assertEqual(1,fieldId);
6692         #
6693         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
6694         self.assertEqual(1,meshId);
6695         self.assertEqual(3,arrId);
6696         self.assertEqual(0,arrIdInField);
6697         self.assertEqual(2,fieldId);
6698         #
6699         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.35);
6700         self.assertEqual(1,meshId);
6701         self.assertEqual(3,arrId);
6702         self.assertEqual(0,arrIdInField);
6703         self.assertEqual(2,fieldId);
6704         #
6705         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6706         self.assertEqual(0,meshId);
6707         self.assertEqual(3,arrId);
6708         self.assertEqual(0,arrIdInField);
6709         self.assertEqual(3,fieldId);
6710         #
6711         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6712         self.assertEqual(1,meshId);
6713         self.assertEqual(4,arrId);
6714         self.assertEqual(0,arrIdInField);
6715         self.assertEqual(4,fieldId);
6716         #
6717         dt2=MEDCouplingDefinitionTime();
6718         self.assertTrue(not dt2.isEqual(dt));
6719         dt2.assign(dt);
6720         dt2.assign(dt);#to check memory management
6721         self.assertTrue(dt2.isEqual(dt));
6722         #
6723         dt3=MEDCouplingDefinitionTime();
6724         #
6725         pass
6726
6727     def testDAICheckAndPreparePermutation1(self):
6728         vals1=[9,10,0,6,4,11,3,7];
6729         expect1=[5,6,0,3,2,7,1,4];
6730         vals2=[9,10,0,6,10,11,3,7];
6731         da=DataArrayInt.New();
6732         da.setValues(vals1,8,1);
6733         da2=da.checkAndPreparePermutation();
6734         self.assertEqual(8,da2.getNumberOfTuples());
6735         self.assertEqual(1,da2.getNumberOfComponents());
6736         for i in xrange(8):
6737             self.assertEqual(expect1[i],da2.getIJ(i,0));
6738             pass
6739         #
6740         da=DataArrayInt.New();
6741         da.alloc(8,1);
6742         da.iota(0);
6743         da2=da.checkAndPreparePermutation();
6744         self.assertEqual(8,da2.getNumberOfTuples());
6745         self.assertEqual(1,da2.getNumberOfComponents());
6746         self.assertTrue(da2.isIdentity());
6747         #
6748         da=DataArrayInt.New();
6749         da.alloc(8,1);
6750         da.setValues(vals2,8,1);
6751         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6752         pass
6753
6754     def testDAIChangeSurjectiveFormat1(self):
6755         vals1=[0,3,2,3,2,2,1,2]
6756         expected1=[0,1,2,6,8]
6757         expected2=[0,  6,  2,4,5,7,  1,3]
6758         da=DataArrayInt.New();
6759         da.setValues(vals1,8,1);
6760         #
6761         da2,da2I=da.changeSurjectiveFormat(4);
6762         self.assertEqual(5,da2I.getNumberOfTuples());
6763         self.assertEqual(8,da2.getNumberOfTuples());
6764         self.assertEqual(expected1,da2I.getValues());
6765         self.assertEqual(expected2,da2.getValues());
6766         #
6767         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6768         #
6769         pass
6770
6771     def testUMeshGetCellIdsLyingOnNodes1(self):
6772         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6773         nodeIds1=[1,2,3,4,6]
6774         nodeIds2=[6,7]
6775         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6776         self.assertEqual(1,da.getNumberOfTuples());
6777         self.assertEqual(1,da.getNumberOfComponents());
6778         self.assertEqual(1,da.getIJ(0,0));
6779         da2=DataArrayInt.New()
6780         da2.setValues(nodeIds2,2,1)
6781         da=m.getCellIdsLyingOnNodes(da2,False);
6782         self.assertEqual(2,da.getNumberOfTuples());
6783         self.assertEqual(1,da.getNumberOfComponents());
6784         self.assertEqual(3,da.getIJ(0,0));
6785         self.assertEqual(4,da.getIJ(1,0));
6786         pass
6787
6788     def testUMeshFindCellIdsOnBoundary1(self):
6789         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6790         da5=m.findCellIdsOnBoundary();
6791         self.assertEqual(5,da5.getNumberOfTuples());
6792         self.assertTrue(da5.isIdentity());
6793         pass
6794
6795     def testMeshSetTime1(self):
6796         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6797         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6798         #
6799         self.assertTrue(m1.isEqual(m2,1e-12));
6800         m1.setTime(3.14,6,7);
6801         tmp3,tmp1,tmp2=m1.getTime();
6802         self.assertEqual(6,tmp1);
6803         self.assertEqual(7,tmp2);
6804         self.assertAlmostEqual(3.14,tmp3,12);
6805         self.assertTrue(not m1.isEqual(m2,1e-12));
6806         m2.setTime(3.14,6,7);
6807         self.assertTrue(m1.isEqual(m2,1e-12));
6808         m1.setTimeUnit("ms");
6809         self.assertTrue(m1.getTimeUnit()=="ms");
6810         m1.setTimeUnit("us");
6811         self.assertTrue(m1.getTimeUnit()=="us");
6812         self.assertTrue(not m1.isEqual(m2,1e-12));
6813         m2.setTimeUnit("us");
6814         self.assertTrue(m1.isEqual(m2,1e-12));
6815         m2.setTime(3.14,6,8);
6816         self.assertTrue(not m1.isEqual(m2,1e-12));
6817         m2.setTime(3.14,7,7);
6818         self.assertTrue(not m1.isEqual(m2,1e-12));
6819         m2.setTime(3.15,6,7);
6820         self.assertTrue(not m1.isEqual(m2,1e-12));
6821         #
6822         m1.setTime(10.34,55,12);
6823         m3=m1.deepCpy();
6824         self.assertTrue(m1.isEqual(m3,1e-12));
6825         tmp3,tmp1,tmp2=m3.getTime();
6826         self.assertEqual(55,tmp1);
6827         self.assertEqual(12,tmp2);
6828         self.assertAlmostEqual(10.34,tmp3,12);
6829         #
6830         # testing CMesh
6831         coo1=[0.,1.,2.,3.5]
6832         a=DataArrayDouble.New();
6833         a.setValues(coo1,4,1);
6834         b=MEDCouplingCMesh.New();
6835         b.setCoordsAt(0,a);
6836         #
6837         b.setTime(5.67,8,100);
6838         tmp3,tmp1,tmp2=b.getTime();
6839         self.assertEqual(8,tmp1);
6840         self.assertEqual(100,tmp2);
6841         self.assertAlmostEqual(5.67,tmp3,12);
6842         c=b.deepCpy();
6843         self.assertTrue(c.isEqual(b,1e-12));
6844         tmp3,tmp1,tmp2=c.getTime();
6845         self.assertEqual(8,tmp1);
6846         self.assertEqual(100,tmp2);
6847         self.assertAlmostEqual(5.67,tmp3,12);
6848         pass
6849
6850     def testApplyFuncTwo1(self):
6851         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6852         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6853         f1.setMesh(m1);
6854         #
6855         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6856         da=DataArrayDouble.New();
6857         da.setValues(vals,5,3);
6858         f1.setArray(da);
6859         #
6860         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6861         da.setInfoOnComponent(0,"x [m]");
6862         da.setInfoOnComponent(1,"y [mm]");
6863         da.setInfoOnComponent(2,"z [km]");
6864
6865         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6866         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6867         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6868
6869         da2=da.applyFunc2(1,"y+z");
6870         self.assertEqual(1,da2.getNumberOfComponents());
6871         self.assertEqual(5,da2.getNumberOfTuples());
6872         expected1=[32.,34.,36.,38.,40.]
6873         for i in xrange(5):
6874             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6875             pass
6876         da2=da.applyFunc(1,"y+z");
6877         expected2=[12.,14.,16.,18.,20.]
6878         for i in xrange(5):
6879             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6880             pass
6881         #
6882         self.assertEqual(3,f1.getNumberOfComponents());
6883         self.assertEqual(5,f1.getNumberOfTuples());
6884         f1.applyFunc2(1,"y+z");
6885         self.assertEqual(1,f1.getNumberOfComponents());
6886         self.assertEqual(5,f1.getNumberOfTuples());
6887         for i in xrange(5):
6888             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6889             pass
6890         #
6891         pass
6892
6893     def testApplyFuncThree1(self):
6894         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6895         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6896         f1.setMesh(m1);
6897         #
6898         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6899         da=DataArrayDouble.New();
6900         da.setValues(vals,5,3);
6901         f1.setArray(da);
6902         #
6903         vs=3*[None];
6904         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6905         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
6906         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
6907         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
6908         vs[1]="y";
6909         da2=da.applyFunc3(1,vs,"y+z");
6910         expected1=[32.,34.,36.,38.,40.]
6911         for i in xrange(5):
6912             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6913             pass
6914         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
6915         f1.setArray(da);
6916         self.assertEqual(3,f1.getNumberOfComponents());
6917         self.assertEqual(5,f1.getNumberOfTuples());
6918         f1.applyFunc3(1,vs,"y+z");
6919         self.assertEqual(1,f1.getNumberOfComponents());
6920         self.assertEqual(5,f1.getNumberOfTuples());
6921         for i in xrange(5):
6922             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6923             pass
6924         pass
6925
6926     def testFillFromAnalyticTwo1(self):
6927         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6928         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6929         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
6930         m1.getCoords().setInfoOnComponent(0,"x [m]");
6931         m1.getCoords().setInfoOnComponent(1,"y");
6932         m1.getCoords().setInfoOnComponent(2,"z");
6933         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
6934         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6935         self.assertEqual("us",f1.getTimeUnit())
6936         self.assertEqual(1,f1.getNumberOfComponents());
6937         self.assertEqual(9,f1.getNumberOfTuples());
6938         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6939         for i in xrange(9):
6940             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6941             pass
6942         pass
6943
6944     def testFillFromAnalyticThree1(self):
6945         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6946         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6947         vs=3*[None];
6948         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6949         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
6950         vs[1]="y";
6951         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
6952         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6953         self.assertEqual("us",f1.getTimeUnit())
6954         self.assertEqual(1,f1.getNumberOfComponents());
6955         self.assertEqual(9,f1.getNumberOfTuples());
6956         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6957         for i in xrange(9):
6958             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6959             pass
6960         pass
6961
6962     def testDAUnitVar1(self):
6963         da=DataArrayDouble.New();
6964         da.alloc(1,3);
6965         da.setInfoOnComponent(0,"XPS [m]");
6966         st1=da.getVarOnComponent(0);
6967         self.assertTrue(st1=="XPS");
6968         st2=da.getUnitOnComponent(0);
6969         self.assertTrue(st2=="m");
6970         #
6971         da.setInfoOnComponent(0,"XPS         [m]");
6972         st1=da.getVarOnComponent(0);
6973         self.assertTrue(st1=="XPS");
6974         st2=da.getUnitOnComponent(0);
6975         self.assertTrue(st2=="m");
6976         #
6977         da.setInfoOnComponent(0,"XPP         [m]");
6978         st1=da.getVarOnComponent(0);
6979         self.assertTrue(st1=="XPP");
6980         st2=da.getUnitOnComponent(0);
6981         self.assertTrue(st2=="m");
6982         #
6983         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
6984         st1=da.getVarOnComponent(0);
6985         self.assertTrue(st1=="XPP kdep  kefer");
6986         st2=da.getUnitOnComponent(0);
6987         self.assertTrue(st2==" m  ");
6988         #
6989         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
6990         st1=da.getVarOnComponent(0);
6991         self.assertTrue(st1=="     XPP k[  dep  k]efer");
6992         st2=da.getUnitOnComponent(0);
6993         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
6994         #
6995         da.setInfoOnComponent(0,"     XPP kefer   ");
6996         st1=da.getVarOnComponent(0);
6997         self.assertTrue(st1=="     XPP kefer   ");
6998         st2=da.getUnitOnComponent(0);
6999         self.assertTrue(st2=="");
7000         #
7001         da.setInfoOnComponent(0,"temperature( bof)");
7002         st1=da.getVarOnComponent(0);
7003         self.assertTrue(st1=="temperature( bof)");
7004         st2=da.getUnitOnComponent(0);
7005         self.assertTrue(st2=="");
7006         #
7007         da.setInfoOnComponent(0,"kkk [m]");
7008         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
7009         da.setInfoOnComponent(2,"abcde   [MW/s]");
7010         #
7011         vs=da.getVarsOnComponent();
7012         self.assertEqual(3,len(vs));
7013         self.assertTrue(vs[0]=="kkk");
7014         self.assertTrue(vs[1]=="ppp");
7015         self.assertTrue(vs[2]=="abcde");
7016         vs=da.getUnitsOnComponent();
7017         self.assertEqual(3,len(vs));
7018         self.assertTrue(vs[0]=="m");
7019         self.assertTrue(vs[1]=="m^2/kJ");
7020         self.assertTrue(vs[2]=="MW/s");
7021         pass
7022
7023     def testGaussCoordinates1(self):
7024         #Testing 1D cell types
7025         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7026         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7027         f.setMesh(m1);
7028         wg1=[0.3];
7029         gsCoo1=[0.2];
7030         refCoo1=[-1.0,1.0];
7031         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7032         wg2=wg1;
7033         gsCoo2=[0.2];
7034         refCoo2=[-1.0,1.0,0.0];
7035         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7036         #
7037         resToTest=f.getLocalizationOfDiscr();
7038         self.assertEqual(3,resToTest.getNumberOfComponents());
7039         self.assertEqual(2,resToTest.getNumberOfTuples());
7040         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7041         for i in xrange(6):
7042             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7043             pass
7044         #
7045         #Testing 2D cell types
7046         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7047         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7048         f.setMesh(m2);
7049         wg3=[0.3,0.3];
7050         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7051         gsCoo3=tria3CooGauss
7052         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7053         refCoo3=tria3CooRef;
7054         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7055         wg4=[0.3,0.3,0.3];
7056         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7057         gsCoo4=tria6CooGauss;
7058         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]
7059         refCoo4=tria6CooRef;
7060         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7061         wg5=[0.3,0.3,0.3,0.3];
7062         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7063         gsCoo5=quad4CooGauss;
7064         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7065         refCoo5=quad4CooRef;
7066         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7067         wg6=[0.3,0.3,0.3,0.3];
7068         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7069         gsCoo6=quad8CooGauss;
7070         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]
7071         refCoo6=quad8CooRef;
7072         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7073         #
7074         resToTest=f.getLocalizationOfDiscr();
7075         self.assertEqual(3,resToTest.getNumberOfComponents());
7076         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7077         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7078                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7079                    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
7080                    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
7081         for i in xrange(39):
7082             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7083             pass
7084         #
7085         #Testing 3D cell types
7086         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7087         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7088         f.setMesh(m3);
7089         #
7090         wg7=[0.3];
7091         tetra4CooGauss=[0.34, 0.16, 0.21]
7092         gsCoo7=tetra4CooGauss;
7093         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]
7094         refCoo7=tetra4CooRef;
7095         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7096         wg8=[0.3];
7097         tetra10CooGauss=[0.2, 0.3, 0.1]
7098         gsCoo8=tetra10CooGauss;
7099         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]
7100         refCoo8=tetra10CooRef;
7101         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7102         wg9=[0.3];
7103         pyra5CooGauss=[0.2, 0.3, 0.1]
7104         gsCoo9=pyra5CooGauss;
7105         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]
7106         refCoo9=pyra5CooRef;
7107         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7108         wg10=[0.3];
7109         pyra13CooGauss=[0.1, 0.2, 0.7]
7110         gsCoo10=pyra13CooGauss;
7111         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]
7112         refCoo10=pyra13CooRef;
7113         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7114         wg11=[0.3];
7115         penta6CooGauss=[0.2, 0.3, 0.1]
7116         gsCoo11=penta6CooGauss;
7117         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]
7118         refCoo11=penta6CooRef;
7119         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7120         wg12=[0.3];
7121         penta15CooGauss=[0.2, 0.3,0.15]
7122         gsCoo12=penta15CooGauss;
7123         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]
7124         refCoo12=penta15CooRef;
7125         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7126         wg13=[0.3];
7127         hexa8CooGauss=[0.2,0.3,0.15]
7128         gsCoo13=hexa8CooGauss;
7129         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]
7130         refCoo13=hexa8CooRef;
7131         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7132         wg14=[0.3];
7133         hexa20CooGauss=[0.11,0.3,0.55]
7134         gsCoo14=hexa20CooGauss;
7135         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]
7136         refCoo14=hexa20CooRef;
7137         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7138         #
7139         resToTest=f.getLocalizationOfDiscr();
7140         self.assertEqual(3,resToTest.getNumberOfComponents());
7141         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7142         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]
7143         for i in xrange(24):
7144             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7145             pass
7146         #
7147         pass
7148
7149     def testP2Localization1(self):
7150         m=MEDCouplingUMesh.New("testP2",2);
7151         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7152         conn=[0,1,2,3,4,5]
7153         coo=DataArrayDouble.New();
7154         coo.setValues(coords,6,2);
7155         m.setCoords(coo);
7156         m.allocateCells(1);
7157         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7158         m.finishInsertingCells();
7159         #
7160         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7161         f.setMesh(m);
7162         da=DataArrayDouble.New();
7163         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]
7164         da.setValues(vals1,6,3);
7165         f.setArray(da);
7166         #
7167         loc=[2.27,1.3]
7168         locs=f.getValueOnMulti(loc);
7169         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7170         for i in xrange(3):
7171             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7172             pass
7173         pass
7174
7175     def testP2Localization2(self):
7176         m=MEDCouplingUMesh.New("testP2_2",3);
7177         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]
7178         conn=[0,1,2,3,4,5,6,7,8,9]
7179         coo=DataArrayDouble.New();
7180         coo.setValues(coords,10,3);
7181         m.setCoords(coo);
7182         m.allocateCells(1);
7183         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7184         m.finishInsertingCells();
7185         #
7186         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7187         f.setMesh(m);
7188         da=DataArrayDouble.New();
7189         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7190         da.setValues(vals1,10,1);
7191         f.setArray(da);
7192         #
7193         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7194         locs=f.getValueOnMulti(loc);
7195         expected1=[10.0844021968047]
7196         for i in xrange(1):
7197             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7198             pass
7199         pass
7200
7201     def testGetValueOn2(self):
7202         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7203         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7204         f.setMesh(m);
7205         arr=DataArrayDouble.New();
7206         nbOfCells=m.getNumberOfCells();
7207         f.setArray(arr);
7208         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7209         arr.setValues(values1,nbOfCells,3);
7210         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7211         f.checkCoherency();
7212         locs=f.getValueOnMulti(loc);
7213         self.assertEqual(5,locs.getNumberOfTuples());
7214         self.assertEqual(3,locs.getNumberOfComponents());
7215         for j in xrange(15):
7216             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7217             pass
7218         # Testing ON_NODES
7219         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7220         f.setMesh(m);
7221         arr=DataArrayDouble.New();
7222         nbOfNodes=m.getNumberOfNodes();
7223         f.setArray(arr);
7224         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.]
7225         arr.setValues(values2,nbOfNodes,3);
7226         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7227         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]
7228         f.checkCoherency();
7229         loc3=DataArrayDouble.New()
7230         loc3.setValues(loc2,4,2);
7231         locs=f.getValueOnMulti(loc3);
7232         self.assertEqual(4,locs.getNumberOfTuples());
7233         self.assertEqual(3,locs.getNumberOfComponents());
7234         for i in xrange(12):
7235             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7236             pass
7237         #
7238         pass
7239
7240     def testDAIGetIdsNotEqual1(self):
7241         d=DataArrayInt.New();
7242         vals1=[2,3,5,6,8,5,5,6,1,-5]
7243         d.setValues(vals1,10,1);
7244         d2=d.getIdsNotEqual(5);
7245         self.assertEqual(7,d2.getNumberOfTuples());
7246         self.assertEqual(1,d2.getNumberOfComponents());
7247         expected1=[0,1,3,4,7,8,9]
7248         for i in xrange(7):
7249             self.assertEqual(expected1[i],d2.getIJ(0,i));
7250             pass
7251         d.rearrange(2);
7252         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7253         vals2=[-4,5,6]
7254         vals3=vals2;
7255         d.rearrange(1);
7256         d3=d.getIdsNotEqualList(vals3);
7257         self.assertEqual(5,d3.getNumberOfTuples());
7258         self.assertEqual(1,d3.getNumberOfComponents());
7259         expected2=[0,1,4,8,9]
7260         for i in xrange(5):
7261             self.assertEqual(expected2[i],d3.getIJ(0,i));
7262             pass
7263         pass
7264
7265     def testDAIComputeOffsets1(self):
7266         d=DataArrayInt.New();
7267         vals1=[3,5,1,2,0,8]
7268         expected1=[0,3,8,9,11,11]
7269         d.setValues(vals1,6,1);
7270         d.computeOffsets();
7271         self.assertEqual(6,d.getNumberOfTuples());
7272         self.assertEqual(1,d.getNumberOfComponents());
7273         for i in xrange(6):
7274             self.assertEqual(expected1[i],d.getIJ(0,i));
7275             pass
7276         pass
7277
7278     def testUMeshHexagonPrism1(self):
7279         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,
7280                 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];
7281         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7282         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7283         coo=DataArrayDouble.New();
7284         coo.setValues(coords,12,3);
7285         mesh.setCoords(coo);
7286         mesh.allocateCells(1);
7287         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7288         mesh.finishInsertingCells();
7289         #
7290         mesh.checkCoherency();
7291         vols=mesh.getMeasureField(False);
7292         self.assertEqual(1,vols.getNumberOfTuples());
7293         self.assertEqual(1,vols.getNumberOfComponents());
7294         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7295         bary=mesh.getBarycenterAndOwner();
7296         self.assertEqual(1,bary.getNumberOfTuples());
7297         self.assertEqual(3,bary.getNumberOfComponents());
7298         expected1=[0.,0.,1.]
7299         for i in xrange(3):
7300             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7301             pass
7302         d1=DataArrayInt.New();
7303         d2=DataArrayInt.New();
7304         d3=DataArrayInt.New();
7305         d4=DataArrayInt.New();
7306         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7307         self.assertEqual(8,m2.getNumberOfCells());
7308         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]];
7309         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7310         expected3=[6,6,4,4,4,4,4,4]
7311         for i in xrange(8):
7312             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7313             v=m2.getNodeIdsOfCell(i);
7314             self.assertTrue(len(v)==expected3[i]);
7315             self.assertEqual(expected4[i],v);
7316         #
7317         mesh.convertAllToPoly();
7318         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7319         mesh.unPolyze();
7320         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7321         self.assertEqual(13,mesh.getMeshLength());
7322         #
7323         pass
7324
7325     def testDADCheckIsMonotonic(self):
7326         da=DataArrayDouble.New();
7327         da.setValues([-1.,1.01,2.03,6.],2,2);
7328         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7329         da.rearrange(1);
7330         self.assertTrue(da.isMonotonic(True,1e-12));
7331         da.checkMonotonic(True,1e-12);
7332         da.setIJ(2,0,6.1);
7333         self.assertTrue(not da.isMonotonic(True,1e-12));
7334         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7335         da.setIJ(2,0,5.99);
7336         self.assertTrue(da.isMonotonic(True,1e-12));
7337         self.assertTrue(not da.isMonotonic(True,1e-1));
7338         pass
7339
7340     def testCheckCoherencyDeeper1(self):
7341         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7342         m.checkCoherency();
7343         m.checkCoherency1();
7344         m.getNodalConnectivity().setIJ(8,0,-1);
7345         m.checkCoherency();
7346         self.assertRaises(InterpKernelException,m.checkCoherency1);
7347         m.getNodalConnectivity().setIJ(8,0,-6);
7348         m.checkCoherency();
7349         self.assertRaises(InterpKernelException,m.checkCoherency1);
7350         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7351         m.checkCoherency();
7352         self.assertRaises(InterpKernelException,m.checkCoherency1);
7353         m.getNodalConnectivity().setIJ(8,0,8);#OK
7354         m.checkCoherency();
7355         m.checkCoherency1();
7356         elts=[1,5]
7357         m.convertToPolyTypes(elts);
7358         m.checkCoherency();
7359         m.checkCoherency1();
7360         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7361         m.checkCoherency();
7362         self.assertRaises(InterpKernelException,m.checkCoherency1);
7363         m.getNodalConnectivity().setIJ(2,0,-3);
7364         m.checkCoherency();
7365         self.assertRaises(InterpKernelException,m.checkCoherency1);
7366         m.getNodalConnectivity().setIJ(2,0,-1);
7367         m.checkCoherency();
7368         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7369         m.getNodalConnectivity().setIJ(2,0,4);
7370         m.checkCoherency();
7371         m.checkCoherency1();
7372         m.getNodalConnectivity().setIJ(7,0,-1);
7373         m.checkCoherency();
7374         m.checkCoherency1();#OK because we are in polyhedron connec
7375         m.getNodalConnectivity().setIJ(36,0,14);
7376         m.checkCoherency();
7377         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7378         pass
7379
7380     def testUnPolyze2(self):
7381         m=MEDCouplingUMesh.New("jjj",3);
7382         coo=DataArrayDouble.New();
7383         coo.alloc(4,3);
7384         coo.rearrange(1);
7385         coo.iota(0);
7386         coo.rearrange(3);
7387         m.setCoords(coo);
7388         m.allocateCells(2);
7389         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7390         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7391         m.finishInsertingCells();
7392         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7393         m2.convertToPolyTypes([2]);
7394         m2.unPolyze();
7395         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7396         self.assertEqual(40,m2.getMeshLength());
7397         temp2=m2.getNodeIdsOfCell(2);
7398         self.assertEqual(temp2,[0,1,2,3]);
7399         m2.checkCoherency1();
7400         m3=m2.deepCpy();
7401         m2.unPolyze();
7402         self.assertTrue(m3.isEqual(m2,1e-12));
7403         pass
7404
7405     def testDACpyFrom1(self):
7406         d=DataArrayDouble.New();
7407         d.alloc(12,1);
7408         d.iota(14.);
7409         d.rearrange(3);
7410         d.setName("Toto");
7411         d.setInfoOnComponent(0,"X [m]");
7412         d.setInfoOnComponent(1,"Y [m]");
7413         d.setInfoOnComponent(2,"Z [m]");
7414         #
7415         d1=DataArrayDouble.New();
7416         self.assertTrue(not d.isEqual(d1,1e-12));
7417         d1.cpyFrom(d);
7418         self.assertTrue(d.isEqual(d1,1e-12));
7419         d1.cpyFrom(d);
7420         self.assertTrue(d.isEqual(d1,1e-12));
7421         d1.rearrange(2);
7422         self.assertTrue(not d.isEqual(d1,1e-12));
7423         d1.cpyFrom(d);
7424         self.assertTrue(d.isEqual(d1,1e-12));
7425         #
7426         d2=d.convertToIntArr();
7427         d4=DataArrayInt.New();
7428         self.assertTrue(not d2.isEqual(d4));
7429         d4.cpyFrom(d2);
7430         self.assertTrue(d2.isEqual(d4));
7431         d4.cpyFrom(d2);
7432         self.assertTrue(d2.isEqual(d4));
7433         d4.rearrange(2);
7434         self.assertTrue(not d2.isEqual(d4));
7435         d4.cpyFrom(d2);
7436         self.assertTrue(d2.isEqual(d4));
7437         pass
7438
7439     def testDAITransformWithIndArr1(self):
7440         tab1=[17,18,22,19]
7441         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7442         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7443         d=DataArrayInt.New();
7444         d.setValues(tab1,4,1);
7445         d1=DataArrayInt.New();
7446         d1.setValues(tab2,12,1);
7447         d2=d1[:]
7448         #
7449         d1.transformWithIndArr(d);
7450         self.assertEqual(12,d1.getNumberOfTuples());
7451         self.assertEqual(1,d1.getNumberOfComponents());
7452         for i in xrange(12):
7453             self.assertEqual(expected[i],d1.getIJ(i,0));
7454             pass
7455         #
7456         d1=d2
7457         d1.transformWithIndArr(tab1)
7458         self.assertEqual(12,d1.getNumberOfTuples());
7459         self.assertEqual(1,d1.getNumberOfComponents());
7460         for i in xrange(12):
7461             self.assertEqual(expected[i],d1.getIJ(i,0));
7462             pass
7463         pass
7464
7465     def testDAIBuildPermArrPerLevel1(self):
7466         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7467         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7468         da=DataArrayInt.New();
7469         da.setValues(arr,12,1);
7470         da2=da.buildPermArrPerLevel();
7471         self.assertEqual(12,da2.getNumberOfTuples());
7472         self.assertEqual(1,da2.getNumberOfComponents());
7473         for i in xrange(12):
7474             self.assertEqual(expected1[i],da2.getIJ(i,0));
7475             pass
7476         pass
7477
7478     def testDAIOperations1(self):
7479         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7480         da=DataArrayInt.New();
7481         da.setValues(arr1,4,3);
7482         da1=DataArrayInt.New();
7483         da1.alloc(12,1);
7484         da1.iota(2);
7485         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7486         da1.rearrange(3);
7487         da2=DataArrayInt.Add(da,da1);
7488         self.assertEqual(4,da2.getNumberOfTuples());
7489         self.assertEqual(3,da2.getNumberOfComponents());
7490         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7491         for i in xrange(12):
7492             self.assertEqual(expected1[i],da2.getIJ(0,i));
7493             pass
7494         da1.substractEqual(da);
7495         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7496         for i in xrange(12):
7497             self.assertEqual(expected2[i],da1.getIJ(0,i));
7498             pass
7499         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7500         da1.addEqual(da);
7501         for i in xrange(12):
7502             self.assertEqual(expected1[i],da1.getIJ(0,i));
7503             pass
7504         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7505         da2=DataArrayInt.Multiply(da,da1);
7506         self.assertEqual(4,da2.getNumberOfTuples());
7507         self.assertEqual(3,da2.getNumberOfComponents());
7508         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7509         for i in xrange(12):
7510             self.assertEqual(expected3[i],da2.getIJ(0,i));
7511             pass
7512         da.divideEqual(da1);
7513         self.assertEqual(4,da.getNumberOfTuples());
7514         self.assertEqual(3,da.getNumberOfComponents());
7515         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7516         for i in xrange(12):
7517             self.assertEqual(expected4[i],da.getIJ(0,i));
7518             pass
7519         da.setValues(arr1,4,3);
7520         da1.multiplyEqual(da);
7521         self.assertEqual(4,da1.getNumberOfTuples());
7522         self.assertEqual(3,da1.getNumberOfComponents());
7523         for i in xrange(12):
7524             self.assertEqual(expected3[i],da1.getIJ(0,i));
7525             pass
7526         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7527         da2=DataArrayInt.Divide(da,da1);
7528         self.assertEqual(4,da2.getNumberOfTuples());
7529         self.assertEqual(3,da2.getNumberOfComponents());
7530         for i in xrange(12):
7531             self.assertEqual(expected4[i],da2.getIJ(0,i));
7532             pass
7533         da1.applyInv(321);
7534         self.assertEqual(4,da1.getNumberOfTuples());
7535         self.assertEqual(3,da1.getNumberOfComponents());
7536         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7537         for i in xrange(12):
7538             self.assertEqual(expected5[i],da1.getIJ(0,i));
7539             pass
7540         da1.applyDivideBy(2);
7541         self.assertEqual(4,da1.getNumberOfTuples());
7542         self.assertEqual(3,da1.getNumberOfComponents());
7543         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7544         for i in xrange(12):
7545             self.assertEqual(expected6[i],da1.getIJ(0,i));
7546             pass
7547         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7548         da1.applyModulus(7);
7549         for i in xrange(12):
7550             self.assertEqual(expected7[i],da1.getIJ(0,i));
7551             pass
7552         da1.applyLin(1,1);
7553         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7554         da1.applyRModulus(3);
7555         for i in xrange(12):
7556             self.assertEqual(expected8[i],da1.getIJ(0,i));
7557             pass
7558         pass
7559
7560     def testEmulateMEDMEMBDC1(self):
7561         m,m1=MEDCouplingDataForTest.buildPointe_1();
7562         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7563         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]
7564         expected1=[1,32,29,23,41,36]
7565         self.assertEqual(47,da0.getNumberOfTuples());
7566         self.assertEqual(1,da0.getNumberOfComponents());
7567         for i in xrange(47):
7568             self.assertEqual(expected0[i],da0.getIJ(0,i));
7569             pass
7570         self.assertEqual(6,da5.getNumberOfTuples());
7571         self.assertEqual(1,da5.getNumberOfComponents());
7572         for i in xrange(6):
7573             self.assertEqual(expected1[i],da5.getIJ(0,i));
7574             pass
7575         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]
7576         self.assertEqual(70,da1.getNumberOfTuples());
7577         self.assertEqual(1,da1.getNumberOfComponents());
7578         for i in xrange(70):
7579             self.assertEqual(expected2[i],da1.getIJ(0,i));
7580             pass
7581         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7582         self.assertEqual(17,da2.getNumberOfTuples());
7583         self.assertEqual(1,da2.getNumberOfComponents());
7584         for i in xrange(17):
7585             self.assertEqual(expected3[i],da2.getIJ(0,i));
7586             pass
7587         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]
7588         #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];
7589         self.assertEqual(48,da4.getNumberOfTuples());
7590         self.assertEqual(1,da4.getNumberOfComponents());
7591         for i in xrange(48):
7592             self.assertEqual(expected4[i],da4.getIJ(0,i));
7593             pass
7594         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]
7595         self.assertEqual(70,da3.getNumberOfTuples());
7596         self.assertEqual(1,da3.getNumberOfComponents());
7597         for i in xrange(70):
7598             self.assertEqual(expected5[i],da3.getIJ(0,i));
7599             pass
7600         pass
7601
7602     def testGetLevArrPerCellTypes1(self):
7603         m,m1=MEDCouplingDataForTest.buildPointe_1();
7604         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7605         order=[NORM_TRI3,NORM_QUAD4];
7606         da0,da1=m1.getLevArrPerCellTypes(order);
7607         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]
7608         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]
7609         self.assertEqual(47,da0.getNumberOfTuples());
7610         self.assertEqual(1,da0.getNumberOfComponents());
7611         for i in xrange(47):
7612             self.assertEqual(expected0[i],da0.getIJ(0,i));
7613             pass
7614         self.assertEqual(2,da1.getNumberOfTuples());
7615         self.assertEqual(1,da1.getNumberOfComponents());
7616         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7617         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7618         #
7619         da2=da0.buildPermArrPerLevel();
7620         #
7621         self.assertEqual(47,da2.getNumberOfTuples());
7622         self.assertEqual(1,da2.getNumberOfComponents());
7623         for i in xrange(47):
7624             self.assertEqual(expected1[i],da2.getIJ(0,i));
7625             pass
7626         pass
7627
7628     def testSortCellsInMEDFileFrmt1(self):
7629         m,m1=MEDCouplingDataForTest.buildPointe_1();
7630         m2=m.deepCpy()
7631         da=DataArrayInt.New()
7632         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7633         daa=da.invertArrayN2O2O2N(16)
7634         m.renumberCells(daa,False)
7635         da2=m.sortCellsInMEDFileFrmt()
7636         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7637         self.assertTrue(m.isEqual(m2,1e-12))
7638         self.assertTrue(da.isEqual(da2))
7639         pass
7640
7641     def testBuildPartAndReduceNodes1(self):
7642         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7643         arr=[1,0]
7644         m2,da=m.buildPartAndReduceNodes(arr);
7645         self.assertEqual(5,m2.getNumberOfNodes());
7646         self.assertEqual(2,m2.getNumberOfCells());
7647         f=m2.getMeasureField(True);
7648         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7649         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7650         #
7651         arr2=DataArrayInt.New()
7652         arr2.setValues(arr,2,1)
7653         m2,da=m.buildPartAndReduceNodes(arr2);
7654         self.assertEqual(5,m2.getNumberOfNodes());
7655         self.assertEqual(2,m2.getNumberOfCells());
7656         f=m2.getMeasureField(True);
7657         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7658         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7659         pass
7660
7661     def testDAITransformWithIndArrR1(self):
7662         tab1=[2,4,5,3,6,7]
7663         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7664         expected=[0,3,1,2,4,5]
7665         d=DataArrayInt.New();
7666         d.setValues(tab1,6,1);
7667         d1=DataArrayInt.New();
7668         d1.setValues(tab2,12,1);
7669         d2=d1[:]
7670         #
7671         d3=d.transformWithIndArrR(d1);
7672         self.assertEqual(6,d3.getNumberOfTuples());
7673         self.assertEqual(1,d3.getNumberOfComponents());
7674         for i in xrange(6):
7675             self.assertEqual(expected[i],d3.getIJ(i,0));
7676             pass
7677         #
7678         d1=d2
7679         d3=d.transformWithIndArrR(tab2)
7680         self.assertEqual(6,d3.getNumberOfTuples());
7681         self.assertEqual(1,d3.getNumberOfComponents());
7682         for i in xrange(6):
7683             self.assertEqual(expected[i],d3.getIJ(i,0));
7684             pass
7685         pass
7686
7687     def testDAISplitByValueRange1(self):
7688         val1=[6,5,0,3,2,7,8,1,4]
7689         val2=[0,4,9]
7690         d=DataArrayInt.New();
7691         d.setValues(val1,9,1);
7692         e,f,g=d.splitByValueRange(val2);
7693         self.assertEqual(9,e.getNumberOfTuples());
7694         self.assertEqual(1,e.getNumberOfComponents());
7695         self.assertEqual(9,f.getNumberOfTuples());
7696         self.assertEqual(1,f.getNumberOfComponents());
7697         self.assertEqual(2,g.getNumberOfTuples());
7698         self.assertEqual(1,g.getNumberOfComponents());
7699         #
7700         expected1=[1,1,0,0,0,1,1,0,1]
7701         expected2=[2,1,0,3,2,3,4,1,0]
7702         for i in xrange(9):
7703             self.assertEqual(expected1[i],e.getIJ(i,0));
7704             self.assertEqual(expected2[i],f.getIJ(i,0));
7705             pass
7706         self.assertEqual(0,g.getIJ(0,0));
7707         self.assertEqual(1,g.getIJ(1,0));
7708         #
7709         d.setIJ(6,0,9);
7710         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7711         pass
7712
7713     def testUMeshSplitProfilePerType1(self):
7714         val0=[2,0,1,3,4]
7715         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7716         m.renumberCells(val0,False);
7717         #
7718         val1=[0,2,3]
7719         d=DataArrayInt.New();
7720         d.setValues(val1,3,1);
7721         d.setName("sup")
7722         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7723         self.assertEqual(6,len(code));
7724         self.assertEqual(2,len(idsInPflPerType));
7725         expected1=[3,1,0, 4,2,1]
7726         for i in xrange(6):
7727             self.assertEqual(expected1[i],code[i]);
7728             pass
7729         self.assertEqual(2,len(idsInPflPerType));
7730         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7731         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7732         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7733         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7734         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7735         #
7736         self.assertEqual(2,len(pfls));
7737         self.assertEqual("sup",pfls[0].getName())
7738         self.assertEqual(1,pfls[0].getNumberOfTuples());
7739         self.assertEqual(0,pfls[0].getIJ(0,0));
7740         self.assertEqual("sup",pfls[1].getName())
7741         self.assertEqual(2,pfls[1].getNumberOfTuples());
7742         self.assertEqual(0,pfls[1].getIJ(0,0));
7743         self.assertEqual(1,pfls[1].getIJ(1,0));
7744         #
7745         val2=[0,2,3,4]
7746         d=DataArrayInt.New();
7747         d.setValues(val2,4,1);
7748         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7749         self.assertEqual(6,len(code));
7750         self.assertEqual(2,len(idsInPflPerType));
7751         expected2=[3,1,0, 4,3,-1]
7752         for i in xrange(6):
7753             self.assertEqual(expected2[i],code[i]);
7754             pass
7755         self.assertEqual(2,len(idsInPflPerType));
7756         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7757         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7758         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7759         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7760         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7761         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7762         #
7763         self.assertEqual(1,len(pfls));
7764         self.assertEqual(1,pfls[0].getNumberOfTuples());
7765         self.assertEqual(0,pfls[0].getIJ(0,0));
7766         #
7767         val3=[1,0,2]
7768         d=DataArrayInt.New();
7769         d.setValues(val3,3,1);
7770         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7771         self.assertEqual(6,len(code));
7772         self.assertEqual(2,len(idsInPflPerType));
7773         expected3=[3,2,0, 4,1,1]
7774         for i in xrange(6):
7775             self.assertEqual(expected3[i],code[i]);
7776             pass
7777         self.assertEqual(2,len(idsInPflPerType));
7778         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7779         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7780         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7781         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7782         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7783         #
7784         self.assertEqual(2,len(pfls));
7785         self.assertEqual(2,pfls[0].getNumberOfTuples());
7786         self.assertEqual(1,pfls[0].getIJ(0,0));
7787         self.assertEqual(0,pfls[0].getIJ(1,0));
7788         self.assertEqual(0,pfls[1].getIJ(0,0));
7789         #
7790         val4=[3,4]
7791         d=DataArrayInt.New();
7792         d.setValues(val4,2,1);
7793         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7794         self.assertEqual(3,len(code));
7795         self.assertEqual(1,len(idsInPflPerType));
7796         expected4=[4,2,0]
7797         for i in xrange(3):
7798             self.assertEqual(expected4[i],code[i]);
7799             pass
7800         self.assertEqual(1,len(idsInPflPerType));
7801         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7802         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7803         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7804         #
7805         self.assertEqual(1,len(pfls));
7806         self.assertEqual(2,pfls[0].getNumberOfTuples());
7807         self.assertEqual(1,pfls[0].getIJ(0,0));
7808         self.assertEqual(2,pfls[0].getIJ(1,0));
7809         pass
7810
7811     def testDAIBuildExplicitArrByRanges1(self):
7812         d=DataArrayInt.New();
7813         vals1=[0,2,3]
7814         d.setValues(vals1,3,1);
7815         e=DataArrayInt.New();
7816         vals2=[0,3,6,10,14,20]
7817         e.setValues(vals2,6,1);
7818         #
7819         f=d.buildExplicitArrByRanges(e);
7820         self.assertEqual(11,f.getNumberOfTuples());
7821         self.assertEqual(1,f.getNumberOfComponents());
7822         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7823         for i in xrange(11):
7824             self.assertEqual(expected1[i],f.getIJ(i,0));
7825             pass
7826         pass
7827
7828     def testDAIComputeOffsets2(self):
7829         d=DataArrayInt.New();
7830         vals1=[3,5,1,2,0,8]
7831         expected1=[0,3,8,9,11,11,19]
7832         d.setValues(vals1,6,1);
7833         d.computeOffsets2();
7834         self.assertEqual(7,d.getNumberOfTuples());
7835         self.assertEqual(1,d.getNumberOfComponents());
7836         for i in xrange(7):
7837             self.assertEqual(expected1[i],d.getIJ(0,i));
7838             pass
7839         pass
7840
7841     def testMergeField3(self):
7842         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7843         m.getCoords().setInfoOnComponent(0,"x [m]");
7844         m.getCoords().setInfoOnComponent(1,"z [km]");
7845         m.setName("m");
7846         m.setDescription("desc");
7847         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7848         f1.setName("f1");
7849         f1.setMesh(m);
7850         arr=DataArrayDouble.New();
7851         arr.alloc(5,2);
7852         arr.setInfoOnComponent(0,"X [m]");
7853         arr.setInfoOnComponent(1,"YY [mm]");
7854         arr.fillWithValue(2.);
7855         f1.setArray(arr);
7856         #
7857         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7858         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7859         #
7860         pass
7861
7862     def testGetDistributionOfTypes1(self):
7863         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7864         tab1=[2,0,1,3,4]
7865         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7866         m.renumberCells(tab1,False);
7867         code=m.getDistributionOfTypes();
7868         self.assertEqual(2,len(code));
7869         self.assertEqual(3,code[0][0]);
7870         self.assertEqual(2,code[0][1]);
7871         self.assertEqual(0,code[0][2]);
7872         self.assertEqual(4,code[1][0]);
7873         self.assertEqual(3,code[1][1]);
7874         self.assertEqual(0,code[1][2]);
7875         pass
7876
7877     def testNorm2_1(self):
7878         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7879         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7880         f.setMesh(m);
7881         #
7882         d=DataArrayDouble.New();
7883         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7884         d.setValues(tab,5,2);
7885         f.setArray(d);
7886         f.checkCoherency();
7887         #
7888         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7889         #
7890         pass
7891
7892     def testNormMax1(self):
7893         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7894         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7895         f.setMesh(m);
7896         #
7897         d=DataArrayDouble.New();
7898         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
7899         d.setValues(tab,5,2);
7900         f.setArray(d);
7901         f.checkCoherency();
7902         #
7903         self.assertAlmostEqual(7.8,f.normMax(),14);
7904         #
7905         pass
7906
7907     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
7908         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];
7909         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]
7910         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]
7911         invalidCells=[2,3,6,7]
7912         m=MEDCouplingUMesh.New("Example",3);
7913         coo=DataArrayDouble.New();
7914         coo.setValues(coords,38,3);
7915         m.setCoords(coo);
7916         m.allocateCells(8);
7917         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
7918         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
7919         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
7920         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
7921         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
7922         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
7923         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
7924         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
7925         m.finishInsertingCells();
7926         #
7927         v=m.findAndCorrectBadOriented3DExtrudedCells();
7928         self.assertEqual(4,len(v));
7929         self.assertEqual(v.getValues(),invalidCells);
7930         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
7931         self.assertTrue(m.findAndCorrectBadOriented3DExtrudedCells().empty())
7932         #
7933         pass
7934
7935     def testConvertExtrudedPolyhedra1(self):
7936         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]
7937         m=MEDCouplingUMesh.New("Example",3);
7938         coo=DataArrayDouble.New();
7939         coo.alloc(73,3);
7940         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
7941         m.setCoords(coo);
7942         m.allocateCells(9);
7943         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
7944         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
7945         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
7946         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
7947         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
7948         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
7949         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
7950         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
7951         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
7952         m.finishInsertingCells();
7953         #
7954         m.convertExtrudedPolyhedra();
7955         da=m.getNodalConnectivity();
7956         dai=m.getNodalConnectivityIndex();
7957         self.assertEqual(10,dai.getNbOfElems());
7958         self.assertEqual(159,da.getNbOfElems());
7959         #
7960         expected1=[14,1,2,3,4,18,5,6,7,8,9,10,11,12,14,13,14,15,16,31,17,18,19,-1,20,22,21,-1,17,20,21,18,-1,18,21,22,19,-1,19,22,20,17,16,23,24,25,26,27,28,31,29,30,31,32,33,-1,34,38,37,36,35,-1,29,34,35,30,-1,30,35,36,31,-1,31,36,37,32,-1,32,37,38,33,-1,33,38,34,29,18,39,40,41,42,43,44,45,46,22,47,48,49,50,51,52,53,54,55,56,57,58,31,59,60,61,62,63,64,65,-1,66,72,71,70,69,68,67,-1,59,66,67,60,-1,60,67,68,61,-1,61,68,69,62,-1,62,69,70,63,-1,63,70,71,64,-1,64,71,72,65,-1,65,72,66,59];
7961         expected2=[0,5,14,19,42,49,86,95,108,159]
7962         self.assertEqual(expected1,da.getValues());
7963         self.assertEqual(expected2,dai.getValues());
7964         m.checkCoherency2()
7965         pass
7966
7967     def testNonRegressionCopyTinyStrings(self):
7968         m=MEDCouplingDataForTest.build2DTargetMesh_1()
7969         f1=m.getMeasureField(True)
7970         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
7971         bary=m.getBarycenterAndOwner()
7972         f2=f1.buildNewTimeReprFromThis(NO_TIME,False)
7973         f2.setArray(bary)
7974         self.assertRaises(InterpKernelException,f1.copyTinyAttrFrom,f2)
7975         pass
7976
7977     def testDaDSetPartOfValuesAdv1(self):
7978         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
7979         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
7980         tab3=[4,1, 2,2, 3,0]
7981         a=DataArrayDouble.New();
7982         a.setValues(tab1,6,3);
7983         b=DataArrayDouble.New();
7984         b.setValues(tab2,3,3);
7985         c=DataArrayInt.New();
7986         c.setValues(tab3,3,2);
7987         #
7988         a.setPartOfValuesAdv(b,c);
7989         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
7990         self.assertEqual(expected1,a.getValues());
7991         pass
7992
7993     def testUMeshBuildSetInstanceFromThis1(self):
7994         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7995         m2=m.buildSetInstanceFromThis(3);
7996         self.assertTrue(m.isEqual(m2,1e-12));
7997         #
7998         m=MEDCouplingUMesh.New("toto",2);
7999         m2=m.buildSetInstanceFromThis(3);
8000         self.assertEqual(0,m2.getNumberOfNodes());
8001         self.assertEqual(0,m2.getNumberOfCells());
8002         pass
8003
8004     def testUMeshMergeMeshesCVW1(self):
8005         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8006         m2=MEDCouplingUMesh.New("toto",2);
8007         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
8008         m3.setName(m.getName());
8009         self.assertTrue(m.isEqual(m3,1e-12));
8010         pass
8011
8012     def testChangeUnderlyingMeshWithCMesh1(self):
8013         mesh=MEDCouplingCMesh.New();
8014         coordsX=DataArrayDouble.New();
8015         arrX=[ -1., 1., 2., 4. ]
8016         coordsX.setValues(arrX,4,1);
8017         coordsY=DataArrayDouble.New();
8018         arrY=[ -2., 2., 4., 8. ]
8019         coordsY.setValues(arrY,4,1);
8020         coordsZ=DataArrayDouble.New();
8021         arrZ=[ -3., 3., 6., 12. ]
8022         coordsZ.setValues(arrZ,4,1);
8023         mesh.setCoords(coordsX,coordsY,coordsZ);
8024         f=mesh.getMeasureField(True)
8025         mesh2=mesh.deepCpy()
8026         for myId in [0,1,2,10,11,12,20,21,22]:
8027             f=mesh.getMeasureField(True)
8028             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8029             pass
8030         mesh2.setName("uuuu")
8031         for myId in [1,2,10,11,12,20,21,22]:
8032             f=mesh.getMeasureField(True)
8033             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8034             pass
8035         pass
8036
8037     def testDADFindCommonTuples1(self):
8038         da=DataArrayDouble.New();
8039         # nbOftuples=1
8040         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8041         da.setValues(array1,6,1)
8042         c,cI=da.findCommonTuples(1e-2);
8043         expected1=[0,3,4]
8044         expected2=[0,3]
8045         self.assertEqual(3,c.getNbOfElems());
8046         self.assertEqual(2,cI.getNbOfElems());
8047         self.assertEqual(expected1,c.getValues())
8048         self.assertEqual(expected2,cI.getValues())
8049         c,cI=da.findCommonTuples(2e-1)
8050         expected3=[0,3,4,1,2]
8051         expected4=[0,3,5]
8052         self.assertEqual(5,c.getNbOfElems());
8053         self.assertEqual(3,cI.getNbOfElems());
8054         self.assertEqual(expected3,c.getValues())
8055         self.assertEqual(expected4,cI.getValues())
8056         # nbOftuples=2
8057         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]
8058         da.setValues(array2,6,2)
8059         c,cI=da.findCommonTuples(1e-2);
8060         self.assertEqual(3,c.getNbOfElems());
8061         self.assertEqual(2,cI.getNbOfElems());
8062         self.assertEqual(expected1,c.getValues())
8063         self.assertEqual(expected2,cI.getValues())
8064         c,cI=da.findCommonTuples(2e-1)
8065         self.assertEqual(5,c.getNbOfElems());
8066         self.assertEqual(3,cI.getNbOfElems());
8067         self.assertEqual(expected3,c.getValues())
8068         self.assertEqual(expected4,cI.getValues())
8069         # nbOftuples=3
8070         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]
8071         da.setValues(array3,6,3)
8072         c,cI=da.findCommonTuples(1e-2);
8073         self.assertEqual(3,c.getNbOfElems());
8074         self.assertEqual(2,cI.getNbOfElems());
8075         self.assertEqual(expected1,c.getValues())
8076         self.assertEqual(expected2,cI.getValues())
8077         c,cI=da.findCommonTuples(2e-1)
8078         self.assertEqual(5,c.getNbOfElems());
8079         self.assertEqual(3,cI.getNbOfElems());
8080         self.assertEqual(expected3,c.getValues())
8081         self.assertEqual(expected4,cI.getValues())
8082         # nbOftuples=1, no common groups
8083         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8084         da.setValues(array11,6,1)
8085         c,cI=da.findCommonTuples(1e-2);
8086         self.assertEqual(0,c.getNbOfElems());
8087         self.assertEqual(1,cI.getNbOfElems());
8088         self.assertEqual([0],cI.getValues())
8089
8090         array12=[0.]*(6*4)
8091         da.setValues(array12,6,4) #bad NumberOfComponents
8092         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8093         pass
8094
8095     def testDABack1(self):
8096         da=DataArrayDouble.New();
8097         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8098         da.setValues(array1,6,1);
8099         self.assertAlmostEqual(0.8,da.back(),14);
8100         da.rearrange(2);
8101         self.assertRaises(InterpKernelException,da.back);
8102         da.alloc(0,1);
8103         self.assertRaises(InterpKernelException,da.back);
8104         #
8105         da=DataArrayInt.New();
8106         array2=[4,7,8,2]
8107         da.setValues(array2,4,1);
8108         self.assertEqual(2,da.back());
8109         da.rearrange(2);
8110         self.assertRaises(InterpKernelException,da.back);
8111         da.alloc(0,1);
8112         self.assertRaises(InterpKernelException,da.back);
8113         pass
8114
8115     def testDADGetDifferentValues1(self):
8116         da=DataArrayDouble.New();
8117         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8118         da.setValues(array1,6,1)
8119         #
8120         expected1=[2.301,1.2,1.3,0.8]
8121         dv=da.getDifferentValues(1e-2);
8122         self.assertEqual(4,dv.getNbOfElems());
8123         for i in xrange(4):
8124             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8125             pass
8126         #
8127         dv=da.getDifferentValues(2e-1);
8128         expected2=[2.301,1.3,0.8]
8129         self.assertEqual(3,dv.getNbOfElems());
8130         for i in xrange(3):
8131             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8132             pass
8133         pass
8134
8135     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8136         arr=[0,3, 5,7,9]
8137         arrI=[0,2,5]
8138         a=DataArrayInt.New();
8139         a.setValues(arr,5,1);
8140         b=DataArrayInt.New();
8141         b.setValues(arrI,3,1);
8142         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8143         expected=[0,1,2,0,3,4,5,4,6,4]
8144         self.assertEqual(10,ret.getNbOfElems());
8145         self.assertEqual(7,newNbTuple);
8146         self.assertEqual(1,ret.getNumberOfComponents());
8147         self.assertEqual(expected,ret.getValues());
8148         self.assertRaises(InterpKernelException,DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2,9,a,b);
8149         pass
8150
8151     def testDADIReverse1(self):
8152         arr=[0,3,5,7,9,2]
8153         a=DataArrayInt.New();
8154         a.setValues(arr,6,1);
8155         self.assertEqual(2,a.back());
8156         a.reverse();
8157         for i in xrange(6):
8158             self.assertEqual(arr[5-i],a.getIJ(i,0));
8159             pass
8160         a.setValues(arr[:-1],5,1);
8161         a.reverse();
8162         for i in xrange(5):
8163             self.assertEqual(arr[4-i],a.getIJ(i,0));
8164             pass
8165         #
8166         arr2=[0.,3.,5.,7.,9.,2.]
8167         b=DataArrayDouble.New();
8168         b.setValues(arr2,6,1);
8169         b.reverse();
8170         for i in xrange(6):
8171             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8172             pass
8173         b.setValues(arr2[:5],5,1);
8174         self.assertAlmostEqual(9.,b.back(),14)
8175         b.reverse();
8176         for i in xrange(5):
8177             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8178             pass
8179         pass
8180
8181     def testGetNodeIdsInUse1(self):
8182         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8183         CellIds=[1,2]
8184         m1=m0.buildPartOfMySelf(CellIds,True);
8185         arr,newNbOfNodes=m1.getNodeIdsInUse();
8186         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8187         self.assertEqual(4,newNbOfNodes);
8188         self.assertEqual(9,arr.getNbOfElems());
8189         self.assertEqual(expected,arr.getValues());
8190         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8191         self.assertEqual(4,arr2.getNbOfElems());
8192         expected2=[1,2,4,5]
8193         self.assertEqual(expected2,arr2.getValues());
8194         pass
8195
8196     def testBuildDescendingConnec2(self):
8197         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8198         #
8199         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8200         mesh2.checkCoherency();
8201         self.assertEqual(1,mesh2.getMeshDimension());
8202         self.assertEqual(13,mesh2.getNumberOfCells());
8203         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8204         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8205         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8206         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8207         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8208         self.assertEqual(expected1,desc.getValues());
8209         expected2=[0,4,7,10,14,18]
8210         self.assertEqual(expected2,descIndx.getValues());
8211         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8212         self.assertEqual(expected3,revDescIndx.getValues());
8213         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8214         self.assertEqual(expected4,revDesc.getValues());
8215         conn=mesh2.getNodalConnectivity();
8216         connIndex=mesh2.getNodalConnectivityIndex();
8217         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8218         self.assertEqual(expected5,connIndex.getValues());
8219         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]
8220         self.assertEqual(expected6,conn.getValues());
8221         pass
8222
8223     def testIntersect2DMeshesTmp1(self):
8224         m1c=MEDCouplingCMesh.New();
8225         coordsX=DataArrayDouble.New();
8226         arrX=[ -1., 1., 2., 4. ]
8227         coordsX.setValues(arrX,4,1);
8228         m1c.setCoordsAt(0,coordsX);
8229         coordsY=DataArrayDouble.New();
8230         arrY=[ -2., 2., 4., 8. ]
8231         coordsY.setValues(arrY,4,1);
8232         m1c.setCoordsAt(1,coordsY);
8233         m1=m1c.buildUnstructured()
8234         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8235         m2=m1.deepCpy()
8236         m2=m2.buildPartOfMySelf([0,1,2],False)
8237         m2.translate([0.5,0.5])
8238         #
8239         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8240         expected1=[0,0,1,1,1,2,2,2]
8241         expected2=[0,-1,0,1,-1,1,2,-1]
8242         self.assertEqual(8,d1.getNumberOfTuples());
8243         self.assertEqual(8,d2.getNumberOfTuples());
8244         self.assertEqual(8,m3.getNumberOfCells());
8245         self.assertEqual(22,m3.getNumberOfNodes());
8246         self.assertEqual(2,m3.getSpaceDimension());
8247         self.assertEqual(expected1,d1.getValues());
8248         self.assertEqual(expected2,d2.getValues());
8249         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]
8250         expected4=[0,5,12,17,22,28,33,38,44]
8251         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]
8252         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
8253         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
8254         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8255         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8256         for i in xrange(44):
8257             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8258             pass
8259         pass
8260
8261     def testFindNodesOnLine1(self):
8262         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8263         pt=[-0.3,-0.3]
8264         pt2=[0.,0.,0.]
8265         pt3=[-0.3,0.,0.]
8266         vec=[0.,1.]
8267         vec2=[1.,0.,0.]
8268         vec3=[0.,1.,1.]
8269         expected1=[0,3,6]
8270         res=mesh.findNodesOnLine(pt,vec,1e-12);
8271         self.assertEqual(3,len(res));
8272         self.assertEqual(expected1,res.getValues());
8273         #
8274         mesh.changeSpaceDimension(3);
8275         mesh.rotate(pt2,vec2,pi/4.);
8276         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8277         self.assertEqual(3,len(res));
8278         self.assertEqual(expected1,res.getValues());
8279         pass
8280
8281     def testIntersect2DMeshesTmp2(self):
8282         m1c=MEDCouplingCMesh.New();
8283         coordsX1=DataArrayDouble.New();
8284         arrX1=[ 0., 1., 1.5, 2. ]
8285         coordsX1.setValues(arrX1,4,1);
8286         m1c.setCoordsAt(0,coordsX1);
8287         coordsY1=DataArrayDouble.New();
8288         arrY1=[ 0., 1.5, 3.]
8289         coordsY1.setValues(arrY1,3,1);
8290         m1c.setCoordsAt(1,coordsY1);
8291         m1=m1c.buildUnstructured();
8292         m2c=MEDCouplingCMesh.New();
8293         coordsX2=DataArrayDouble.New();
8294         arrX2=[ 0., 1., 2. ]
8295         coordsX2.setValues(arrX2,3,1);
8296         m2c.setCoordsAt(0,coordsX2);
8297         coordsY2=DataArrayDouble.New();
8298         arrY2=[ 0., 1., 3.]
8299         coordsY2.setValues(arrY2,3,1);
8300         m2c.setCoordsAt(1,coordsY2);
8301         m2=m2c.buildUnstructured();
8302         #
8303         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8304         #
8305         expected1=[0,0,1,1,2,2,3,4,5]
8306         expected2=[0,2,1,3,1,3,2,3,3]
8307         self.assertEqual(9,d1.getNumberOfTuples());
8308         self.assertEqual(9,d2.getNumberOfTuples());
8309         self.assertEqual(9,m3.getNumberOfCells());
8310         self.assertEqual(22,m3.getNumberOfNodes());
8311         self.assertEqual(2,m3.getSpaceDimension());
8312         self.assertEqual(expected1,d1.getValues());
8313         self.assertEqual(expected2,d2.getValues());
8314         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]
8315         expected4=[0,5,10,15,20,25,30,35,40,45]
8316         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]
8317         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8318         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8319         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8320         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8321         for i in xrange(44):
8322             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8323             pass
8324         pass
8325
8326     def testBuildPartOfMySelfSafe1(self):
8327         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8328         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8329         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8330         pass
8331
8332     def testIntersect2DMeshesTmp3(self):
8333         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];
8334         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];
8335         m1=MEDCouplingUMesh.New();
8336         m1.setMeshDimension(2);
8337         m1.allocateCells(8);
8338         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8339         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8340         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8341         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8342         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8343         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8344         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8345         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8346         m1.finishInsertingCells();
8347         myCoords1=DataArrayDouble.New();
8348         myCoords1.setValues(m1Coords,25,2);
8349         m1.setCoords(myCoords1);
8350         #
8351         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.]
8352         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]
8353         m2=MEDCouplingUMesh.New();
8354         m2.setMeshDimension(2);
8355         m2.allocateCells(8);
8356         for i in xrange(8):
8357             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8358             pass
8359         m2.finishInsertingCells();
8360         myCoords2=DataArrayDouble.New();
8361         myCoords2.setValues(m2Coords,15,2);
8362         m2.setCoords(myCoords2);
8363         #
8364         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8365         m3.unPolyze()
8366         #
8367         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
8368         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
8369         self.assertEqual(16,d1.getNumberOfTuples());
8370         self.assertEqual(16,d2.getNumberOfTuples());
8371         self.assertEqual(16,m3.getNumberOfCells());
8372         self.assertEqual(104,m3.getNumberOfNodes());
8373         self.assertEqual(2,m3.getSpaceDimension());
8374         self.assertEqual(expected1,d1.getValues());
8375         self.assertEqual(expected2,d2.getValues());
8376         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]
8377         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8378         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]
8379         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8380         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8381         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8382         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8383         for i in xrange(208):
8384             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8385             pass
8386         pass
8387
8388     def testUMeshTessellate2D1(self):
8389         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];
8390         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];
8391         m1=MEDCouplingUMesh.New();
8392         m1.setMeshDimension(2);
8393         m1.allocateCells(8);
8394         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8395         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8396         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8397         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8398         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8399         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8400         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8401         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8402         m1.finishInsertingCells();
8403         myCoords1=DataArrayDouble.New();
8404         myCoords1.setValues(m1Coords,25,2);
8405         m1.setCoords(myCoords1);
8406         #
8407         m11=m1.deepCpy();
8408         m11.tessellate2D(1.);
8409         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8410         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]
8411         expected2=[0,5,12,17,24,29,36,41,48]
8412         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8413         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8414         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8415         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8416         #
8417         m12=m1.deepCpy();
8418         m12.tessellate2D(0.5);
8419         self.assertEqual(41,m12.getNumberOfNodes());
8420         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]
8421         expected4=[0,6,15,21,30,36,45,51,60]
8422         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]
8423         for i in xrange(82):
8424             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8425             pass
8426         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8427         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8428         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8429         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8430         pass
8431
8432     def testIntersect2DMeshesTmp4(self):
8433         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];
8434         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];
8435         m1=MEDCouplingUMesh.New();
8436         m1.setMeshDimension(2);
8437         m1.allocateCells(8);
8438         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8439         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8440         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8441         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8442         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8443         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8444         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8445         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8446         m1.finishInsertingCells();
8447         myCoords1=DataArrayDouble.New();
8448         myCoords1.setValues(m1Coords,25,2);
8449         m1.setCoords(myCoords1);
8450         #
8451         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.]
8452         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]
8453         m2=MEDCouplingUMesh.New();
8454         m2.setMeshDimension(2);
8455         m2.allocateCells(8);
8456         for i in xrange(8):
8457             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8458             pass
8459         m2.finishInsertingCells();
8460         myCoords2=DataArrayDouble.New();
8461         myCoords2.setValues(m2Coords,15,2);
8462         m2.setCoords(myCoords2);
8463         #
8464         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8465         m3.unPolyze()
8466         #
8467         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
8468         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
8469         self.assertEqual(16,d1.getNumberOfTuples());
8470         self.assertEqual(16,d2.getNumberOfTuples());
8471         self.assertEqual(16,m3.getNumberOfCells());
8472         self.assertEqual(104,m3.getNumberOfNodes());
8473         self.assertEqual(2,m3.getSpaceDimension());
8474         self.assertEqual(expected1,d1.getValues());
8475         self.assertEqual(expected2,d2.getValues());
8476         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]
8477         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8478         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]
8479         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8480         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8481         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8482         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8483         for i in xrange(208):
8484             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8485             pass
8486         pass
8487
8488     def testGetCellIdsCrossingPlane1(self):
8489         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8490         vec=[-0.07,1.,0.07]
8491         origin=[1.524,1.4552,1.74768]
8492         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8493         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8494         vec2=[0.,0.,1.]
8495         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8496         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8497         pass
8498
8499     def testBuildSlice3D1(self):
8500         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8501         vec1=[-0.07,1.,0.07]
8502         origin1=[1.524,1.4552,1.74768]
8503         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8504         expected1=[1,3,4,7,9,10,13,15,16]
8505         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]
8506         expected3=[0,6,11,17,22,27,32,37,42,47]
8507         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.]
8508         self.assertEqual(2,slice1.getMeshDimension());
8509         self.assertEqual(3,slice1.getSpaceDimension());
8510         self.assertEqual(57,slice1.getNumberOfNodes());
8511         self.assertEqual(9,slice1.getNumberOfCells());
8512         self.assertEqual(9,ids.getNumberOfTuples());
8513         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8514         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8515         self.assertEqual(expected1,ids.getValues());
8516         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8517         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8518         for i in xrange(171):
8519             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8520             pass
8521         # 2nd slice based on already existing nodes of mesh3D.
8522         vec2=[0.,3.,1.]
8523         origin2=[2.5,1.,3.]
8524         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8525         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]
8526         expected6=[0,5,10,15,21,26,32,38,43,49]
8527         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]
8528         self.assertEqual(2,slice1.getMeshDimension());
8529         self.assertEqual(3,slice1.getSpaceDimension());
8530         self.assertEqual(60,slice1.getNumberOfNodes());
8531         self.assertEqual(9,slice1.getNumberOfCells());
8532         self.assertEqual(9,ids.getNumberOfTuples());
8533         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8534         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8535         self.assertEqual(expected1,ids.getValues());
8536         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8537         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8538         for i in xrange(180):
8539             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8540             pass
8541         # 3rd slice based on shared face of mesh3D.
8542         vec3=[0.,0.,1.]
8543         origin3=[2.5,1.,2.]
8544         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8545         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8546         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]
8547         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8548         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.]
8549         self.assertEqual(2,slice1.getMeshDimension());
8550         self.assertEqual(3,slice1.getSpaceDimension());
8551         self.assertEqual(45,slice1.getNumberOfNodes());
8552         self.assertEqual(12,slice1.getNumberOfCells());
8553         self.assertEqual(12,ids.getNumberOfTuples());
8554         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8555         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8556         self.assertEqual(expected8,ids.getValues());
8557         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8558         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8559         for i in xrange(135):
8560             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8561             pass
8562         pass
8563
8564     def testBuildSlice3DSurf1(self):
8565         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8566         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8567         vec1=[-0.07,1.,0.07]
8568         origin1=[1.524,1.4552,1.74768]
8569         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8570         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]
8571         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]
8572         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];
8573         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.]
8574         self.assertEqual(1,slice1.getMeshDimension());
8575         self.assertEqual(3,slice1.getSpaceDimension());
8576         self.assertEqual(57,slice1.getNumberOfNodes());
8577         self.assertEqual(25,slice1.getNumberOfCells());
8578         self.assertEqual(25,ids.getNumberOfTuples());
8579         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8580         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8581         self.assertEqual(expected1,ids.getValues());
8582         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8583         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8584         for i in xrange(171):
8585             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8586             pass
8587         #
8588         vec2=[0.,0.,1.]
8589         origin2=[2.5,1.,2.]
8590         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8591         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]
8592         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]
8593         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];
8594         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.]
8595         self.assertEqual(1,slice1.getMeshDimension());
8596         self.assertEqual(3,slice1.getSpaceDimension());
8597         self.assertEqual(45,slice1.getNumberOfNodes());
8598         self.assertEqual(68,slice1.getNumberOfCells());
8599         self.assertEqual(68,ids.getNumberOfTuples());
8600         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8601         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8602         self.assertEqual(expected5,ids.getValues());
8603         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8604         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8605         for i in xrange(135):
8606             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8607             pass
8608         pass
8609
8610     def testDataArrayDoubleAdvSetting1(self):
8611         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8612         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8613         compsCpp=["comp1","comp2"]
8614         da=DataArrayDouble.New();
8615         da.setInfoAndChangeNbOfCompo(compsCpp);
8616         da.setName("da");
8617         da.alloc(7,2);
8618         compsCpp=compsCpp[:-1]
8619         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8620         da.setValues(data1,7,2)
8621         #
8622         p=[(0,3),(3,5),(5,7)]
8623         tmp=da.selectByTupleRanges(p);
8624         self.assertTrue(tmp.isEqual(da,1e-14));
8625         p=[(0,2),(3,4),(5,7)]
8626         tmp=da.selectByTupleRanges(p);
8627         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8628         self.assertEqual(5,tmp.getNumberOfTuples());
8629         self.assertEqual(2,tmp.getNumberOfComponents());
8630         for i in xrange(10):
8631             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8632             pass
8633         p=[(0,2),(0,2),(5,6)]
8634         tmp=da.selectByTupleRanges(p);
8635         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8636         self.assertEqual(5,tmp.getNumberOfTuples());
8637         self.assertEqual(2,tmp.getNumberOfComponents());
8638         for i in xrange(10):
8639             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8640             pass
8641         p=[(0,2),(-1,2),(5,6)]
8642         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8643         p=[(0,2),(0,2),(5,8)]
8644         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8645         #
8646         da2=DataArrayDouble.New();
8647         da2.setValues(data2,5,2);
8648         #
8649         dac=da.deepCpy();
8650         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8651         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8652         for i in xrange(14):
8653             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8654             pass
8655         #
8656         dac=da.deepCpy();
8657         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8658         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8659         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8660         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8661         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8662         for i in xrange(14):
8663             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8664             pass
8665         #
8666         ids=DataArrayInt.New();
8667         ids.alloc(3,1);
8668         dac=da.deepCpy();
8669         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8670         dac.setContigPartOfSelectedValues(2,da2,ids);
8671         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8672         for i in xrange(14):
8673             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8674             pass
8675         #
8676         dac=da.deepCpy();
8677         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8678         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8679         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8680         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8681         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8682         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8683         #
8684         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8685         dac=da.deepCpy();
8686         dac.setContigPartOfSelectedValues(4,da2,ids);
8687         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8688         for i in xrange(14):
8689             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8690             pass
8691         pass
8692
8693     def testDataArrayIntAdvSetting1(self):
8694         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8695         data2=[8,38,9,39,0,30,11,41,12,42]
8696         compsCpp=["comp1","comp2"]
8697         da=DataArrayInt.New();
8698         da.setInfoAndChangeNbOfCompo(compsCpp);
8699         da.setName("da");
8700         da.alloc(7,2);
8701         compsCpp=compsCpp[:-1]
8702         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8703         da.setValues(data1,7,2)
8704         #
8705         p=[(0,3),(3,5),(5,7)]
8706         tmp=da.selectByTupleRanges(p);
8707         self.assertTrue(tmp.isEqual(da));
8708         p=[(0,2),(3,4),(5,7)]
8709         tmp=da.selectByTupleRanges(p);
8710         expected1=[1,11,2,12,4,14,6,16,7,17]
8711         self.assertEqual(5,tmp.getNumberOfTuples());
8712         self.assertEqual(2,tmp.getNumberOfComponents());
8713         for i in xrange(10):
8714             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8715             pass
8716         p=[(0,2),(0,2),(5,6)]
8717         tmp=da.selectByTupleRanges(p);
8718         expected2=[1,11,2,12,1,11,2,12,6,16]
8719         self.assertEqual(5,tmp.getNumberOfTuples());
8720         self.assertEqual(2,tmp.getNumberOfComponents());
8721         for i in xrange(10):
8722             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8723             pass
8724         p=[(0,2),(-1,2),(5,6)]
8725         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8726         p=[(0,2),(0,2),(5,8)]
8727         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8728         #
8729         da2=DataArrayInt.New();
8730         da2.setValues(data2,5,2);
8731         #
8732         dac=da.deepCpy();
8733         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8734         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8735         for i in xrange(14):
8736             self.assertEqual(expected3[i],dac.getIJ(0,i));
8737             pass
8738         #
8739         dac=da.deepCpy();
8740         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8741         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8742         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8743         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8744         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8745         for i in xrange(14):
8746             self.assertEqual(expected4[i],dac.getIJ(0,i));
8747             pass
8748         #
8749         ids=DataArrayInt.New();
8750         ids.alloc(3,1);
8751         dac=da.deepCpy();
8752         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8753         dac.setContigPartOfSelectedValues(2,da2,ids);
8754         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8755         for i in xrange(14):
8756             self.assertEqual(expected5[i],dac.getIJ(0,i));
8757             pass
8758         #
8759         dac=da.deepCpy();
8760         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8761         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8762         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8763         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8764         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8765         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8766         #
8767         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8768         dac=da.deepCpy();
8769         dac.setContigPartOfSelectedValues(4,da2,ids);
8770         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8771         for i in xrange(14):
8772             self.assertEqual(expected6[i],dac.getIJ(0,i));
8773             pass
8774         pass
8775
8776     def testBuildDescendingConnec2Of3DMesh1(self):
8777         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8778         #
8779         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8780         mesh2.checkCoherency();
8781         self.assertEqual(2,mesh2.getMeshDimension());
8782         self.assertEqual(30,mesh2.getNumberOfCells());
8783         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8784         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8785         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8786         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8787         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]
8788         self.assertEqual(expected1,desc.getValues());
8789         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8790         self.assertEqual(expected2,descIndx.getValues());
8791         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]
8792         self.assertEqual(expected3,revDescIndx.getValues());
8793         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]
8794         self.assertEqual(expected4,revDesc.getValues());
8795         conn=mesh2.getNodalConnectivity();
8796         connIndex=mesh2.getNodalConnectivityIndex();
8797         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]
8798         self.assertEqual(expected5,connIndex.getValues());
8799         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]
8800         self.assertEqual(expected6,conn.getValues());
8801         pass
8802
8803     def testAre2DCellsNotCorrectlyOriented1(self):
8804         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8805         m1Conn=[0,3,1,2]
8806         m1=MEDCouplingUMesh.New();
8807         m1.setMeshDimension(2);
8808         m1.allocateCells(1);
8809         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8810         m1.finishInsertingCells();
8811         myCoords1=DataArrayDouble.New();
8812         myCoords1.setValues(m1Coords,4,2);
8813         m1.setCoords(myCoords1);
8814         #
8815         vec1=[0.,0.,1.]
8816         for i in xrange(18):
8817             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8818             m1Cpy=m1.deepCpy();
8819             m1Cpy.translate(vec2);
8820             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8821             m1Cpy.changeSpaceDimension(3);
8822             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8823             self.assertEqual([0],res.getValues());
8824             pass
8825         pass
8826
8827     def testDataArrayAbs1(self):
8828         d1=DataArrayDouble.New();
8829         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8830         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8831         d1.setValues(val1,6,2);
8832         d2=d1.convertToIntArr();
8833         #
8834         d1.abs();
8835         for i in xrange(12):
8836             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8837             pass
8838         #
8839         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8840         d2.abs();
8841         for i in xrange(12):
8842             self.assertEqual(expected2[i],d2.getIJ(0,i));
8843             pass
8844         #
8845         pass
8846
8847     # test on 1D
8848     def testGetValueOn3(self):
8849         v=[0.,1.,1.5,2.]
8850         v2=[0.7,1.25,0.,2.,1.5]
8851         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8852         m=MEDCouplingUMesh.New("myMesh",1)
8853         nbNodes=len(v)
8854         nbCells=nbNodes-1
8855         m.allocateCells(nbCells)
8856         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8857         m.setCoords(coords)
8858         m.insertNextCell(NORM_SEG2,2,[0,1])
8859         m.insertNextCell(NORM_SEG2,2,[2,1])
8860         m.insertNextCell(NORM_SEG2,2,[2,3])
8861         m.finishInsertingCells()
8862         f=MEDCouplingFieldDouble.New(ON_NODES)
8863         f.setMesh(m)
8864         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8865         f.setArray(array)
8866         arr1=f.getValueOnMulti(v2)
8867         self.assertEqual(5,arr1.getNumberOfTuples());
8868         self.assertEqual(3,arr1.getNumberOfComponents());
8869         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8870         for i in xrange(15):
8871             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8872             pass
8873         pass
8874
8875     def testGetNodeIdsOfCell2(self):
8876         m1c=MEDCouplingCMesh.New();
8877         coordsX=DataArrayDouble.New();
8878         arrX=[ -1., 1., 2., 4., 4.5 ]
8879         coordsX.setValues(arrX,5,1);
8880         coordsY=DataArrayDouble.New();
8881         arrY=[ -2., 2., 4., 8.]
8882         coordsY.setValues(arrY,4,1);
8883         coordsZ=DataArrayDouble.New();
8884         arrZ=[ -2., 2., 4.]
8885         coordsZ.setValues(arrZ,3,1);
8886         # test in 1D
8887         m1c.setCoordsAt(0,coordsX);
8888         expected1=[[0,1],[1,2],[2,3],[3,4]]
8889         self.assertEqual(4,m1c.getNumberOfCells())
8890         for i in xrange(m1c.getNumberOfCells()):
8891             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
8892             pass
8893         # test in 2D
8894         m1c.setCoordsAt(1,coordsY);
8895         self.assertEqual(12,m1c.getNumberOfCells())
8896         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]]
8897         for i in xrange(m1c.getNumberOfCells()):
8898             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
8899             pass
8900         # test in 3D
8901         m1c.setCoordsAt(2,coordsZ);
8902         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]]
8903         self.assertEqual(24,m1c.getNumberOfCells())
8904         for i in xrange(m1c.getNumberOfCells()):
8905             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
8906             pass
8907         pass
8908
8909     def testSwigDADOp4(self):
8910         da=DataArrayDouble.New(range(6,30),12,2)
8911         self.assertEqual(12,da.getNumberOfTuples());
8912         self.assertEqual(2,da.getNumberOfComponents());
8913         for i in xrange(24):
8914             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8915             pass
8916         # operator transpose
8917         da.transpose()
8918         self.assertEqual(2,da.getNumberOfTuples());
8919         self.assertEqual(12,da.getNumberOfComponents());
8920         for i in xrange(24):
8921             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8922             pass
8923         da.transpose()
8924         # operator __neg__
8925         da2=DataArrayDouble.New(12,1)
8926         da2.iota(0.)
8927         dabis=-da
8928         for i in xrange(24):
8929             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
8930             pass
8931         # operator+=
8932         da+=da2
8933         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.]
8934         for i in xrange(24):
8935             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8936             pass
8937         da=-dabis
8938         da+=[100.,101.]
8939         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.]
8940         self.assertEqual(12,da.getNumberOfTuples());
8941         self.assertEqual(2,da.getNumberOfComponents());
8942         for i in xrange(24):
8943             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8944             pass
8945         for pos,elt in enumerate(dabis):
8946             da[pos]+=elt
8947             pass
8948         self.assertEqual(12,da.getNumberOfTuples());
8949         self.assertEqual(2,da.getNumberOfComponents());
8950         for elt in da:
8951             li=elt[:]
8952             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
8953             pass
8954         # operator-=
8955         da=DataArrayDouble.New(range(6,30),12,2)
8956         da2=DataArrayDouble.New(range(12),12,1)
8957         dabis=-da
8958         da-=da2
8959         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.]
8960         for i in xrange(24):
8961             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8962             pass
8963         da=-dabis
8964         da-=[100.,101.]
8965         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.]
8966         self.assertEqual(12,da.getNumberOfTuples());
8967         self.assertEqual(2,da.getNumberOfComponents());
8968         for i in xrange(24):
8969             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8970             pass
8971         for pos,elt in enumerate(dabis):
8972             da[pos]-=elt
8973             pass
8974         self.assertEqual(12,da.getNumberOfTuples());
8975         self.assertEqual(2,da.getNumberOfComponents());
8976         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.]
8977         for i in xrange(24):
8978             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8979             pass
8980         # operator*=
8981         da=DataArrayDouble.New(range(6,30),12,2)
8982         da2=DataArrayDouble.New(range(12),12,1)
8983         dabis=-da
8984         da*=da2
8985         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.]
8986         for i in xrange(24):
8987             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8988             pass
8989         da=-dabis
8990         da*=[100.,101.]
8991         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.]
8992         self.assertEqual(12,da.getNumberOfTuples());
8993         self.assertEqual(2,da.getNumberOfComponents());
8994         for i in xrange(24):
8995             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8996             pass
8997         for pos,elt in enumerate(dabis):
8998             da[pos]*=elt
8999             pass
9000         self.assertEqual(12,da.getNumberOfTuples());
9001         self.assertEqual(2,da.getNumberOfComponents());
9002         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]
9003         for i in xrange(24):
9004             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9005             pass
9006         # operator/=
9007         da=DataArrayDouble.New(range(6,30),12,2)
9008         da2=DataArrayDouble.New(range(1,13),12,1)
9009         dabis=-da
9010         da/=da2
9011         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]
9012         for i in xrange(24):
9013             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9014             pass
9015         da=-dabis
9016         da/=[100.,101.]
9017         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]
9018         self.assertEqual(12,da.getNumberOfTuples());
9019         self.assertEqual(2,da.getNumberOfComponents());
9020         for i in xrange(24):
9021             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9022             pass
9023         for pos,elt in enumerate(dabis):
9024             da[pos]/=elt
9025             pass
9026         self.assertEqual(12,da.getNumberOfTuples());
9027         self.assertEqual(2,da.getNumberOfComponents());
9028         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]
9029         for i in xrange(24):
9030             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9031             pass
9032         pass
9033
9034     def testSwigDAIOp4(self):
9035         da=DataArrayInt.New(range(6,30),12,2)
9036         self.assertEqual(12,da.getNumberOfTuples());
9037         self.assertEqual(2,da.getNumberOfComponents());
9038         for i in xrange(24):
9039             self.assertEqual(da.getIJ(0,i),i+6)
9040             pass
9041         # operator transpose
9042         da.transpose()
9043         self.assertEqual(2,da.getNumberOfTuples());
9044         self.assertEqual(12,da.getNumberOfComponents());
9045         for i in xrange(24):
9046             self.assertEqual(da.getIJ(0,i),i+6)
9047             pass
9048         da.transpose()
9049         # operator __neg__
9050         da2=DataArrayInt.New(12,1)
9051         da2.iota(0)
9052         dabis=-da
9053         for i in xrange(24):
9054             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9055             pass
9056         # operator+=
9057         da+=da2
9058         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]
9059         for i in xrange(24):
9060             self.assertEqual(da.getIJ(0,i),expected1[i])
9061             pass
9062         da=-dabis
9063         da+=[100,101]
9064         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]
9065         self.assertEqual(12,da.getNumberOfTuples());
9066         self.assertEqual(2,da.getNumberOfComponents());
9067         for i in xrange(24):
9068             self.assertEqual(da.getIJ(0,i),expected2[i])
9069             pass
9070         for pos,elt in enumerate(dabis):
9071             da[pos]+=elt
9072             pass
9073         self.assertEqual(12,da.getNumberOfTuples());
9074         self.assertEqual(2,da.getNumberOfComponents());
9075         for elt in da:
9076             li=elt[:]
9077             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9078             pass
9079         # operator-=
9080         da=DataArrayInt.New(range(6,30),12,2)
9081         da2=DataArrayInt.New(range(12),12,1)
9082         dabis=-da
9083         da-=da2
9084         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]
9085         for i in xrange(24):
9086             self.assertEqual(da.getIJ(0,i),expected1[i])
9087             pass
9088         da=-dabis
9089         da-=[100,101]
9090         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]
9091         self.assertEqual(12,da.getNumberOfTuples());
9092         self.assertEqual(2,da.getNumberOfComponents());
9093         for i in xrange(24):
9094             self.assertEqual(da.getIJ(0,i),expected2[i])
9095             pass
9096         for pos,elt in enumerate(dabis):
9097             da[pos]-=elt
9098             pass
9099         self.assertEqual(12,da.getNumberOfTuples());
9100         self.assertEqual(2,da.getNumberOfComponents());
9101         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]
9102         for i in xrange(24):
9103             self.assertEqual(da.getIJ(0,i),expected3[i])
9104             pass
9105         # operator*=
9106         da=DataArrayInt.New(range(6,30),12,2)
9107         da2=DataArrayInt.New(range(12),12,1)
9108         dabis=-da
9109         da*=da2
9110         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]
9111         for i in xrange(24):
9112             self.assertEqual(da.getIJ(0,i),expected1[i])
9113             pass
9114         da=-dabis
9115         da*=[100,101]
9116         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]
9117         self.assertEqual(12,da.getNumberOfTuples());
9118         self.assertEqual(2,da.getNumberOfComponents());
9119         for i in xrange(24):
9120             self.assertEqual(da.getIJ(0,i),expected2[i])
9121             pass
9122         for pos,elt in enumerate(dabis):
9123             da[pos]*=elt
9124             pass
9125         self.assertEqual(12,da.getNumberOfTuples());
9126         self.assertEqual(2,da.getNumberOfComponents());
9127         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]
9128         for i in xrange(24):
9129             self.assertEqual(da.getIJ(0,i),expected3[i])
9130             pass
9131         # operator/=
9132         da=DataArrayInt.New(range(6,30),12,2)
9133         da2=DataArrayInt.New(range(1,13),12,1)
9134         dabis=-da
9135         da/=da2
9136         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]
9137         for i in xrange(24):
9138             self.assertEqual(da.getIJ(0,i),expected1[i])
9139             pass
9140         da=-dabis
9141         da/=DataArrayInt.New([2,3],1,2)
9142         self.assertEqual(12,da.getNumberOfTuples());
9143         self.assertEqual(2,da.getNumberOfComponents());
9144         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]
9145         for i in xrange(24):
9146             self.assertEqual(da.getIJ(0,i),expected2[i])
9147             pass
9148         pass
9149
9150     def testSwigDADOp5(self):
9151         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9152         da.rearrange(3)
9153         da2=DataArrayDouble.New([5.,8.,10.,12])
9154         self.assertEqual(4,da2.getNumberOfTuples());
9155         self.assertEqual(1,da2.getNumberOfComponents());
9156         da3=da+da2
9157         self.assertEqual(4,da3.getNumberOfTuples());
9158         self.assertEqual(3,da3.getNumberOfComponents());
9159         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9160         for i in xrange(12):
9161             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9162             pass
9163         da3=da2+da
9164         self.assertEqual(4,da3.getNumberOfTuples());
9165         self.assertEqual(3,da3.getNumberOfComponents());
9166         for i in xrange(12):
9167             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9168             pass
9169         # Test new API of classmethod DataArrayDouble.New
9170         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9171         da=DataArrayDouble.New(vals)
9172         self.assertEqual(12,da.getNumberOfTuples());
9173         self.assertEqual(1,da.getNumberOfComponents());
9174         for i in xrange(12):
9175             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9176             pass
9177         da=DataArrayDouble.New(vals,12)
9178         self.assertEqual(12,da.getNumberOfTuples());
9179         self.assertEqual(1,da.getNumberOfComponents());
9180         for i in xrange(12):
9181             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9182             pass
9183         da=DataArrayDouble.New(vals,1,12)
9184         self.assertEqual(1,da.getNumberOfTuples());
9185         self.assertEqual(12,da.getNumberOfComponents());
9186         for i in xrange(12):
9187             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9188             pass
9189         da=DataArrayDouble.New(vals,6,2)
9190         self.assertEqual(6,da.getNumberOfTuples());
9191         self.assertEqual(2,da.getNumberOfComponents());
9192         for i in xrange(12):
9193             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9194             pass
9195         da=DataArrayDouble.New(vals,4,3)
9196         self.assertEqual(4,da.getNumberOfTuples());
9197         self.assertEqual(3,da.getNumberOfComponents());
9198         for i in xrange(12):
9199             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9200             pass
9201         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9202         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9203         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9204         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9205         pass
9206
9207     def testSwigDADOp6(self):
9208         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9209         da.rearrange(3)
9210         da2=DataArrayInt.New([5,8,10,12])
9211         self.assertEqual(4,da2.getNumberOfTuples());
9212         self.assertEqual(1,da2.getNumberOfComponents());
9213         da3=da+da2
9214         self.assertEqual(4,da3.getNumberOfTuples());
9215         self.assertEqual(3,da3.getNumberOfComponents());
9216         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9217         for i in xrange(12):
9218             self.assertEqual(da3.getIJ(0,i),expected1[i])
9219             pass
9220         da3=da2+da
9221         self.assertEqual(4,da3.getNumberOfTuples());
9222         self.assertEqual(3,da3.getNumberOfComponents());
9223         for i in xrange(12):
9224             self.assertEqual(da3.getIJ(0,i),expected1[i])
9225             pass
9226         da3=da+DataArrayInt.New(da2.getValues())
9227         # Test new API of classmethod DataArrayInt.New
9228         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9229         da=DataArrayDouble.New(vals)
9230         self.assertEqual(12,da.getNumberOfTuples());
9231         self.assertEqual(1,da.getNumberOfComponents());
9232         for i in xrange(12):
9233             self.assertEqual(da.getIJ(0,i),vals[i])
9234             pass
9235         da=DataArrayDouble.New(vals,12)
9236         self.assertEqual(12,da.getNumberOfTuples());
9237         self.assertEqual(1,da.getNumberOfComponents());
9238         for i in xrange(12):
9239             self.assertEqual(da.getIJ(0,i),vals[i])
9240             pass
9241         da=DataArrayDouble.New(vals,1,12)
9242         self.assertEqual(1,da.getNumberOfTuples());
9243         self.assertEqual(12,da.getNumberOfComponents());
9244         for i in xrange(12):
9245             self.assertEqual(da.getIJ(0,i),vals[i])
9246             pass
9247         da=DataArrayDouble.New(vals,6,2)
9248         self.assertEqual(6,da.getNumberOfTuples());
9249         self.assertEqual(2,da.getNumberOfComponents());
9250         for i in xrange(12):
9251             self.assertEqual(da.getIJ(0,i),vals[i])
9252             pass
9253         da=DataArrayDouble.New(vals,4,3)
9254         self.assertEqual(4,da.getNumberOfTuples());
9255         self.assertEqual(3,da.getNumberOfComponents());
9256         for i in xrange(12):
9257             self.assertEqual(da.getIJ(0,i),vals[i])
9258             pass
9259         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9260         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9261         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9262         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9263         pass
9264
9265     def testSwigDADOp9(self):
9266         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
9267         da1=DataArrayDouble(l1,4,3)
9268         self.assertEqual(4,da1.getNumberOfTuples());
9269         self.assertEqual(3,da1.getNumberOfComponents());
9270         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9271         self.assertTrue(da2.isEqual(da1,1e-12))
9272         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9273         da3=DataArrayDouble(l1,4)
9274         self.assertTrue(da3.isEqual(da1,1e-12))
9275         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9276         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9277         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
9278         da1=DataArrayDouble(l1,4,3)
9279         self.assertEqual(4,da1.getNumberOfTuples());
9280         self.assertEqual(3,da1.getNumberOfComponents());
9281         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9282         self.assertTrue(da2.isEqual(da1,1e-12))
9283         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9284         da3=DataArrayDouble(l1,4)
9285         self.assertTrue(da3.isEqual(da1,1e-12))
9286         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9287         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9288         #
9289         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
9290         da1=DataArrayInt(l1,4,3)
9291         self.assertEqual(4,da1.getNumberOfTuples());
9292         self.assertEqual(3,da1.getNumberOfComponents());
9293         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9294         self.assertTrue(da2.isEqual(da1))
9295         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9296         da3=DataArrayInt(l1,4)
9297         self.assertTrue(da3.isEqual(da1))
9298         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9299         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9300         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
9301         da1=DataArrayInt(l1,4,3)
9302         self.assertEqual(4,da1.getNumberOfTuples());
9303         self.assertEqual(3,da1.getNumberOfComponents());
9304         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9305         self.assertTrue(da2.isEqual(da1))
9306         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9307         da3=DataArrayInt(l1,4)
9308         self.assertTrue(da3.isEqual(da1))
9309         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9310         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9311         pass
9312
9313     def testRenumberNodesInConn1(self):
9314         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. ]
9315         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9316         mesh2D=MEDCouplingUMesh.New("mesh",2);
9317         mesh2D.allocateCells(5);
9318         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9319         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9320         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9321         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9322         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9323         mesh2D.finishInsertingCells();
9324         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9325         mesh2D.setCoords(myCoords);
9326         mesh2D.checkCoherency();
9327         #
9328         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. ]
9329         mesh3DConn=[0,1,2,3,4,5,6,7]
9330         mesh3D=MEDCouplingUMesh.New("mesh",3);
9331         mesh3D.allocateCells(1);
9332         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9333         mesh3D.finishInsertingCells();
9334         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9335         mesh3D.setCoords(myCoords3D);
9336         mesh3D.checkCoherency();
9337         #
9338         mesh3D_2=mesh3D.deepCpy();
9339         mesh2D_2=mesh2D.deepCpy();
9340         mesh3D_4=mesh3D.deepCpy();
9341         mesh2D_4=mesh2D.deepCpy();
9342         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9343         renumNodes=DataArrayInt.New();
9344         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9345         renumNodes.iota(oldNbOf3DNodes);
9346         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9347         mesh3D.setCoords(coo);
9348         mesh2D.setCoords(coo);
9349         mesh2DCpy=mesh2D.deepCpy()
9350         mesh2D_3=mesh2D.deepCpy();
9351         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9352         mesh2D.renumberNodesInConn(renumNodes);
9353         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9354         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9355         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9356         #
9357         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9358         self.assertTrue(da1==None);
9359         self.assertEqual(8,da2.getNumberOfTuples());
9360         self.assertEqual(1,da2.getNumberOfComponents());
9361         expected1=[8,11,12,9,4,5,6,7]
9362         for i in xrange(8):
9363             self.assertEqual(expected1[i],da2.getIJ(i,0));
9364             pass
9365         #
9366         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9367         self.assertTrue(da1==None);
9368         self.assertEqual(9,da2.getNumberOfTuples());
9369         self.assertEqual(1,da2.getNumberOfComponents());
9370         for i in xrange(9):
9371             self.assertEqual(8+i,da2.getIJ(i,0));
9372             pass
9373         #
9374         mesh2D_5=mesh2D_4.deepCpy();
9375         mesh2D_5.translate([1.,0.,0.]);
9376         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9377         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9378         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9379         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9380         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9381         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9382         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9383         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9384         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9385         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9386         expected2=[18,0,1,2,3,4,5,6,7]
9387         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9388         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9389         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]
9390         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9391         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9392         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9393         for i in xrange(78):
9394             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9395             pass
9396         #
9397         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9398         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9399         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9400         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9401         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9402         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9403         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9404         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9405         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9406         expected6=[18,0,1,2,3,4,5,6,7]
9407         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9408         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9409         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.,
9410                     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.,
9411                     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.]
9412         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9413         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9414         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9415         for i in xrange(57):
9416             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9417             pass
9418         #
9419         pass
9420
9421     def testComputeNeighborsOfCells1(self):
9422         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9423         d1,d2=m.computeNeighborsOfCells();
9424         self.assertEqual(6,d2.getNumberOfTuples());
9425         self.assertEqual(10,d1.getNumberOfTuples());
9426         expected1=[0,2,4,6,8,10]
9427         expected2=[3,1,0,2,4,1,4,0,2,3]
9428         self.assertEqual(expected1,d2.getValues());
9429         self.assertEqual(expected2,d1.getValues());
9430         pass
9431
9432     def testCheckButterflyCellsBug1(self):
9433         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9434         mesh2DConn=[4,1,0,2,3]
9435         mesh2D=MEDCouplingUMesh.New("mesh",2);
9436         mesh2D.allocateCells(1);
9437         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9438         mesh2D.finishInsertingCells();
9439         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9440         mesh2D.setCoords(myCoords);
9441         mesh2D.checkCoherency();
9442         #
9443         v=mesh2D.checkButterflyCells();
9444         self.assertTrue(v.empty());
9445         pass
9446
9447     def testDataArrayIntRange1(self):
9448         d=DataArrayInt.Range(2,17,7);
9449         expected1=[2,9,16]
9450         self.assertEqual(3,d.getNumberOfTuples());
9451         self.assertEqual(1,d.getNumberOfComponents());
9452         self.assertEqual(expected1,d.getValues());
9453         #
9454         d=DataArrayInt.Range(2,23,7);
9455         self.assertEqual(3,d.getNumberOfTuples());
9456         self.assertEqual(1,d.getNumberOfComponents());
9457         self.assertEqual(expected1,d.getValues());
9458         #
9459         d=DataArrayInt.Range(2,24,7);
9460         expected2=[2,9,16,23]
9461         self.assertEqual(4,d.getNumberOfTuples());
9462         self.assertEqual(1,d.getNumberOfComponents());
9463         self.assertEqual(expected2,d.getValues());
9464         #
9465         d=DataArrayInt.Range(24,2,-7);
9466         expected3=[24,17,10,3]
9467         self.assertEqual(4,d.getNumberOfTuples());
9468         self.assertEqual(1,d.getNumberOfComponents());
9469         self.assertEqual(expected3,d.getValues());
9470         #
9471         d=DataArrayInt.Range(23,2,-7);
9472         expected4=[23,16,9]
9473         self.assertEqual(3,d.getNumberOfTuples());
9474         self.assertEqual(1,d.getNumberOfComponents());
9475         self.assertEqual(expected4,d.getValues());
9476         #
9477         d=DataArrayInt.Range(23,22,-7);
9478         self.assertEqual(1,d.getNumberOfTuples());
9479         self.assertEqual(1,d.getNumberOfComponents());
9480         self.assertEqual(23,d.getIJ(0,0));
9481         #
9482         d=DataArrayInt.Range(22,23,7);
9483         self.assertEqual(1,d.getNumberOfTuples());
9484         self.assertEqual(1,d.getNumberOfComponents());
9485         self.assertEqual(22,d.getIJ(0,0));
9486         #
9487         d=DataArrayInt.Range(22,22,7);
9488         self.assertEqual(0,d.getNumberOfTuples());
9489         self.assertEqual(1,d.getNumberOfComponents());
9490         #
9491         d=DataArrayInt.Range(22,22,-7);
9492         self.assertEqual(0,d.getNumberOfTuples());
9493         self.assertEqual(1,d.getNumberOfComponents());
9494         #
9495         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9496         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9497         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9498         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9499         pass
9500
9501     def testSwigUMeshGetItem1(self):
9502         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9503         subMesh=m.buildPartOfMySelf([1,3],True);
9504         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9505         m1=m[[1,3]]
9506         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9507         m2=m[(1,3)]
9508         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9509         m3=m[1::2]
9510         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9511         m4=m[DataArrayInt.New([1,3])]
9512         m5_1=m[1]
9513         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9514         m5_2=m[3]
9515         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9516         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9517         m5.setName(subMesh.getName())
9518         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9519         self.assertTrue(subMesh.isEqual(m1,1e-12))
9520         self.assertTrue(subMesh.isEqual(m2,1e-12))
9521         self.assertTrue(subMesh.isEqual(m3,1e-12))
9522         self.assertTrue(subMesh.isEqual(m4,1e-12))
9523         self.assertTrue(subMesh.isEqual(m5,1e-12))
9524         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9525         pass
9526
9527     def testSwigGetItem3(self):
9528         da=DataArrayInt.New([4,5,6])
9529         self.assertEqual(5,da[1])
9530         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9531         self.assertRaises(InterpKernelException,da.__getitem__,3)
9532         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9533         self.assertEqual(9,da[1,2])
9534         da=DataArrayDouble.New([4.1,5.2,6.3])
9535         self.assertAlmostEqual(5.2,da[1],12)
9536         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9537         self.assertRaises(InterpKernelException,da.__getitem__,3)
9538         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9539         self.assertAlmostEqual(9.12,da[1,2],12)
9540         pass
9541
9542     def testSwigDADISub1(self):
9543         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9544         bary=mesh3D.getBarycenterAndOwner()
9545         bary=bary[:,:2]
9546         pts=bary.getDifferentValues(1e-12)
9547         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9548         for pos,pt in enumerate(pts):
9549             bary2=bary[:,:2]
9550             bary2[:]-=pt
9551             norm=bary2.magnitude()
9552             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9553             pass
9554         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9555         for pos,pt in enumerate(pts):
9556             bary2=bary[:,:2]
9557             bary2[:]+=pt
9558             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9559             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9560             pass
9561         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9562         for pos,pt in enumerate(pts):
9563             bary2=bary[:,:2]
9564             bary2[:]*=pt
9565             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9566             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9567             pass
9568         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9569         for pos,pt in enumerate(pts):
9570             bary2=bary[:,:2]
9571             bary2[:]/=pt
9572             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9573             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9574             pass
9575         #
9576         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9577         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9578         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]]
9579         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]]
9580         for pos,tup in enumerate(d):
9581             f=e[:]
9582             self.assertTrue(isinstance(f,DataArrayInt))
9583             f[tup]=77
9584             self.assertEqual(expected5[pos],f.getValues())
9585             self.assertEqual(6*[77],f[tup].getValues())
9586             f=e[:]
9587             f[:,tup]=77
9588             self.assertEqual(expected6[pos],f.getValues())
9589             self.assertEqual(8*[77],f[:,tup].getValues())
9590             pass
9591         #
9592         e=e.convertToDblArr()
9593         for pos,tup in enumerate(d):
9594             f=e[:]
9595             self.assertTrue(isinstance(f,DataArrayDouble))
9596             f[tup]=77.
9597             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9598             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9599             f=e[:]
9600             f[:,tup]=77.
9601             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9602             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9603             pass
9604         pass
9605
9606     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9607         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9608         d1=DataArrayDouble.New();
9609         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9610         d1=DataArrayDouble.New(values1,4,3);
9611         res=d1.getMinMaxPerComponent();
9612         self.assertTrue(isinstance(res,list))
9613         self.assertEqual(3,len(res))
9614         for i in xrange(3):
9615             self.assertTrue(isinstance(res[i],tuple))
9616             self.assertEqual(2,len(res[i]))
9617             pass
9618         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9619         for i in xrange(6):
9620             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9621             pass
9622         #
9623         d1.rearrange(2);
9624         res=d1.getMinMaxPerComponent();
9625         self.assertTrue(isinstance(res,list))
9626         self.assertEqual(2,len(res))
9627         for i in xrange(2):
9628             self.assertTrue(isinstance(res[i],tuple))
9629             self.assertEqual(2,len(res[i]))
9630             pass
9631         expected2=[1.,3.,-0.9,3.]
9632         for i in xrange(4):
9633             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9634             pass
9635         #
9636         d1.rearrange(1);
9637         res=d1.getMinMaxPerComponent();
9638         self.assertTrue(isinstance(res,list))
9639         self.assertEqual(1,len(res))
9640         for i in xrange(1):
9641             self.assertTrue(isinstance(res[i],tuple))
9642             self.assertEqual(2,len(res[i]))
9643             pass
9644         expected3=[-0.9,3.]
9645         for i in xrange(2):
9646             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9647             pass
9648         pass
9649
9650     def testDataArrayIntGetHashCode1(self):
9651         d1=DataArrayInt.New(range(3545))
9652         d2=DataArrayInt.New(range(3545))
9653         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9654         self.assertEqual(232341068,d1.getHashCode())
9655         d1[886]=6
9656         self.assertEqual(232340188,d1.getHashCode())
9657         pass
9658
9659     def testZipConnectivityPol1(self):
9660         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9661         cells1=[2,3,4]
9662         m2_1=m1.buildPartOfMySelf(cells1,True);
9663         m2=m2_1
9664         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9665         # no permutation policy 0
9666         isOk,arr=m1.areCellsIncludedIn(m2,0)
9667         self.assertTrue(isOk);
9668         self.assertEqual(3,arr.getNumberOfTuples());
9669         self.assertEqual(1,arr.getNumberOfComponents());
9670         self.assertEqual(cells1,arr.getValues())
9671         # no permutation policy 1
9672         isOk,arr=m1.areCellsIncludedIn(m2,1)
9673         self.assertTrue(isOk);
9674         self.assertEqual(3,arr.getNumberOfTuples());
9675         self.assertEqual(1,arr.getNumberOfComponents());
9676         self.assertEqual(cells1,arr.getValues())
9677         # no permutation policy 2
9678         isOk,arr=m1.areCellsIncludedIn(m2,2)
9679         self.assertTrue(isOk);
9680         self.assertEqual(3,arr.getNumberOfTuples());
9681         self.assertEqual(1,arr.getNumberOfComponents());
9682         self.assertEqual(cells1,arr.getValues())
9683         # some modification into m2
9684         modif1=[2,4,5]
9685         m2.getNodalConnectivity()[1:4]=modif1
9686         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9687         expected1=[5,3,4]
9688         isOk,arr=m1.areCellsIncludedIn(m2,0)
9689         self.assertTrue(not isOk);
9690         self.assertEqual(3,arr.getNumberOfTuples());
9691         self.assertEqual(1,arr.getNumberOfComponents());
9692         self.assertEqual(expected1,arr.getValues())
9693         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
9694         isOk,arr=m1.areCellsIncludedIn(m2,1)
9695         self.assertTrue(isOk);
9696         self.assertEqual(3,arr.getNumberOfTuples());
9697         self.assertEqual(1,arr.getNumberOfComponents());
9698         self.assertEqual(cells1,arr.getValues())
9699         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9700         isOk,arr=m1.areCellsIncludedIn(m2,2)
9701         self.assertTrue(isOk);
9702         self.assertEqual(3,arr.getNumberOfTuples());
9703         self.assertEqual(1,arr.getNumberOfComponents());
9704         self.assertEqual(cells1,arr.getValues())
9705         #some new modification into m2
9706         modif2=[2,5,4]
9707         m2.getNodalConnectivity()[1:4]=modif2
9708         #policy 0 fails because cell0 in m2 has not exactly the same conn
9709         isOk,arr=m1.areCellsIncludedIn(m2,0)
9710         self.assertTrue(not isOk);
9711         self.assertEqual(3,arr.getNumberOfTuples());
9712         self.assertEqual(1,arr.getNumberOfComponents());
9713         self.assertEqual(expected1,arr.getValues())
9714         #policy 1 fails too because cell0 in m2 has not same orientation
9715         isOk,arr=m1.areCellsIncludedIn(m2,1)
9716         self.assertTrue(not isOk);
9717         self.assertEqual(3,arr.getNumberOfTuples());
9718         self.assertEqual(1,arr.getNumberOfComponents());
9719         self.assertEqual(expected1,arr.getValues())
9720         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9721         isOk,arr=m1.areCellsIncludedIn(m2,2)
9722         self.assertTrue(isOk);
9723         self.assertEqual(3,arr.getNumberOfTuples());
9724         self.assertEqual(1,arr.getNumberOfComponents());
9725         self.assertEqual(cells1,arr.getValues())
9726         # Now 1D
9727         cells2=[3,2]
9728         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9729         m2_1=m1.buildPartOfMySelf(cells2,True);
9730         m2=m2_1
9731         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9732         # no permutation policy 0
9733         isOk,arr=m1.areCellsIncludedIn(m2,0)
9734         self.assertTrue(isOk);
9735         self.assertEqual(2,arr.getNumberOfTuples());
9736         self.assertEqual(1,arr.getNumberOfComponents());
9737         self.assertEqual(cells2,arr.getValues())
9738         # no permutation policy 1
9739         isOk,arr=m1.areCellsIncludedIn(m2,1)
9740         self.assertTrue(isOk);
9741         self.assertEqual(2,arr.getNumberOfTuples());
9742         self.assertEqual(1,arr.getNumberOfComponents());
9743         self.assertEqual(cells2,arr.getValues())
9744         # no permutation policy 2
9745         isOk,arr=m1.areCellsIncludedIn(m2,2)
9746         self.assertTrue(isOk);
9747         self.assertEqual(2,arr.getNumberOfTuples());
9748         self.assertEqual(1,arr.getNumberOfComponents());
9749         self.assertEqual(cells2,arr.getValues())
9750         # some modification into m2
9751         modif3=[4,3]
9752         m2.getNodalConnectivity()[1:3]=modif3
9753         #policy 0 fails because cell0 in m2 has not exactly the same conn
9754         expected2=[4,2]
9755         isOk,arr=m1.areCellsIncludedIn(m2,0)
9756         self.assertTrue(not isOk);
9757         self.assertEqual(2,arr.getNumberOfTuples());
9758         self.assertEqual(1,arr.getNumberOfComponents());
9759         self.assertEqual(expected2,arr.getValues())
9760         #policy 1 fails too because cell0 in m2 has not same orientation
9761         isOk,arr=m1.areCellsIncludedIn(m2,1)
9762         self.assertTrue(not isOk);
9763         self.assertEqual(2,arr.getNumberOfTuples());
9764         self.assertEqual(1,arr.getNumberOfComponents());
9765         self.assertEqual(expected2,arr.getValues())
9766         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9767         isOk,arr=m1.areCellsIncludedIn(m2,2)
9768         self.assertTrue(isOk);
9769         self.assertEqual(2,arr.getNumberOfTuples());
9770         self.assertEqual(1,arr.getNumberOfComponents());
9771         self.assertEqual(cells2,arr.getValues())
9772         pass
9773
9774     def toSeeIfDaIIopsAreOK(self,d):
9775         d+=5
9776         d*=6
9777         d/=3
9778         d-=2
9779         d%=7
9780         pass
9781
9782     def testSwigDAIOp5(self):
9783         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9784         self.toSeeIfDaIIopsAreOK(d)
9785         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9786         self.assertTrue(d.isEqual(dExp));
9787         pass
9788
9789     def toSeeIfDaDIopsAreOK(self,d):
9790         d+=5
9791         d*=6
9792         d/=3
9793         d-=2
9794         pass
9795
9796     def testSwigDADOp7(self):
9797         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9798         self.toSeeIfDaDIopsAreOK(d)
9799         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9800         self.assertTrue(d.isEqual(dExp,1e-14));
9801         pass
9802
9803     def testConvexEnvelop2D1(self):
9804         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]
9805         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]
9806         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]
9807         #
9808         m=MEDCouplingUMesh.New("convexhull",2);
9809         m.allocateCells(331);
9810         for i in xrange(331):
9811             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9812             pass
9813         m.finishInsertingCells();
9814         coordsDa=DataArrayDouble.New(coords,331,2);
9815         m.setCoords(coordsDa);
9816         m.checkCoherency();
9817         #
9818         da=m.convexEnvelop2D();
9819         m.checkCoherency()
9820         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9821         daC=da.buildComplement(m.getNumberOfCells());
9822         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]);
9823         self.assertTrue(expected2.isEqual(daC));
9824         #
9825         vals=m.getMeasureField(ON_CELLS).getArray()
9826         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]
9827         vals-=DataArrayDouble.New(ref)
9828         vals.abs()
9829         theTest=vals.getIdsInRange(-1.,1e-7)
9830         self.assertTrue(theTest.isIdentity())
9831         self.assertEqual(331,len(theTest))
9832         pass
9833
9834     def testSwigDAIOp8(self):
9835         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9836         self.assertTrue(7 in da)
9837         self.assertTrue(47 in da)
9838         self.assertTrue(15 in da)
9839         self.assertEqual(0,da.index(7))
9840         self.assertEqual(10,da.index(47))
9841         self.assertTrue(14 not in da)
9842         self.assertEqual(5,da.search([9,9]))
9843         self.assertEqual(-1,da.search([5,8]))
9844         da.rearrange(2)
9845         self.assertTrue([47,16] not in da)
9846         self.assertTrue([5,6] not in da)
9847         self.assertTrue([6,7] in da)
9848         self.assertEqual(4,da.index([12,13]))
9849         pass
9850
9851     def testDataArraySort1(self):
9852         arr=DataArrayInt.New();
9853         self.assertRaises(InterpKernelException,arr.sort,True)
9854         self.assertRaises(InterpKernelException,arr.sort,False)
9855         values=[2,1,6,5,4,7]
9856         arr.alloc(3,2);
9857         self.assertRaises(InterpKernelException,arr.sort,True)
9858         self.assertRaises(InterpKernelException,arr.sort,False)
9859         arr.rearrange(1);
9860         arr.setValues(values,6,1)
9861         arr1=arr.deepCpy();
9862         arr2=arr.deepCpy();
9863         arr1.sort(True);
9864         expected1=[1,2,4,5,6,7]
9865         self.assertEqual(6,arr1.getNumberOfTuples());
9866         self.assertEqual(1,arr1.getNumberOfComponents());
9867         self.assertEqual(expected1,arr1.getValues());
9868         arr2.sort(False);
9869         expected2=[7,6,5,4,2,1]
9870         self.assertEqual(6,arr2.getNumberOfTuples());
9871         self.assertEqual(1,arr2.getNumberOfComponents());
9872         self.assertTrue(expected2,arr2.getValues());
9873         #
9874         ard=DataArrayDouble.New();
9875         self.assertRaises(InterpKernelException,ard.sort,True)
9876         self.assertRaises(InterpKernelException,ard.sort,False)
9877         valuesD=[2.,1.,6.,5.,4.,7.]
9878         ard.alloc(3,2);
9879         self.assertRaises(InterpKernelException,ard.sort,True)
9880         self.assertRaises(InterpKernelException,ard.sort,False)
9881         ard.rearrange(1);
9882         ard.setValues(valuesD,6,1)
9883         ard1=ard.deepCpy();
9884         ard2=ard.deepCpy();
9885         ard1.sort(True);
9886         expected3=[1.,2.,4.,5.,6.,7.]
9887         self.assertEqual(6,ard1.getNumberOfTuples());
9888         self.assertEqual(1,ard1.getNumberOfComponents());
9889         for i in xrange(6):
9890             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
9891             pass
9892         ard2.sort(False);
9893         expected4=[7.,6.,5.,4.,2.,1.]
9894         self.assertEqual(6,ard2.getNumberOfTuples());
9895         self.assertEqual(1,ard2.getNumberOfComponents());
9896         for i in xrange(6):
9897             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
9898             pass
9899         pass
9900
9901     def testPartitionBySpreadZone1(self):
9902         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9903         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
9904         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
9905         #
9906         v2=m4.partitionBySpreadZone();
9907         self.assertTrue(3,len(v2));
9908         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
9909         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
9910         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
9911         #
9912         m5=m4.buildSpreadZonesWithPoly();
9913         self.assertEqual(3,m5.getNumberOfCells());
9914         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
9915         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())
9916         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
9917         #
9918         pass
9919
9920     def testGiveCellsWithType1(self):
9921         expected0=[1,2]
9922         expected1=[0,3,4]
9923         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9924         da=m.giveCellsWithType(NORM_TRI3);
9925         self.assertEqual(2,da.getNumberOfTuples());
9926         self.assertEqual(1,da.getNumberOfComponents());
9927         self.assertEqual(expected0,da.getValues())
9928         #
9929         da=m.giveCellsWithType(NORM_QUAD4);
9930         self.assertEqual(3,da.getNumberOfTuples());
9931         self.assertEqual(1,da.getNumberOfComponents());
9932         self.assertEqual(expected1,da.getValues())
9933         #
9934         da=m.giveCellsWithType(NORM_TRI6);
9935         self.assertEqual(0,da.getNumberOfTuples());
9936         self.assertEqual(1,da.getNumberOfComponents());
9937         #
9938         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
9939         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
9940         pass
9941
9942     def testSwigDAOp1(self):
9943         d=DataArrayDouble.New(5,2)
9944         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
9945         d.setInfoOnComponents(["X [m]","Y [m]"])
9946         d.setName("AName")
9947         #
9948         d1=d+[8,9]
9949         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))
9950         d1bis=DataArrayDouble.New([8,9],1,2)+d
9951         self.assertTrue(d1bis.isEqual(d1,1e-12))
9952         d1ter=[8,9]+d
9953         self.assertTrue(d1ter.isEqual(d1,1e-12))
9954         #
9955         d2=d1-[8,9]
9956         self.assertTrue(d2.isEqual(d,1e-12))
9957         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
9958         #
9959         d3=d*[8,9]
9960         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))
9961         d3bis=DataArrayDouble.New([8,9],1,2)*d
9962         self.assertTrue(d3bis.isEqual(d3,1e-12))
9963         d3ter=[8,9]*d
9964         self.assertTrue(d3ter.isEqual(d3,1e-12))
9965         #
9966         d4=d3/[8,9]
9967         self.assertTrue(d4.isEqual(d,1e-12))
9968         #
9969         d=DataArrayInt.New(5,2)
9970         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
9971         d.setInfoOnComponents(["X [m]","Y [m]"])
9972         d.setName("AName")
9973         #
9974         d1=d+[8,9]
9975         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
9976         d1bis=DataArrayInt.New([8,9],1,2)+d
9977         self.assertTrue(d1bis.isEqual(d1))
9978         d1ter=[8,9]+d
9979         self.assertTrue(d1ter.isEqual(d1))
9980         #
9981         d2=d1-[8,9]
9982         self.assertTrue(d2.isEqual(d))
9983         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
9984         #
9985         d3=d*[8,9]
9986         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
9987         d3bis=DataArrayInt.New([8,9],1,2)*d
9988         self.assertTrue(d3bis.isEqual(d3))
9989         d3ter=[8,9]*d
9990         self.assertTrue(d3ter.isEqual(d3))
9991         #
9992         d4=d3/[8,9]
9993         self.assertTrue(d4.isEqual(d))
9994         #
9995         d5=d%[4,5]
9996         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
9997         pass
9998
9999     def testSwigSelectTupleId2DAIBug1(self):
10000         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
10001         self.assertEqual([2,6,10],da[2::6].getValues())
10002         self.assertEqual([0,4,8],da[::6].getValues())
10003         self.assertEqual([5,9],da[7::6].getValues())
10004         self.assertEqual([5],da[7:-5:6].getValues())
10005         pass
10006
10007     def testSwigCpp5Safe1(self):
10008         m=MEDCouplingUMesh.New("toto",2)
10009         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
10010         m.setCoords(coords)
10011         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
10012         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]]
10013         for pos,vec in enumerate(vecs):
10014             m2=m.deepCpy()
10015             m2.translate(vec)
10016             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10017             pass
10018         for pos,vec in enumerate(vecs):
10019             m2=m.deepCpy()
10020             m2.translate(vec.buildDADouble())
10021             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10022             pass
10023         pass
10024
10025     def testSwigBugNonRegressionZipDA(self):
10026         angles=map(lambda x:pi/3*x,xrange(6))
10027         radius=3
10028         #
10029         dad=DataArrayDouble.New(6, 2)
10030         dad[:,0]=radius
10031         dad[:,1]=angles
10032         #
10033         dad2=dad.fromPolarToCart()
10034         dads=[dad2.deepCpy() for elt in 7*[None]]
10035         #
10036         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.)]]
10037         for d,t in zip(dads,translationToPerform):
10038             d+=t
10039             pass
10040         for elt in dads:
10041             self.assertTrue(not dad2.isEqual(elt,1e-12))
10042             pass
10043         for d,t in zip(dads,translationToPerform):
10044             d-=t
10045             pass
10046         for elt in dads:
10047             self.assertTrue(dad2.isEqual(elt,1e-12))
10048             pass
10049         pass
10050
10051     def testBuildSlice3D2(self):
10052         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
10053         vec1=[-0.07,1.,0.07]
10054         origin1=[1.524,1.4552,1.74768]
10055         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
10056         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
10057         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
10058         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
10059         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
10060         f.setArray(arr)
10061         f.checkCoherency()
10062         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
10063         self.assertTrue(expected1.isEqual(ids))
10064         arr2=arr[expected1]
10065         #
10066         f2=f.extractSlice3D(origin1,vec1,1e-10)
10067         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10068         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10069         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10070         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10071         pass
10072
10073     def testComputeTupleIdsToSelectFromCellIds1(self):
10074         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10075         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10076         f.setMesh(m);
10077         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10078         f.setArray(arr)
10079         #
10080         f2=f.buildSubPart([1,5,9])
10081         f2.checkCoherency()
10082         cI=m.computeNbOfNodesPerCell()
10083         cI.computeOffsets2()
10084         sel=DataArrayInt([1,5,9])
10085         res=sel.buildExplicitArrByRanges(cI)
10086         arr2=arr[res]
10087         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))
10088         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10089         pass
10090
10091     def testComputeSkin1(self):
10092         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10093         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10094         umesh=cmesh.buildUnstructured()
10095         #
10096         skin=umesh.computeSkin()
10097         self.assertEqual(18,skin.getNumberOfCells())
10098         self.assertEqual(1,skin.getMeshDimension())
10099         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10100         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10101         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())
10102         ids=skin.computeFetchedNodeIds()
10103         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10104         part=umesh.buildFacePartOfMySelfNode(ids,True)
10105         part.setName(skin.getName());
10106         self.assertTrue(part.isEqual(skin,1e-12))
10107         part2=part[1::2]
10108         part[::2]=part2
10109         self.assertTrue(not part.isEqual(skin,1e-12))
10110         trad=part.zipConnectivityTraducer(0)
10111         self.assertEqual(9,part.getNumberOfCells())
10112         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10113         pass
10114
10115     def testUMeshSetPartOfMySelf2(self):
10116         # resize with explicit ids list
10117         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10118         self.assertEqual([3,4],m.getAllTypes())
10119         part=m[[0,3,4]]
10120         part.simplexize(0)
10121         part2=part[[1,2,5]]
10122         m[[0,3,4]]=part2
10123         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())
10124         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10125         self.assertEqual([3],m.getAllTypes())
10126         # no resize with explicit ids list
10127         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10128         part=m[[0,3]]
10129         part.convertAllToPoly()
10130         m[[3,4]]=part
10131         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())
10132         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10133         self.assertEqual([3,4,5],m.getAllTypes())
10134         # resize with range ids
10135         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10136         part=m[3:]
10137         m[1:3]=part
10138         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())
10139         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10140         self.assertEqual([4],m.getAllTypes())
10141         # no resize with range ids
10142         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10143         part=m[0::3]
10144         part.convertAllToPoly()
10145         m[3:]=part
10146         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())
10147         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10148         self.assertEqual([3,4,5],m.getAllTypes())
10149         # no resize with range ids negative direction
10150         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10151         part=m[3::-3]
10152         part.convertAllToPoly()
10153         m[:-3:-1]=part
10154         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())
10155         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10156         self.assertEqual([3,4,5],m.getAllTypes())
10157         pass
10158
10159     def testUnPolyze3(self):
10160         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]
10161         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10162         m=MEDCouplingUMesh.New("a mesh",3);
10163         m.allocateCells(1);
10164         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10165         m.finishInsertingCells();
10166         coords=DataArrayDouble(coord,6,3);
10167         m.setCoords(coords);
10168         m.checkCoherency();
10169         #
10170         vol=m.getMeasureField(ON_CELLS);
10171         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10172         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10173         #
10174         m.unPolyze();
10175         #
10176         self.assertEqual([NORM_PENTA6],m.getAllTypes())
10177         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10178         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10179         #
10180         vol=m.getMeasureField(ON_CELLS);
10181         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10182         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10183         pass
10184
10185     def testKrSpatialDiscretization1(self):
10186         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10187         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10188         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]
10189         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]
10190         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])
10191         #
10192         nbOfInputPoints=10;
10193         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10194         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10195         cmesh=MEDCouplingCMesh.New("aMesh");
10196         cmesh.setCoordsAt(0,srcArrX);
10197         umesh=cmesh.buildUnstructured();
10198         f.setMesh(umesh);
10199         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10200         f.setArray(srcVals);
10201         f.checkCoherency();
10202         #
10203         res0=f.getValueOn(targetPointCoordsX[:1]);
10204         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10205         #
10206         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10207         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10208         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10209         for i in xrange(40):
10210             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10211             pass
10212         fd=f.getDiscretization()
10213         del f
10214         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10215         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10216         self.assertEqual(2,isDrift)
10217         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10218         #
10219         pass
10220
10221     def testDuplicateEachTupleNTimes1(self):
10222         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10223         d2=d.duplicateEachTupleNTimes(3)
10224         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10225         self.assertEqual("aname",d2.getName())
10226         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10227         #
10228         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10229         d2=d.duplicateEachTupleNTimes(3)
10230         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10231         self.assertEqual("aname",d2.getName())
10232         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10233         pass
10234
10235     def testSwigComputeTupleIdsNearTuples1(self):
10236         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10237         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10238         self.assertEqual([2,0,4,1],arr.getValues())
10239         self.assertEqual([0,1,3,4],arrI.getValues())
10240         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10241         self.assertEqual([2,0,4,1],arr.getValues())
10242         self.assertEqual([0,1,3,4],arrI.getValues())
10243         expected0=[[2],[0,4],[1]]
10244         expected1=[[0,1],[0,2],[0,1]]
10245         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10246             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10247             self.assertEqual(expected0[pos],arr.getValues())
10248             self.assertEqual(expected1[pos],arrI.getValues())
10249             pass
10250         pass
10251
10252     def testSwigDataTupleIOp1(self):
10253         d=DataArrayDouble(10,1)
10254         d.iota(7.)
10255         for elt in d:
10256             elt+=2.
10257             pass
10258         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10259         self.assertTrue(toTest.isEqual(d,1e-12))
10260         for elt in d:
10261             elt-=2.
10262             pass
10263         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10264         self.assertTrue(toTest.isEqual(d,1e-12))
10265         for elt in d:
10266             elt*=2.
10267             pass
10268         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10269         self.assertTrue(toTest.isEqual(d,1e-12))
10270         for elt in d:
10271             elt/=2.
10272             pass
10273         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10274         self.assertTrue(toTest.isEqual(d,1e-12))
10275         #
10276         d=DataArrayInt(10,1)
10277         d.iota(7)
10278         for elt in d:
10279             elt+=2
10280             pass
10281         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10282         for elt in d:
10283             elt-=2
10284             pass
10285         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10286         for elt in d:
10287             elt*=2
10288             pass
10289         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10290         for elt in d:
10291             elt/=2
10292             pass
10293         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10294         for elt in d:
10295             elt%=3
10296             pass
10297         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10298         pass
10299
10300     def testIntersect2DMeshesTmp5(self):
10301         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)
10302         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)
10303         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)
10304         #
10305         m1=MEDCouplingUMesh.New("Fix",2);
10306         m1.setCoords(coords);
10307         m1.setConnectivity(conn,connI,True);
10308         #
10309         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)
10310         # connectivity
10311         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);
10312         conn.setName("");
10313         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
10314         m2=MEDCouplingUMesh.New("Mobile",2);
10315         m2.setCoords(coords);
10316         m2.setConnectivity(conn,connI,True);
10317         #
10318         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10319         self.assertEqual(105,m3.getNumberOfCells());
10320         self.assertEqual(105,d1.getNumberOfTuples());
10321         self.assertEqual(105,d2.getNumberOfTuples());
10322         self.assertEqual(704,m3.getNumberOfNodes());
10323         #
10324         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]
10325         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]
10326         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]
10327         f3=m3.getMeasureField(ON_CELLS).getArray().getValues();
10328         for i in xrange(105):
10329             self.assertAlmostEqual(areaExpected[i],f3[i],10)
10330             pass
10331         self.assertEqual(expected1,d1.getValues())
10332         self.assertEqual(expected2,d2.getValues())
10333         pass
10334
10335     def testDAIBuildUnique1(self):
10336         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
10337         e=d.buildUnique()
10338         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
10339         pass
10340
10341     def testDAIPartitionByDifferentValues1(self):
10342         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
10343         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
10344         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
10345             self.assertEqual(expected[i][0],elt[1])
10346             self.assertEqual(expected[i][1],elt[0].getValues())
10347             pass
10348         pass
10349
10350     def testFieldGaussMultiDiscPerType1(self):
10351         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
10352         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
10353         mQ8.allocateCells(1)
10354         mQ8.insertNextCell(NORM_QUAD8,range(8))
10355         mQ8.finishInsertingCells()
10356         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
10357         mQ4.allocateCells(1)
10358         mQ4.insertNextCell(NORM_QUAD4,range(4))
10359         mQ4.finishInsertingCells()
10360         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
10361         mT3.allocateCells(1)
10362         mT3.insertNextCell(NORM_TRI3,range(3))
10363         mT3.finishInsertingCells()
10364
10365         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.]]
10366         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
10367         ms[:]=(elt.deepCpy() for elt in ms)
10368         for m,t in zip(ms,tr):
10369             d=m.getCoords() ; d+= t
10370             pass
10371         m=MEDCouplingUMesh.MergeUMeshes(ms)
10372         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
10373         f.setMesh(m)
10374         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
10375         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])
10376         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10377         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])
10378         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])
10379         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
10380         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])
10381         self.assertEqual(46,f.getNumberOfTuplesExpected())
10382         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
10383         f.setArray(vals)
10384         f.checkCoherency()
10385         #f.getLocalizationOfDiscr()
10386         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
10387         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
10388         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())
10389         fc=f[[1,2,3,8]]
10390         fc.checkCoherency()
10391         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))
10392         fc.renumberCells([3,2,0,1])
10393         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))
10394         fc.getArray()
10395         pass
10396
10397     def testSwigRotate(self):
10398         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
10399         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
10400         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
10401         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
10402         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
10403         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
10404         pass
10405
10406     def testSwigCMeshProtection(self):
10407         cm=MEDCouplingCMesh()
10408         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
10409         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
10410         pass
10411
10412     def testSwigCellsInBoundingBox1(self):
10413         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
10414         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
10415         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
10416         pass
10417
10418     def testDAICheckMonotonic1(self):
10419         data1=[-1,0,2,2,4,5]
10420         data2=[6,2,0,-8,-9,-56]
10421         data3=[-1,0,3,2,4,6]
10422         data4=[7,5,2,3,0,-6]
10423         d=DataArrayInt.New(data1);
10424         self.assertTrue(d.isMonotonic(True));
10425         self.assertTrue(not d.isMonotonic(False));
10426         d.checkMonotonic(True);
10427         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10428         d=DataArrayInt.New(data2);
10429         self.assertTrue(d.isMonotonic(False));
10430         self.assertTrue(not d.isMonotonic(True));
10431         d.checkMonotonic(False);
10432         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10433         d=DataArrayInt.New(data3);
10434         self.assertTrue(not d.isMonotonic(False));
10435         self.assertTrue(not d.isMonotonic(True));
10436         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10437         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10438         d=DataArrayInt.New(data4);
10439         self.assertTrue(not d.isMonotonic(False));
10440         self.assertTrue(not d.isMonotonic(True));
10441         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10442         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10443         d=DataArrayInt.New(0,1)
10444         self.assertTrue(d.isMonotonic(True));
10445         self.assertTrue(d.isMonotonic(False));
10446         d.checkMonotonic(True);
10447         d.checkMonotonic(False);
10448         d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
10449         self.assertRaises(InterpKernelException,d.isMonotonic,True)
10450         self.assertRaises(InterpKernelException,d.isMonotonic,False)
10451         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10452         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10453         pass
10454
10455     def testSwigDASetItemOnEmpty1(self):
10456         d=DataArrayInt(0,1)
10457         isThrow=False
10458         try:
10459             d[0:1000:2]=4
10460         except InterpKernelException as e:
10461             isThrow=True
10462             pass
10463         self.assertTrue(isThrow)
10464         d[:]=4
10465         d[::2]=5
10466         #
10467         d=DataArrayDouble(0,1)
10468         isThrow=False
10469         try:
10470             d[0:1000:2]=4
10471         except InterpKernelException as e:
10472             isThrow=True
10473             pass
10474         self.assertTrue(isThrow)
10475         d[:]=4
10476         d[::2]=5
10477         d=DataArrayInt([],0,1)
10478         d2=DataArrayInt(0)
10479         self.assertTrue(d2.isEqual(d))
10480         d=DataArrayDouble([],0,1)
10481         d2=DataArrayDouble(0)
10482         self.assertTrue(d2.isEqual(d,1e-12))
10483         pass
10484
10485     def testSwigDAITransformWithIndArr1(self):
10486         arr=DataArrayInt([0,4,5,1])
10487         d=DataArrayInt([7,8,9,10])
10488         self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
10489         pass
10490
10491     def testIntersect2DMeshesTmp6(self):
10492         # coordinates
10493         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);
10494         # connectivity
10495         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
10496         connI=DataArrayInt.New([0,9]);
10497         m1=MEDCouplingUMesh.New("Fixe",2);
10498         m1.setCoords(coords);
10499         m1.setConnectivity(conn,connI,True);
10500         #
10501         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);
10502         # connectivity
10503         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
10504         connI=DataArrayInt.New([0,9,18]);
10505         #
10506         m2=MEDCouplingUMesh.New("Mobile",2);
10507         m2.setCoords(coords);
10508         m2.setConnectivity(conn,connI,True);
10509         #
10510         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10511         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
10512         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
10513         self.assertEqual(4,m3.getNumberOfCells());
10514         self.assertEqual(4,d1.getNumberOfTuples());
10515         self.assertEqual(4,d2.getNumberOfTuples());
10516         self.assertEqual(43,m3.getNumberOfNodes());
10517         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
10518         self.assertEqual(35,m3.getNumberOfNodes());
10519         m3.zipCoords();
10520         self.assertEqual(23,m3.getNumberOfNodes());
10521         #
10522         f=m3.getMeasureField(True);
10523         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
10524         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
10525         pass
10526
10527     def testDAPushBack(self):
10528         d=DataArrayDouble(0,1)
10529         for i in xrange(8):
10530             d.pushBackSilent(i)
10531             pass
10532         self.assertEqual(d.getNumberOfTuples(),8)
10533         self.assertEqual(d.getNbOfElemAllocated(),8)
10534         d.pushBackSilent(4.44)
10535         self.assertEqual(d.getNumberOfTuples(),9)
10536         self.assertEqual(d.getNbOfElemAllocated(),16)
10537         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10538         e=d.deepCpy()
10539         self.assertEqual(e.getNumberOfTuples(),9)
10540         self.assertEqual(e.getNbOfElemAllocated(),9)
10541         self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10542         self.assertAlmostEqual(d.popBackSilent(),4.44,12)
10543         self.assertEqual(d.getNumberOfTuples(),8)
10544         self.assertEqual(d.getNbOfElemAllocated(),16)
10545         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
10546         f=DataArrayDouble()
10547         f.reserve(1000)
10548         f.pushBackSilent(4.)
10549         self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
10550         self.assertEqual(f.getNumberOfTuples(),1)
10551         self.assertEqual(f.getNbOfElemAllocated(),1000)
10552         ff=f[:]
10553         self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
10554         self.assertEqual(ff.getNumberOfTuples(),1)
10555         self.assertEqual(ff.getNbOfElemAllocated(),1)
10556         d=DataArrayDouble()
10557         d.pushBackSilent(4.44)
10558         d.pushBackSilent(5.55)
10559         d.pushBackSilent(6.66)
10560         self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
10561         #
10562         d=DataArrayInt(0,1)
10563         for i in xrange(8):
10564             d.pushBackSilent(i)
10565             pass
10566         self.assertEqual(d.getNumberOfTuples(),8)
10567         self.assertEqual(d.getNbOfElemAllocated(),8)
10568         d.pushBackSilent(444)
10569         self.assertEqual(d.getNumberOfTuples(),9)
10570         self.assertEqual(d.getNbOfElemAllocated(),16)
10571         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10572         e=d.deepCpy()
10573         self.assertEqual(e.getNumberOfTuples(),9)
10574         self.assertEqual(e.getNbOfElemAllocated(),9)
10575         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10576         self.assertEqual(d.popBackSilent(),444)
10577         self.assertEqual(d.getNumberOfTuples(),8)
10578         self.assertEqual(d.getNbOfElemAllocated(),16)
10579         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
10580         f=DataArrayInt()
10581         f.reserve(1000)
10582         f.pushBackSilent(4)
10583         self.assertTrue(f.isEqual(DataArrayInt([4])))
10584         self.assertEqual(f.getNumberOfTuples(),1)
10585         self.assertEqual(f.getNbOfElemAllocated(),1000)
10586         ff=f[:]
10587         self.assertTrue(ff.isEqual(DataArrayInt([4])))
10588         self.assertEqual(ff.getNumberOfTuples(),1)
10589         self.assertEqual(ff.getNbOfElemAllocated(),1)
10590         d=DataArrayInt()
10591         d.pushBackSilent(444)
10592         d.pushBackSilent(555)
10593         d.pushBackSilent(666)
10594         self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
10595         #
10596         d=DataArrayInt()
10597         d.alloc(10,1)
10598         d.setInfoOnComponent(0,"ABC")
10599         d.setName("dEf")
10600         d.iota(7)
10601         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10602         self.assertEqual(10,d.getNbOfElemAllocated())
10603         d.pushBackSilent(55)
10604         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10605         self.assertEqual(20,d.getNbOfElemAllocated())
10606         d.reserve(4)
10607         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10608         self.assertEqual(4,d.getNbOfElemAllocated())
10609         d.pushBackSilent(5)
10610         e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10611         self.assertEqual(8,d.getNbOfElemAllocated())
10612         self.assertEqual(5,d.popBackSilent())
10613         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10614         self.assertEqual(8,d.getNbOfElemAllocated())
10615         self.assertRaises(OverflowError,d.reserve,-1)
10616         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10617         self.assertEqual(8,d.getNbOfElemAllocated())
10618         d.reserve(0)
10619         e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
10620         self.assertEqual(0,d.getNbOfElemAllocated())
10621         #
10622         d=DataArrayDouble()
10623         d.alloc(10,1)
10624         d.setInfoOnComponent(0,"ABC")
10625         d.setName("dEf")
10626         d.iota(7)
10627         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10628         self.assertEqual(10,d.getNbOfElemAllocated())
10629         d.pushBackSilent(55)
10630         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10631         self.assertEqual(20,d.getNbOfElemAllocated())
10632         d.reserve(4)
10633         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10634         self.assertEqual(4,d.getNbOfElemAllocated())
10635         d.pushBackSilent(5)
10636         e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10637         self.assertEqual(8,d.getNbOfElemAllocated())
10638         self.assertEqual(5.,d.popBackSilent())
10639         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10640         self.assertEqual(8,d.getNbOfElemAllocated())
10641         self.assertRaises(OverflowError,d.reserve,-1)
10642         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10643         self.assertEqual(8,d.getNbOfElemAllocated())
10644         d.reserve(0)
10645         e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
10646         self.assertEqual(0,d.getNbOfElemAllocated())
10647         pass
10648
10649     def testDAIBuildSubstractionOptimized1(self):
10650         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10651         da2=DataArrayInt.New([3,5,9])
10652         da3=DataArrayInt.New([1,3,5])
10653         da4=DataArrayInt.New([1,3,5,6,7,9,13])
10654         #
10655         a=da1.buildSubstractionOptimized(da2);
10656         self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
10657         #
10658         a=da1.buildSubstractionOptimized(da3);
10659         self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
10660         #
10661         a=da1.buildSubstractionOptimized(da4);
10662         self.assertTrue(a.isEqual(DataArrayInt([])));
10663         pass
10664
10665     def testDAIIsStrictlyMonotonic1(self):
10666         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10667         self.assertTrue(da1.isStrictlyMonotonic(True));
10668         da1.checkStrictlyMonotonic(True);
10669         self.assertTrue(da1.isMonotonic(True));
10670         da1.checkMonotonic(True);
10671         self.assertTrue(not da1.isStrictlyMonotonic(False));
10672         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10673         self.assertTrue(not da1.isMonotonic(False));
10674         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10675         #
10676         da1=DataArrayInt.New([1,3,5,6,6,9,13])
10677         self.assertTrue(not da1.isStrictlyMonotonic(True));
10678         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10679         self.assertTrue(da1.isMonotonic(True));
10680         da1.checkMonotonic(True);
10681         self.assertTrue(not da1.isStrictlyMonotonic(False));
10682         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10683         self.assertTrue(not da1.isMonotonic(False));
10684         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10685         #
10686         da1=DataArrayInt.New([1,3,5,6,5,9,13])
10687         self.assertTrue(not da1.isStrictlyMonotonic(True));
10688         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10689         self.assertTrue(not da1.isMonotonic(True));
10690         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10691         self.assertTrue(not da1.isStrictlyMonotonic(False));
10692         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10693         self.assertTrue(not da1.isMonotonic(False));
10694         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10695         #
10696         da1=DataArrayInt.New([13,9,7,6,5,3,1])
10697         self.assertTrue(not da1.isStrictlyMonotonic(True));
10698         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10699         self.assertTrue(not da1.isMonotonic(True));
10700         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10701         self.assertTrue(da1.isStrictlyMonotonic(False));
10702         da1.checkStrictlyMonotonic(False);
10703         self.assertTrue(da1.isMonotonic(False));
10704         da1.checkMonotonic(False);
10705         #
10706         da1=DataArrayInt.New([13,9,6,6,5,3,1])
10707         self.assertTrue(not da1.isStrictlyMonotonic(True));
10708         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10709         self.assertTrue(not da1.isMonotonic(True));
10710         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10711         self.assertTrue(not da1.isStrictlyMonotonic(False));
10712         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10713         self.assertTrue(da1.isMonotonic(False));
10714         da1.checkMonotonic(False);
10715         #
10716         da1=DataArrayInt.New([13,9,5,6,5,3,1])
10717         self.assertTrue(not da1.isStrictlyMonotonic(True));
10718         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10719         self.assertTrue(not da1.isMonotonic(True));
10720         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10721         self.assertTrue(not da1.isStrictlyMonotonic(False));
10722         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10723         self.assertTrue(not da1.isMonotonic(False));
10724         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10725         #
10726         da1=DataArrayInt.New([])
10727         self.assertTrue(da1.isStrictlyMonotonic(True));
10728         da1.checkStrictlyMonotonic(True);
10729         self.assertTrue(da1.isMonotonic(True));
10730         da1.checkMonotonic(True);
10731         self.assertTrue(da1.isStrictlyMonotonic(False));
10732         da1.checkStrictlyMonotonic(False);
10733         self.assertTrue(da1.isMonotonic(False));
10734         da1.checkMonotonic(False);
10735         #
10736         da1=DataArrayInt.New([13])
10737         self.assertTrue(da1.isStrictlyMonotonic(True));
10738         da1.checkStrictlyMonotonic(True);
10739         self.assertTrue(da1.isMonotonic(True));
10740         da1.checkMonotonic(True);
10741         self.assertTrue(da1.isStrictlyMonotonic(False));
10742         da1.checkStrictlyMonotonic(False);
10743         self.assertTrue(da1.isMonotonic(False));
10744         da1.checkMonotonic(False);
10745         pass
10746
10747     def testFindAndCorrectBadOriented3DCells1(self):
10748         nbOfDisc=20
10749         vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
10750         #
10751         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10752         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10753         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10754         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10755         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
10756         self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
10757         m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
10758         c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
10759         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
10760         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)
10761         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)
10762         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)
10763         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10764         expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
10765         for v in vects:
10766             for i in xrange(nbOfDisc):
10767                 mm=m.deepCpy()
10768                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10769                 mm2=mm.deepCpy()
10770                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10771                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
10772                 self.assertTrue(mm.isEqual(mm2,1e-14))
10773                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10774                 mm.convertAllToPoly()
10775                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10776                 pass
10777             pass
10778         #
10779         mOK=m.deepCpy()
10780         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
10781         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10782         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10783         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
10784         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
10785         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10786         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10787         expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
10788         for v in vects:
10789             for i in xrange(nbOfDisc):
10790                 mm=m.deepCpy()
10791                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10792                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10793                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10794                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10795                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
10796                 mOK.setCoords(mm.getCoords())
10797                 self.assertTrue(mm.isEqual(mOK,1e-14))
10798                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10799                 mmm=mm.deepCpy()
10800                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10801                 mm.convertAllToPoly()
10802                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10803                 pass
10804             pass
10805         #
10806         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10807         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented
10808         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented
10809         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10810         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,range(12)); #Well oriented
10811         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10812         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10813         expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
10814         for v in vects:
10815             for i in xrange(nbOfDisc):
10816                 mm=m.deepCpy()
10817                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10818                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10819                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10820                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10821                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
10822                 mOK.setCoords(mm.getCoords())
10823                 self.assertTrue(mm.isEqual(mOK,1e-14))
10824                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10825                 mmm=mm.deepCpy()
10826                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10827                 mm.convertAllToPoly()
10828                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10829                 pass
10830             pass
10831         pass
10832
10833     def testSwig2CellOrientation1(self):
10834         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)
10835         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]]
10836         for i in xrange(256):
10837             mesh=MEDCouplingUMesh("FluidMesh_1",3);
10838             mesh.allocateCells(0)
10839             conn2=[elt[:] for elt in conn]
10840             code=bin(i)[2:] ; code='0'*(8-len(code))+code
10841             for face,rev in zip(conn2,code):
10842                 if bool(int(rev)):
10843                     face.reverse()
10844                     pass
10845                 pass
10846             conn3=[elt+[-1] for elt in conn2]
10847             conn3=sum(conn3,[])[:-1]
10848             mesh.insertNextCell(NORM_POLYHED,conn3)
10849             mesh.setCoords(coords)
10850             mesh.orientCorrectlyPolyhedrons()
10851             self.assertTrue(mesh.getBarycenterAndOwner().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
10852             pass
10853         pass
10854
10855     def testSwig2CheckConsecutiveCellTypesForMEDFileFrmt1(self):
10856         m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
10857         m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
10858         m1.insertNextCell(NORM_TRI3,[0,1,2])
10859         d=DataArrayDouble(4,3) ; d[:]=0.
10860         m1.setCoords(d)
10861         self.assertTrue(m1.checkConsecutiveCellTypes())
10862         self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
10863         m1.renumberCells([1,0])
10864         self.assertTrue(m1.checkConsecutiveCellTypes())
10865         self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
10866         pass
10867
10868     def testSwig2DAAccumulate1(self):
10869         d=DataArrayInt(10) ; d.iota(0)
10870         self.assertEqual([45],d.accumulate())
10871         self.assertEqual(45,d.accumulate(0))
10872         d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
10873         self.assertEqual([135,145,155],d.accumulate())
10874         self.assertEqual(135,d.accumulate(0))
10875         self.assertEqual(145,d.accumulate(1))
10876         self.assertEqual(155,d.accumulate(2))
10877         d=DataArrayDouble(10) ; d.iota(0.)
10878         self.assertEqual([45.],d.accumulate())
10879         self.assertEqual(45.,d.accumulate(0))
10880         d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
10881         self.assertEqual([135.,145.,155.],d.accumulate())
10882         self.assertEqual(135.,d.accumulate(0))
10883         self.assertEqual(145.,d.accumulate(1))
10884         self.assertEqual(155.,d.accumulate(2))
10885         pass
10886
10887     def testSwig2UMeshDistanceToMesh1(self):
10888         m=MEDCouplingUMesh("toto",2)
10889         coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
10890         m.setCoords(coords)
10891         m.allocateCells(0)
10892         m.insertNextCell(NORM_TRI3,[0,1,2])
10893         a,b,c=m.distanceToPoint([-0.335,2.27,1.21])
10894         self.assertEqual(0,b) ; self.assertEqual(0,c)
10895         self.assertAlmostEqual(0.022360988100374124,a,14);
10896         a,b,c=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
10897         self.assertEqual(0,b) ; self.assertEqual(0,c)
10898         self.assertAlmostEqual(0.022360988100374124,a,14);
10899         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
10900         self.assertAlmostEqual(5.243302871282566,a,14)
10901         self.assertEqual(0,b)
10902         #
10903         m=MEDCouplingUMesh("toto",2)
10904         coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
10905         m.setCoords(coords)
10906         m.allocateCells(0)
10907         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
10908         m.checkCoherency2()
10909         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
10910         a,b,c=m.distanceToPoint([5.,2.,0.1])
10911         self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10912         a,b,c=m.distanceToPoint([5.,-2.,4.])
10913         self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10914         m.allocateCells(0)
10915         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
10916         m.checkCoherency2()
10917         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
10918         a,b,c=m.distanceToPoint([11.,3.,4.])
10919         self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10920         a,b,c=m.distanceToPoint([4.,12.,5.])
10921         self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b) ; self.assertEqual(2,c)
10922         d=DataArrayDouble([-1.2,3.,2.],1,3)
10923         for elt in d:
10924             a,b,c=m.distanceToPoint(d)
10925             self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b) ; self.assertEqual(0,c)
10926             pass
10927         #
10928         m=MEDCouplingUMesh("toto",1)
10929         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
10930         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
10931         a,b,c=m.distanceToPoint([-0.1,4.1])
10932         self.assertAlmostEqual(0.14142135623730925,a,14) ; self.assertEqual(-1,b) ; self.assertEqual(2,c)
10933         a,b,c=m.distanceToPoint([0.,3.9])
10934         self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) ; self.assertEqual(2,c)
10935         pass
10936
10937     def testSwig2NonRegressionPartitionBySpreadZone1(self):
10938         m=MEDCouplingCMesh()
10939         arr=DataArrayDouble(6) ; arr.iota(0.)
10940         m.setCoords(arr,arr,arr)
10941         m=m.buildUnstructured()
10942         mPart=m[50,80,85,87,92,122]
10943         zones=mPart.partitionBySpreadZone()
10944         self.assertEqual(4,len(zones))
10945         self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
10946         self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
10947         self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
10948         self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
10949         #
10950         n,ni=m.computeNeighborsOfCells()
10951         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
10952         self.assertEqual(13,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10953         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
10954         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10955         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
10956         self.assertEqual(11,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10957         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
10958         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10959         pass
10960
10961     def testSwigUMeshInsertNextCell1(self):
10962         m=MEDCouplingUMesh("toto",2)
10963         #
10964         coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
10965         da=DataArrayInt([0,1,2])
10966         m.allocateCells(0)
10967         for i in xrange(5):
10968             m.insertNextCell(NORM_TRI3,da)
10969             pass
10970         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])))
10971         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10972         #
10973         da=DataArrayInt([0,1,2,3])
10974         m.allocateCells(0)
10975         for i in xrange(5):
10976             m.insertNextCell(NORM_TRI3,3,da)
10977             pass
10978         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])))
10979         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10980         #
10981         da=DataArrayInt([0,1])
10982         m.allocateCells(0)
10983         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
10984         #
10985         da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
10986         m.allocateCells(0)
10987         for t in da:
10988             m.insertNextCell(NORM_TRI3,t)
10989             pass
10990         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])))
10991         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10992         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
10993         pass
10994
10995     def testSwigCurveLinearMesh1(self):
10996         m=MEDCouplingCurveLinearMesh("toto")
10997         m.setNodeGridStructure([2,3])
10998         coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
10999         m.setCoords(coords)
11000         m.checkCoherency()
11001         m0=m.deepCpy()
11002         self.assertTrue(m0.isEqual(m,1e-12))
11003         m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
11004         self.assertTrue(not m0.isEqual(m,1e-12))
11005         m0=m.deepCpy()
11006         self.assertTrue(m0.isEqual(m,1e-12))
11007         self.assertEqual(m.getNodeGridStructure(),(2,3))
11008         pass
11009
11010     def testSimplexize3(self):
11011         m=MEDCouplingUMesh("toto",3)
11012         m.allocateCells(0)
11013         m.insertNextCell(NORM_TETRA4,[0,1,2,3])
11014         m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
11015         m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
11016         m.insertNextCell(NORM_TETRA4,[20,21,22,23])
11017         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
11018         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.]
11019         c3=c2+[2.,0.,0.]
11020         c4=c1+[6.,0.,0.]
11021         c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
11022         m.setCoords(c)
11023         m.checkCoherency2()
11024         #
11025         m1=m.deepCpy()
11026         d1=m1.simplexize(PLANAR_FACE_5)
11027         m1.checkCoherency2()
11028         vol1=m1.getMeasureField(ON_CELLS).getArray()
11029         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))
11030         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])
11031         self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
11032         self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
11033         #
11034         m2=m.deepCpy()
11035         d2=m2.simplexize(PLANAR_FACE_6)
11036         m2.checkCoherency2()
11037         vol2=m2.getMeasureField(ON_CELLS).getArray()
11038         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))
11039         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])
11040         self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
11041         self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
11042         pass
11043
11044     def testSwig2CurveLinearMesh2(self):
11045         c=MEDCouplingCMesh()
11046         #2D
11047         arr1=DataArrayDouble([0,1,3,7])
11048         arr2=DataArrayDouble([0,1,1.5])
11049         c.setCoords(arr1,arr2)
11050         u=c.buildUnstructured()
11051         coo=u.getCoords()
11052         cl=MEDCouplingCurveLinearMesh()
11053         cl.setCoords(coo)
11054         cl.setNodeGridStructure([4,3])
11055         cl.checkCoherency2()
11056         li1=[1.,2.,4.,0.5,1.,2.]
11057         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11058         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11059         li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
11060         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11061         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11062         #3D
11063         c.setCoords(arr1,arr2,arr2)
11064         u=c.buildUnstructured()
11065         coo=u.getCoords()
11066         cl=MEDCouplingCurveLinearMesh()
11067         cl.setCoords(coo)
11068         cl.setNodeGridStructure([4,3,3])
11069         cl.checkCoherency2()
11070         li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
11071         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]
11072         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11073         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11074         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11075         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11076         #1D spaceDim 1
11077         coo=DataArrayDouble(5) ; coo.iota(0.)
11078         coo=coo*coo
11079         cl.setCoords(coo)
11080         cl.setNodeGridStructure([5])
11081         cl.checkCoherency2()
11082         li3=[1.,3.,5.,7.]
11083         li3_1=[0.5,2.5,6.5,12.5]
11084         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11085         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11086         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11087         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11088         #1D spaceDim 2
11089         coo=DataArrayDouble.Meld(coo,coo)
11090         cl.setCoords(coo)
11091         cl.checkCoherency2()
11092         li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
11093         li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
11094         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11095         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11096         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11097         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11098         pass
11099
11100     def testSwig2CurveLinearMeshNonRegression1(self):
11101         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)
11102         m=MEDCouplingCurveLinearMesh("toto")
11103         m.setCoords(coords)
11104         m.setNodeGridStructure([3,3,3])
11105         #
11106         vol=m.getMeasureField(False).getArray()
11107         self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
11108         self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
11109         #
11110         self.assertTrue(m.getBarycenterAndOwner().isEqual(m.buildUnstructured().getBarycenterAndOwner(),1e-12))
11111         pass
11112
11113     def testSwig2NonRegressionDASetSelectedComponents1(self):
11114         da=DataArrayDouble.New([1.,2.,3.,4.,5.,6.],3,2)
11115         dv=DataArrayDouble.New();
11116         dv.alloc(4,4)
11117         dv.fillWithZero()
11118         # da has less tuples than dv
11119         dv.setSelectedComponents(da,[1,0])
11120         #
11121         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))
11122         #
11123         da=DataArrayInt.New([1,2,3,4,5,6],3,2)
11124         dv=DataArrayInt.New();
11125         dv.alloc(4,4)
11126         dv.fillWithZero()
11127         # da has less tuples than dv
11128         dv.setSelectedComponents(da,[1,0])
11129         #
11130         self.assertTrue(dv.isEqual(DataArrayInt([2,1,0,0,4,3,0,0,6,5,0,0,0,0,0,0],4,4)))
11131         pass
11132
11133     def testSwigSetItem3(self):
11134         # 1-2
11135         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11136         d[3]=[1,2]
11137         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,1,2,0,0,0,0],6,2),1e-14))
11138         # 2-2 false
11139         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11140         d[[5,3,2]]=[1,2]
11141         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,1,2,1,2,0,0,1,2],6,2),1e-14))
11142         # 3-2 false
11143         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11144         d[:]=[1,2]
11145         self.assertTrue(d.isEqual(DataArrayDouble([1,2,1,2,1,2,1,2,1,2,1,2],6,2),1e-14))
11146         # 4-2 false
11147         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11148         d[DataArrayInt([0,3,4])]=[1,2]
11149         self.assertTrue(d.isEqual(DataArrayDouble([1,2,0,0,0,0,1,2,1,2,0,0],6,2),1e-14))
11150         # 5-2
11151         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11152         d[5,1]=[7]
11153         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,7],6,2),1e-14))
11154         # 6-2 false
11155         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11156         d[[3,5],1]=[7]
11157         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,7,0,0,0,7],6,2),1e-14))
11158         # 7-2 false
11159         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11160         d[:-1:2,1]=[7]
11161         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,7,0,0,0,7,0,0],6,2),1e-14))
11162         # 8-2 false
11163         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11164         d[DataArrayInt([0,3,4]),1]=[7]
11165         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,0,0,7,0,7,0,0],6,2),1e-14))
11166         # 9-2
11167         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11168         d[3,[1,0]]=[7,8]
11169         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,8,7,0,0,0,0],6,2),1e-14))
11170         # 10-2 false
11171         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11172         d[[1,3,4],[1,0]]=[7,8]
11173         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,8,7,0,0],6,2),1e-14))
11174         # 11-2 false
11175         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11176         d[1::2,[1,0]]=[7,8]
11177         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,0,0,8,7],6,2),1e-14))
11178         # 12-2 false
11179         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11180         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11181         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,0,0,8,7,0,0],6,2),1e-14))
11182         # 13-2
11183         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11184         d[1,:-1]=[9]
11185         self.assertTrue(d.isEqual(DataArrayDouble([0,0,9,0,0,0,0,0,0,0,0,0],6,2),1e-14))
11186         # 14-2 false
11187         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11188         d[[1,4,5],:]=[7,8]
11189         self.assertTrue(d.isEqual(DataArrayDouble([0,0,7,8,0,0,0,0,7,8,7,8],6,2),1e-14))
11190         # 15-2 false
11191         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11192         d[1::2,:]=[3,9]
11193         self.assertTrue(d.isEqual(DataArrayDouble([0,0,3,9,0,0,3,9,0,0,3,9],6,2),1e-14))
11194         # 1-2
11195         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11196         d[3]=[1,2]
11197         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,1,2,0,0,0,0],6,2)))
11198         # 2-2 false
11199         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11200         d[[5,3,2]]=[1,2]
11201         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,1,2,1,2,0,0,1,2],6,2)))
11202         # 3-2 false
11203         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11204         d[:]=[1,2]
11205         self.assertTrue(d.isEqual(DataArrayInt([1,2,1,2,1,2,1,2,1,2,1,2],6,2)))
11206         # 4-2 false
11207         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11208         d[DataArrayInt([0,3,4])]=[1,2]
11209         self.assertTrue(d.isEqual(DataArrayInt([1,2,0,0,0,0,1,2,1,2,0,0],6,2)))
11210         # 5-2
11211         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11212         d[5,1]=[7]
11213         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,7],6,2)))
11214         # 6-2 false
11215         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11216         d[[3,5],1]=[7]
11217         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,7,0,0,0,7],6,2)))
11218         # 7-2 false
11219         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11220         d[:-1:2,1]=[7]
11221         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,7,0,0,0,7,0,0],6,2)))
11222         # 8-2 false
11223         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11224         d[DataArrayInt([0,3,4]),1]=[7]
11225         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,0,0,7,0,7,0,0],6,2)))
11226         # 9-2
11227         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11228         d[3,[1,0]]=[7,8]
11229         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,8,7,0,0,0,0],6,2)))
11230         # 10-2 false
11231         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11232         d[[1,3,4],[1,0]]=[7,8]
11233         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,8,7,0,0],6,2)))
11234         # 11-2 false
11235         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11236         d[1::2,[1,0]]=[7,8]
11237         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,0,0,8,7],6,2)))
11238         # 12-2 false
11239         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11240         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11241         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,0,0,8,7,0,0],6,2)))
11242         # 13-2
11243         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11244         d[1,:-1]=[9]
11245         self.assertTrue(d.isEqual(DataArrayInt([0,0,9,0,0,0,0,0,0,0,0,0],6,2)))
11246         # 14-2 false
11247         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11248         d[[1,4,5],:]=[7,8]
11249         self.assertTrue(d.isEqual(DataArrayInt([0,0,7,8,0,0,0,0,7,8,7,8],6,2)))
11250         # 15-2 false
11251         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11252         d[1::2,:]=[3,9]
11253         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,9,0,0,3,9,0,0,3,9],6,2)))
11254         pass
11255
11256     def testSwig2ConvertLinearCellsToQuadratic1(self):
11257         coordsExp=DataArrayDouble([-0.3,-0.3,0.2,-0.3,0.7,-0.3,-0.3,0.2,0.2,0.2,0.7,0.2,-0.3,0.7,0.2,0.7,0.7,0.7,-0.3,-0.05,-0.05,0.2,0.2,-0.05,-0.05,-0.3,0.45,-0.05,0.45,-0.3,0.45,0.2,0.7,-0.05,-0.05,0.7,0.2,0.45,-0.3,0.45,0.45,0.7,0.7,0.45],22,2)
11258         # 2D
11259         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11260         m2D.convertLinearCellsToQuadratic(0)
11261         m2D.checkCoherency1()
11262         self.assertEqual(m2D.getNodalConnectivity().getValues(),[8,0,3,4,1,9,10,11,12,6,1,4,2,11,13,14,6,4,5,2,15,16,13,8,6,7,4,3,17,18,10,19,8,7,8,5,4,20,21,15,18])
11263         self.assertEqual(m2D.getNodalConnectivityIndex().getValues(),[0,9,16,23,32,41])
11264         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11265         # 1D
11266         m1D=MEDCouplingDataForTest.build2DTargetMesh_1().buildDescendingConnectivity()[0]
11267         m1D.convertLinearCellsToQuadratic(0)
11268         m1D.checkCoherency1()
11269         self.assertEqual(m1D.getNodalConnectivity().getValues(),[2,0,3,9,2,3,4,10,2,4,1,11,2,1,0,12,2,4,2,13,2,2,1,14,2,4,5,15,2,5,2,16,2,6,7,17,2,7,4,18,2,3,6,19,2,7,8,20,2,8,5,21])
11270         self.assertEqual(m1D.getNodalConnectivityIndex().getValues(),[0,4,8,12,16,20,24,28,32,36,40,44,48,52])
11271         self.assertTrue(m1D.getCoords().isEqual(coordsExp,1e-14))
11272         # 3D
11273         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11274         m2D.changeSpaceDimension(3)
11275         arr=DataArrayDouble(4);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11276         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11277         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11278         cooTmp=m2D.getCoords()[:]
11279         m3D=m2D.buildExtrudedMesh(m1D,0)
11280         m3D.convertLinearCellsToQuadratic(0)
11281         m3D.checkCoherency1()
11282         # check of new m3D content
11283         coordsExp2=[coordsExp.changeNbOfComponents(3,i) for i in xrange(4)]
11284         coordsExp3=[DataArrayDouble.Meld(cooTmp[:,[0,1]],cooTmp[:,2]+(0.5+float(i))) for i in xrange(3)]
11285         coordsExp4=DataArrayDouble.Aggregate([coordsExp2[0],coordsExp3[0],coordsExp2[1],coordsExp3[1],coordsExp2[2],coordsExp3[2],coordsExp2[3]])
11286         c=DataArrayDouble.Aggregate(m3D.getCoords(),coordsExp4)
11287         self.assertEqual(len(coordsExp4),115)
11288         self.assertEqual(len(m3D.getCoords()),115)
11289         a,b=c.findCommonTuples(1e-14)
11290         self.assertEqual(len(b),len(coordsExp4)+1)
11291         e,f=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(2*115,a,b)
11292         self.assertEqual(f,115)
11293         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,0,1,2,3,4,5,6,7,8,36,37,38,39,48,49,53,54,58,59,60,66,67,44,47,52,45,46,57,64,65,70,9,10,11,12,13,14,15,16,17,40,41,42,43,50,51,55,56,61,62,63,68,69,75,78,81,76,77,84,88,89,92,18,19,20,21,22,23,24,25,26,71,72,73,74,79,80,82,83,85,86,87,90,91,97,100,103,98,99,106,110,111,114,27,28,29,30,31,32,33,34,35,93,94,95,96,101,102,104,105,107,108,109,112,113])))
11294         self.assertTrue(DataArrayInt([30,0,3,4,1,9,12,13,10,36,37,38,39,40,41,42,43,44,45,46,47,25,1,4,2,10,13,11,38,48,49,42,50,51,47,46,52,25,4,5,2,13,14,11,53,54,48,55,56,50,46,57,52,30,6,7,4,3,15,16,13,12,58,59,37,60,61,62,41,63,64,65,46,45,30,7,8,5,4,16,17,14,13,66,67,53,59,68,69,55,62,65,70,57,46,30,9,12,13,10,18,21,22,19,40,41,42,43,71,72,73,74,75,76,77,78,25,10,13,11,19,22,20,42,50,51,73,79,80,78,77,81,25,13,14,11,22,23,20,55,56,50,82,83,79,77,84,81,30,15,16,13,12,24,25,22,21,61,62,41,63,85,86,72,87,88,89,77,76,30,16,17,14,13,25,26,23,22,68,69,55,62,90,91,82,86,89,92,84,77,30,18,21,22,19,27,30,31,28,71,72,73,74,93,94,95,96,97,98,99,100,25,19,22,20,28,31,29,73,79,80,95,101,102,100,99,103,25,22,23,20,31,32,29,82,83,79,104,105,101,99,106,103,30,24,25,22,21,33,34,31,30,85,86,72,87,107,108,94,109,110,111,99,98,30,25,26,23,22,34,35,32,31,90,91,82,86,112,113,104,108,111,114,106,99]).isEqual(m3D.getNodalConnectivity()))
11295         self.assertTrue(DataArrayInt([0,21,37,53,74,95,116,132,148,169,190,211,227,243,264,285]).isEqual(m3D.getNodalConnectivityIndex()))
11296         # testing explode3DMeshTo1D
11297         m3DSlice0=m3D[:5]
11298         m3DSlice0.zipCoords()
11299         a,b,c,d,e=m3DSlice0.explode3DMeshTo1D()
11300         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,2,12,13,6,14,15,11,10,16,17,18,12,19,20,14,10,21,16,22,23,1,24,25,26,5,27,28,29,10,9,30,31,17,23,32,33,19,26,29,34,21,10])))
11301         self.assertTrue(c.isEqual(DataArrayInt([0,12,21,30,42,54])))
11302         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,0,1,0,0,0,3,0,1,0,0,0,3,0,1,2,3,4,0,1,1,2,1,1,2,1,1,2,2,4,2,2,4,2,2,4,3,3,4,3,3,3,4,3,3,3,4,4,4,4,4,4])))
11303         self.assertTrue(e.isEqual(DataArrayInt([0,1,3,5,6,7,9,11,12,13,15,20,22,24,25,27,28,30,32,33,35,36,38,39,41,42,43,45,46,47,49,50,51,52,53,54])))
11304         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([2,0,3,18,2,3,4,19,2,4,1,20,2,1,0,21,2,9,12,22,2,12,13,23,2,13,10,24,2,10,9,25,2,0,9,26,2,3,12,27,2,4,13,28,2,1,10,29,2,4,2,30,2,2,1,31,2,13,11,32,2,11,10,33,2,2,11,34,2,4,5,35,2,5,2,36,2,13,14,37,2,14,11,38,2,5,14,39,2,6,7,40,2,7,4,41,2,3,6,42,2,15,16,43,2,16,13,44,2,12,15,45,2,6,15,46,2,7,16,47,2,7,8,48,2,8,5,49,2,16,17,50,2,17,14,51,2,8,17,52])))
11305         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,84,88,92,96,100,104,108,112,116,120,124,128,132,136,140])))
11306         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([-0.3,-0.3,0.0,0.2,-0.3,0.0,0.7,-0.3,0.0,-0.3,0.2,0.0,0.2,0.2,0.0,0.7,0.2,0.0,-0.3,0.7,0.0,0.2,0.7,0.0,0.7,0.7,0.0,-0.3,-0.3,1.0,0.2,-0.3,1.0,0.7,-0.3,1.0,-0.3,0.2,1.0,0.2,0.2,1.0,0.7,0.2,1.0,-0.3,0.7,1.0,0.2,0.7,1.0,0.7,0.7,1.0,-0.3,-0.05,0.0,-0.05,0.2,0.0,0.2,-0.05,0.0,-0.05,-0.3,0.0,-0.3,-0.05,1.0,-0.05,0.2,1.0,0.2,-0.05,1.0,-0.05,-0.3,1.0,-0.3,-0.3,0.5,-0.3,0.2,0.5,0.2,0.2,0.5,0.2,-0.3,0.5,0.45,-0.05,0.0,0.45,-0.3,0.0,0.45,-0.05,1.0,0.45,-0.3,1.0,0.7,-0.3,0.5,0.45,0.2,0.0,0.7,-0.05,0.0,0.45,0.2,1.0,0.7,-0.05,1.0,0.7,0.2,0.5,-0.05,0.7,0.0,0.2,0.45,0.0,-0.3,0.45,0.0,-0.05,0.7,1.0,0.2,0.45,1.0,-0.3,0.45,1.0,-0.3,0.7,0.5,0.2,0.7,0.5,0.45,0.7,0.0,0.7,0.45,0.0,0.45,0.7,1.0,0.7,0.45,1.0,0.7,0.7,0.5],53,3),1e-14))
11307         pass
11308
11309     def testSwig2DataArrayPushBackValsSilent1(self):
11310         d=DataArrayDouble()
11311         d.pushBackValsSilent([4,5,6])
11312         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.]),1e-14))
11313         e=DataArrayDouble([1,2,3],1,3)
11314         for t in e: d.pushBackValsSilent(t)
11315         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.]),1e-14))
11316         d.pushBackValsSilent(DataArrayDouble([9,10.]))
11317         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11318         d.pushBackValsSilent(DataArrayDouble(0,1))
11319         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11320         e=DataArrayDouble([1,2,3],3,1)
11321         for t in e: d.pushBackValsSilent(t)
11322         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.]),1e-14))
11323         d.pushBackValsSilent(77)
11324         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.,77.]),1e-14))
11325         #
11326         d=DataArrayInt()
11327         d.pushBackValsSilent([4,5,6])
11328         self.assertTrue(d.isEqual(DataArrayInt([4,5,6])))
11329         e=DataArrayInt([1,2,3],1,3)
11330         for t in e: d.pushBackValsSilent(t)
11331         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3])))
11332         d.pushBackValsSilent(DataArrayInt([9,10]))
11333         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11334         d.pushBackValsSilent(DataArrayInt(0,1))
11335         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11336         e=DataArrayInt([1,2,3],3,1)
11337         for t in e: d.pushBackValsSilent(t)
11338         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3])))
11339         d.pushBackValsSilent(77)
11340         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3,77])))
11341         pass
11342
11343     def testSwig2ConvertLinearCellsToQuadratic2(self):
11344         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11345         ret=m2D.convertLinearCellsToQuadratic(1)
11346         self.assertTrue(ret.isIdentity())
11347         self.assertEqual(5,len(ret))
11348         m2D.checkCoherency1()
11349         coordsExp=DataArrayDouble([-0.3,-0.3,0.2,-0.3,0.7,-0.3,-0.3,0.2,0.2,0.2,0.7,0.2,-0.3,0.7,0.2,0.7,0.7,0.7,-0.3,-0.05,-0.05,0.2,0.2,-0.05,-0.05,-0.3,0.45,-0.05,0.45,-0.3,0.45,0.2,0.7,-0.05,-0.05,0.7,0.2,0.45,-0.3,0.45,0.45,0.7,0.7,0.45,-0.05,-0.05,0.3666666666666667,-0.1333333333333333,0.5333333333333332,0.03333333333333334,-0.05,0.45,0.45,0.45],27,2)
11350         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11351         self.assertTrue(m2D.getNodalConnectivity().isEqual(DataArrayInt([9,0,3,4,1,9,10,11,12,22,7,1,4,2,11,13,14,23,7,4,5,2,15,16,13,24,9,6,7,4,3,17,18,10,19,25,9,7,8,5,4,20,21,15,18,26])))
11352         self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,10,18,26,36,46])))
11353         #
11354         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()[(0,3)] ; m2D.zipCoords()
11355         m2D.changeSpaceDimension(3)
11356         arr=DataArrayDouble(3);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11357         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11358         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11359         cooTmp=m2D.getCoords()[:]
11360         m3D=m2D.buildExtrudedMesh(m1D,0)
11361         ret=m3D.convertLinearCellsToQuadratic(1)
11362         self.assertTrue(ret.isIdentity())
11363         self.assertEqual(4,len(ret))
11364         m3D.checkCoherency1()
11365         coordsExp2=DataArrayDouble([-0.3,-0.3,0.0,0.2,-0.3,0.0,-0.3,0.2,0.0,0.2,0.2,0.0,-0.3,0.7,0.0,0.2,0.7,0.0,-0.3,-0.3,1.0,0.2,-0.3,1.0,-0.3,0.2,1.0,0.2,0.2,1.0,-0.3,0.7,1.0,0.2,0.7,1.0,-0.3,-0.3,2.0,0.2,-0.3,2.0,-0.3,0.2,2.0,0.2,0.2,2.0,-0.3,0.7,2.0,0.2,0.7,2.0,-0.3,-0.05,0.0,-0.05,0.2,0.0,0.2,-0.05,0.0,-0.05,-0.3,0.0,-0.3,-0.05,1.0,-0.05,0.2,1.0,0.2,-0.05,1.0,-0.05,-0.3,1.0,-0.3,-0.3,0.5,-0.3,0.2,0.5,0.2,0.2,0.5,0.2,-0.3,0.5,-0.05,0.7,0.0,0.2,0.45,0.0,-0.3,0.45,0.0,-0.05,0.7,1.0,0.2,0.45,1.0,-0.3,0.45,1.0,-0.3,0.7,0.5,0.2,0.7,0.5,-0.3,-0.05,2.0,-0.05,0.2,2.0,0.2,-0.05,2.0,-0.05,-0.3,2.0,-0.3,-0.3,1.5,-0.3,0.2,1.5,0.2,0.2,1.5,0.2,-0.3,1.5,-0.05,0.7,2.0,0.2,0.45,2.0,-0.3,0.45,2.0,-0.3,0.7,1.5,0.2,0.7,1.5,-0.05,-0.05,0.0,-0.3,-0.05,0.5,-0.05,0.2,0.5,0.2,-0.05,0.5,-0.05,-0.3,0.5,-0.05,-0.05,1.0,-0.05,0.45,0.0,-0.05,0.7,0.5,0.2,0.45,0.5,-0.3,0.45,0.5,-0.05,0.45,1.0,-0.3,-0.05,1.5,-0.05,0.2,1.5,0.2,-0.05,1.5,-0.05,-0.3,1.5,-0.05,-0.05,2.0,-0.05,0.7,1.5,0.2,0.45,1.5,-0.3,0.45,1.5,-0.05,0.45,2.0,-0.05,-0.05,0.5,-0.05,0.45,0.5,-0.05,-0.05,1.5,-0.05,0.45,1.5],75,3)
11366         self.assertTrue(m3D.getCoords().isEqual(coordsExp2,1e-14))
11367         self.assertTrue(m3D.getNodalConnectivity().isEqual(DataArrayInt([27,0,2,3,1,6,8,9,7,18,19,20,21,22,23,24,25,26,27,28,29,51,52,53,54,55,56,71,27,4,5,3,2,10,11,9,8,30,31,19,32,33,34,23,35,36,37,28,27,57,58,59,53,60,61,72,27,6,8,9,7,12,14,15,13,22,23,24,25,38,39,40,41,42,43,44,45,56,62,63,64,65,66,73,27,10,11,9,8,16,17,15,14,33,34,23,35,46,47,39,48,49,50,44,43,61,67,68,63,69,70,74])))
11368         self.assertTrue(m3D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,28,56,84,112])))
11369         pass
11370
11371     def testSwig2GaussNEIntegral1(self):
11372         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11373         m0=m2D[0] ; m0.zipCoords()
11374         m1=m2D[[1,2]] ; m1.zipCoords()
11375         m2=m2D[[3,4]] ; m2.zipCoords()
11376         m0.convertLinearCellsToQuadratic(1)
11377         m1.convertLinearCellsToQuadratic(0)
11378         m2.convertLinearCellsToQuadratic(1)
11379         m=MEDCouplingUMesh.MergeUMeshes([m0,m1,m2])
11380         m.mergeNodes(1e-12)
11381         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11382         f.setMesh(m)
11383         arr=DataArrayDouble([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,
11384                              11.1,12.2,13.3,14.4,15.5,16.6,
11385                              21.1,22.2,23.3,24.4,25.5,26.6,
11386                              31.1,32.2,33.3,34.4,35.5,36.6,37.7,38.8,39.9,
11387                              41.1,42.2,43.3,44.4,45.5,46.6,47.7,48.8,49.9])
11388         arr2=DataArrayDouble(len(arr),2)
11389         arr2[:,0]=arr ; arr2[:,1]=arr+100
11390         f.setArray(arr2)
11391         f.checkCoherency()
11392         res=f.integral(False)
11393         # a=25./81 ; b=40./81 ; c=64./81
11394         # p1=0.11169079483905 ; p2=0.0549758718227661
11395         # 1st compo
11396         # c0=(a*(1.1+2.2+3.3+4.4)+b*(5.5+6.6+7.7+8.8)+c*9.9)*0.25/3.9999999999999978 ; c0=1.5837962962962973
11397         # c1=(p2*(11.1+12.2+13.3)+p1*(14.4+15.5+16.6))*0.125/0.4999999999854482 ; c1=1.8014347172346943
11398         # c2=(p2*(21.1+22.2+23.3)+p1*(24.4+25.5+26.6))*0.125/0.4999999999854482 ; c2=3.0514347172346943
11399         # c3=(a*(31.1+32.2+33.3+34.4)+b*(35.5+36.6+37.7+38.8)+c*39.9)*0.25/3.9999999999999978 ; c3=9.0837962962963
11400         # c4=(a*(41.1+42.2+43.3+44.4)+b*(45.5+46.6+47.7+48.8)+c*49.9)*0.25/3.9999999999999978 ; c4=11.583796296296303
11401         # c0+c1+c2+c3+c4=27.104258323358287
11402         integExp0=27.104258323358287
11403         self.assertAlmostEqual(res[0],integExp0,13)
11404         # 2nd compo
11405         # c0=(a*(101.1+102.2+103.3+104.4)+b*(105.5+106.6+107.7+108.8)+c*109.9)*0.25/3.9999999999999978 ; c0=26.58379629629631
11406         # c1=(p2*(111.1+112.2+113.3)+p1*(114.4+115.5+116.6))*0.125/0.4999999999854482 ; c1=14.301434717234699
11407         # c2=(p2*(121.1+122.2+123.3)+p1*(124.4+125.5+126.6))*0.125/0.4999999999854482 ; c2=15.5514347172347
11408         # c3=(a*(131.1+132.2+133.3+134.4)+b*(135.5+136.6+137.7+138.8)+c*139.9)*0.25/3.9999999999999978 ; c3=34.08379629629631
11409         # c4=(a*(141.1+142.2+143.3+144.4)+b*(145.5+146.6+147.7+148.8)+c*149.9)*0.25/3.9999999999999978 ; c4=36.58379629629632
11410         # c0+c1+c2+c3+c4=127.10425832335835
11411         integExp1=127.10425832335835
11412         self.assertAlmostEqual(res[1],integExp1,12)
11413         meas=f.getDiscretization().getMeasureField(f.getMesh(),False)
11414         intPerTuple=meas*f
11415         res2=intPerTuple.accumulate()
11416         self.assertAlmostEqual(res2[0],integExp0,13)
11417         self.assertAlmostEqual(res2[1],integExp1,12)
11418         #
11419         meas2=f.buildMeasureField(False)
11420         intPerTuple=meas2*f
11421         res3=intPerTuple.accumulate()
11422         self.assertAlmostEqual(res3[0],integExp0,13)
11423         self.assertAlmostEqual(res3[1],integExp1,12)
11424         #
11425         res4=f.getWeightedAverageValue(False) # res4==res2 because sum of area of mesh is equal to 1
11426         self.assertAlmostEqual(res4[0],integExp0,13)
11427         self.assertAlmostEqual(res4[1],integExp1,12)
11428         #
11429         m.scale([0,0],2.)
11430         #
11431         res5=f.getWeightedAverageValue() # res4==res4 because weighted average is not sensitive to the scaling
11432         self.assertAlmostEqual(res5[0],integExp0,13)
11433         self.assertAlmostEqual(res5[1],integExp1,12)
11434         meas3=f.buildMeasureField(False)
11435         delta=4*meas2.getArray()-meas3.getArray()
11436         delta.abs()
11437         self.assertTrue(delta.isUniform(0.,1e-16))
11438         res6=f.integral(False)
11439         self.assertAlmostEqual(res6[0],4.*integExp0,12)
11440         self.assertAlmostEqual(res6[1],4.*integExp1,11)
11441         pass
11442
11443     def testSwig2SlowDADFindClosestTupleId(self):
11444         nbPts=[10,]
11445         for nbPt in nbPts:
11446             d=DataArrayDouble(nbPt) ; d.iota() ; d*=1./(nbPt-1)
11447             c=MEDCouplingCMesh() ; c.setCoords(d,d) ; m=c.buildUnstructured() ; pts=m.getCoords() ; del m
11448             #
11449             d0=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d0.iota() ; d0*=(3./((nbPt-1)*(nbPt-1))) ; d0=d0.applyFunc("exp(x)-1")
11450             d1=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d1.iota()
11451             d2=DataArrayDouble.Meld(d0,d1) ; d2=d2.fromPolarToCart() ; d2+=[0.32,0.73]
11452             ids=pts.findClosestTupleId(d2)
11453             #print "Start of costly computation"
11454             idsExpected=DataArrayInt(len(d2))
11455             tmp=1e300
11456             for i,elt in enumerate(d2):
11457                 l,m=(pts-elt).magnitude().getMinValue()
11458                 idsExpected.setIJSilent(i,0,m)
11459                 if l<tmp:
11460                     tmp=l ; tmp1=m ; tmp2=i
11461                     pass
11462                 pass
11463             #print "End of costly computation"
11464             self.assertTrue(idsExpected.isEqual(ids))
11465             a,b,c=pts.minimalDistanceTo(d2)
11466             self.assertEqual(tmp,a)
11467             self.assertEqual(tmp1,b)
11468             self.assertEqual(tmp2,c)
11469             #
11470             l=[d2[:,i] for i in [0,1]]
11471             for elt in l: elt.reverse()
11472             d2i=DataArrayDouble.Meld(l)
11473             ids1=pts.findClosestTupleId(d2i)
11474             idsExpectedI=idsExpected.deepCpy() ; idsExpectedI.reverse()
11475             self.assertTrue(idsExpectedI.isEqual(ids1))
11476             #
11477             l=[pts[:,i] for i in [0,1]]
11478             for elt in l: elt.reverse()
11479             ptsi=DataArrayDouble.Meld(l)
11480             ids2=ptsi.findClosestTupleId(d2)
11481             idsExpected2=nbPt*nbPt-1-ids
11482             self.assertTrue(idsExpected2.isEqual(ids2))
11483             #
11484             ids3=ptsi.findClosestTupleId(d2i)
11485             idsExpected3=idsExpected2.deepCpy() ; idsExpected3.reverse()
11486             self.assertTrue(idsExpected3.isEqual(ids3))
11487             pass
11488
11489     def testSwig2DataArrayAsciiChar1(self):
11490         alpha=DataArrayInt(26) ; alpha.iota(ord("A"))
11491         d=DataArrayAsciiChar(alpha.getValues(),2,13)
11492         d.setInfoOnComponents(["c%i"%(v) for v in xrange(13)])
11493         self.assertEqual('ABCDEFGHIJKLM',d.getTuple(0))
11494         self.assertEqual('NOPQRSTUVWXYZ',d.getTuple(1))
11495         self.assertEqual(2,d.getNumberOfTuples())
11496         self.assertEqual(26,d.getNbOfElems())
11497         self.assertEqual(13,d.getNumberOfComponents())
11498         dd=d.deepCpy()
11499         self.assertTrue(d.isEqual(dd))
11500         dd.setIJ(0,3,'d')
11501         self.assertTrue(not d.isEqual(dd))
11502         d.setIJ(0,3,ord('d'))
11503         self.assertTrue(d.isEqual(dd))
11504         d.rearrange(1)
11505         d.reserve(20)
11506         self.assertEqual(20,d.getNumberOfTuples())
11507         self.assertEqual(20,d.getNbOfElems())
11508         self.assertEqual(1,d.getNumberOfComponents())
11509         #
11510         d0=DataArrayAsciiChar([ord('a')],1,1)
11511         self.assertEqual('a',d0.asciiCharValue())
11512         self.assertTrue(not d0.empty())
11513         d0=DataArrayAsciiChar(0,3)
11514         self.assertTrue(d0.empty())
11515         d.pushBackSilent("U") ; d.pushBackSilent("V") ; d.pushBackSilent("W")
11516         self.assertEqual("W",d.popBackSilent())
11517         d.rearrange(2)
11518         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV'],d.toStrList())
11519         d.fillWithZero()
11520         self.assertEqual(11*[''],d.toStrList())
11521         d.fillWithValue('T')
11522         self.assertEqual(11*["TT"],d.toStrList())
11523         d.rearrange(1)
11524         self.assertTrue(d.isUniform("T"))
11525         d.rearrange(2)
11526         #
11527         dd.rearrange(2)
11528         dd2=dd.deepCpy()
11529         dd.renumberInPlace([3,1,2,4,0,11,10,9,8,7,5,12,6])
11530         self.assertEqual(dd.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11531         dd.renumberInPlaceR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11532         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV','WX','YZ'],dd.toStrList())
11533         e=dd.renumber([3,1,2,4,0,11,10,9,8,7,5,12,6])
11534         self.assertEqual(e.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11535         e=dd.renumberR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11536         self.assertEqual(e.toStrList(),['GH','Cd','EF','IJ','AB','WX','UV','ST','QR','OP','KL','YZ','MN'])
11537         e=dd.renumberAndReduce([1,1,1,1,1,1,1,2,0,0,0,0,0],3)
11538         self.assertEqual(['YZ','MN','OP'],e.toStrList())
11539         self.assertEqual(['GH','IJ'],dd.selectByTupleIdSafe([3,4]).toStrList())
11540         self.assertEqual(['AB','GH','MN','ST','YZ'],dd.selectByTupleId2(0,13,3).toStrList())
11541         dd3=dd.changeNbOfComponents(3,"G")
11542         self.assertEqual(['ABG','CdG','EFG','GHG','IJG','KLG','MNG','OPG','QRG','STG','UVG','WXG','YZG'],dd3.toStrList())
11543         dd3.rearrange(1) ; self.assertEqual("G",dd3.back()) ; dd3.rearrange(3)
11544         self.assertTrue(dd3.changeNbOfComponents(2,"\0").isEqual(dd))
11545         self.assertEqual(len(dd),13)
11546         d=DataArrayAsciiChar(13,2) ; d.fillWithValue('Y')
11547         dd3.meldWith(d)
11548         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','KLGYY','MNGYY','OPGYY','QRGYY','STGYY','UVGYY','WXGYY','YZGYY'],dd3.toStrList())
11549         self.assertEqual("d",dd3.getIJ(0,6))
11550         self.assertRaises(InterpKernelException,dd3.getIJSafe,0,6)
11551         self.assertEqual("d",dd3.getIJSafe(1,1))
11552         dd3.rearrange(1)
11553         e=dd3.getIdsEqual("Y")
11554         self.assertTrue(e.isEqual(DataArrayInt([3,4,8,9,13,14,18,19,23,24,28,29,33,34,38,39,43,44,48,49,53,54,58,59,60,63,64])))
11555         e=dd3.getIdsNotEqual("Y")
11556         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,5,6,7,10,11,12,15,16,17,20,21,22,25,26,27,30,31,32,35,36,37,40,41,42,45,46,47,50,51,52,55,56,57,61,62])))
11557         self.assertEqual(("d",6),dd3.getMaxValue())
11558         self.assertEqual(("A",0),dd3.getMinValue())
11559         self.assertEqual(26,dd3.search("LGYYM"))
11560         self.assertEqual(-1,dd3.search("LGYYN"))
11561         dd3.rearrange(5)
11562         self.assertEqual(7,dd3.locateTuple("OPGYY"))
11563         self.assertTrue("OPGYY" in dd3)
11564         self.assertEqual(7,dd3.index("OPGYY"))
11565         self.assertEqual(-1,dd3.locateTuple("OPGYP"))
11566         dd3.rearrange(1)
11567         self.assertEqual(2,dd3.locateValue("OPGYY"))
11568         self.assertTrue(dd3.presenceOfValue("OPGYY"))
11569         self.assertTrue("O" in dd3)
11570         self.assertTrue(not dd3.presenceOfValue("z"))
11571         self.assertTrue("z" not in dd3)
11572         dd3.rearrange(5)
11573         l=list(dd3)
11574         self.assertEqual([e.buildDAAsciiChar().toStrList()[0] for e in list(dd3)],dd3.toStrList())
11575         dd3.reAlloc(5)
11576         dd4=DataArrayChar.Aggregate(dd3,dd3)
11577         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd4.toStrList())
11578         dd5=DataArrayChar.Aggregate([dd4,dd3,dd4])
11579         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd5.toStrList())
11580         # getitem,__iter__,__setitem__
11581         a=list(dd3)
11582         self.assertEqual("ABGYY",str(a[0]))
11583         dd4=dd3[::2]
11584         self.assertEqual(['ABGYY','EFGYY','IJGYY'],dd4.toStrList())
11585         dd4=dd3[(3,2,1)]
11586         self.assertEqual(['GHGYY','EFGYY','CdGYY'],dd4.toStrList())
11587         dd4=dd3[:]
11588         dd4[::2]=["12","345","67890"]
11589         self.assertEqual(['12   ','CdGYY','345  ','GHGYY','67890'],dd4.toStrList())
11590         dd4=dd3[:]
11591         dd4[[1,2]]=" "
11592         self.assertEqual(['ABGYY','     ','     ','GHGYY','IJGYY'],dd4.toStrList())
11593         dd4=dd3[:]
11594         dd4[4]='12345'
11595         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11596         dd4[0]=dd4[1]
11597         self.assertEqual(['CdGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11598         dd4=DataArrayAsciiChar(["abc","de","fghi"])
11599         self.assertEqual(['abc ','de  ','fghi'],dd4.toStrList())
11600         dd4=DataArrayAsciiChar(["abc","de","fghi"],"t")
11601         self.assertEqual(['abct','dett','fghi'],dd4.toStrList())
11602         pass
11603
11604     def testSwig2GaussNELocalizationOfDiscValues(self):
11605         m=MEDCouplingDataForTest.build2DTargetMesh_3()[[0,1,3,4,5,6,8,9]] # suppression of polygons
11606         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11607         f.setMesh(m)
11608         loc=f.getLocalizationOfDiscr()
11609         self.assertEqual(42,len(loc))
11610         self.assertTrue(loc.isEqual(DataArrayDouble([0.,0.,1.,0.,0.5,1.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,1.,0.,0.5,1.,0.5,0.,0.75,0.5,0.25,0.5,0.,0.,1.,0.,1.,1.,0.,1.,0.5,0.,1.,0.5,0.5,1.,0.,0.5,0.,0.,0.5,1.,1.,0.,0.,0.,0.,1.,1.,1.,1.,0.,0.,0.,0.5,1.,1.,0.,0.25,0.5,0.75,0.5,0.5,0.,0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],42,2),1e-13))
11611         m.changeSpaceDimension(3)
11612         m.getCoords()[:,2]=7.
11613         loc=f.getLocalizationOfDiscr()
11614         self.assertEqual(42,len(loc))
11615         self.assertTrue(loc.isEqual(DataArrayDouble([0.,0.,7.,1.,0.,7.,0.5,1.,7.,0.,0.,7.,1.,0.,7.,1.,1.,7.,0.,1.,7.,0.,0.,7.,1.,0.,7.,0.5,1.,7.,0.5,0.,7.,0.75,0.5,7.,0.25,0.5,7.,0.,0.,7.,1.,0.,7.,1.,1.,7.,0.,1.,7.,0.5,0.,7.,1.,0.5,7.,0.5,1.,7.,0.,0.5,7.,0.,0.,7.,0.5,1.,7.,1.,0.,7.,0.,0.,7.,0.,1.,7.,1.,1.,7.,1.,0.,7.,0.,0.,7.,0.5,1.,7.,1.,0.,7.,0.25,0.5,7.,0.75,0.5,7.,0.5,0.,7.,0.,0.,7.,0.,1.,7.,1.,1.,7.,1.,0.,7.,0.,0.5,7.,0.5,1.,7.,1.,0.5,7.,0.5,0.,7.],42,3),1e-13))
11616         pass
11617
11618     def testSwig2GaussMeasureAndIntegral(self):
11619         ft=MEDCouplingDataForTest.buildFieldOnGauss_1()
11620         mea=ft.buildMeasureField(False)
11621         mea.checkCoherency()
11622         self.assertTrue(mea.getArray().isEqual(DataArrayDouble([-0.08504076274779823,-0.06378057206084897,-0.08504076274779869,-0.10630095343474463,-0.12756114412169625,-0.10630095343474734,-0.0637805720608491,-0.0850407627477968,-0.1063009534347449,-0.0850407627477994,-0.10630095343474809,-0.1275611441216954,-0.037205333702161475,-0.037205333702161475,-0.037205333702161475,-0.037205333702161475,-0.047835429045636084,-0.047835429045636084,-0.047835429045636084,-0.047835429045636084,-0.05846552438911087,-0.05846552438911087,-0.05846552438911087,-0.05846552438911087,-0.037205333702161725,-0.037205333702161725,-0.037205333702161725,-0.037205333702161725,-0.047835429045635834,-0.047835429045635834,-0.047835429045635834,-0.047835429045635834,-0.05846552438911058,-0.05846552438911058,-0.05846552438911058,-0.05846552438911058,-0.03879154890291829,-0.03879154890291829,-0.03879154890291829,-0.04120270848015563,-0.04120270848015563,-0.04120270848015563,-0.03393028948486933,-0.03393028948486933,-0.03393028948486933,-0.03151955746491709,-0.03151955746491709,-0.03151955746491709,-0.02424752187358276,-0.02424752187358276,-0.02424752187358276,-0.026657914642918758,-0.026657914642918758,-0.026657914642918758,-0.04120270848015456,-0.04120270848015456,-0.04120270848015456,-0.03879154890291757,-0.03879154890291757,-0.03879154890291757,-0.031519557464916595,-0.031519557464916595,-0.031519557464916595,-0.03393028948487046,-0.03393028948487046,-0.03393028948487046,-0.0266579146429191,-0.0266579146429191,-0.0266579146429191,-0.024247521873582645,-0.024247521873582645,-0.024247521873582645,-0.01851718920904466,-0.01851718920904466,-0.01851718920904466,-0.01851718920904466,-0.029627502734471456,-0.029627502734471456,-0.029627502734471456,-0.029627502734471456,-0.04740400437515433,-0.015150427534672922,-0.015150427534672922,-0.015150427534672922,-0.015150427534672922,-0.024240684055476674,-0.024240684055476674,-0.024240684055476674,-0.024240684055476674,-0.038785094488762675,-0.011783665860301345,-0.011783665860301345,-0.011783665860301345,-0.011783665860301345,-0.018853865376482152,-0.018853865376482152,-0.018853865376482152,-0.018853865376482152,-0.030166184602371443,-0.018517189209044892,-0.018517189209044892,-0.018517189209044892,-0.018517189209044892,-0.029627502734471827,-0.029627502734471827,-0.029627502734471827,-0.029627502734471827,-0.04740400437515492,-0.015150427534672776,-0.015150427534672776,-0.015150427534672776,-0.015150427534672776,-0.02424068405547644,-0.02424068405547644,-0.02424068405547644,-0.02424068405547644,-0.03878509448876231,-0.011783665860301277,-0.011783665860301277,-0.011783665860301277,-0.011783665860301277,-0.01885386537648204,-0.01885386537648204,-0.01885386537648204,-0.01885386537648204,-0.030166184602371266]),1e-14))
11623         f=MEDCouplingFieldDouble(ft)
11624         arr=DataArrayDouble(126,2)
11625         arr[:,0]=range(126)
11626         arr[:,1]=range(126)
11627         arr[:,1]+=1000
11628         f.setArray(arr)
11629         f.checkCoherency()
11630         self.assertTrue(DataArrayDouble(f.integral(False)).isEqual(DataArrayDouble([-211.66121638700983,-4863.9563007698835]),1e-12))
11631         self.assertTrue(DataArrayDouble(f.getWeightedAverageValue()).isEqual(DataArrayDouble([45.496085813113595,1045.496085813114]),1e-12))
11632         self.assertTrue(DataArrayDouble(f.normL1()).isEqual(DataArrayDouble([45.49608581311362,1045.496085813114]),1e-12))
11633         self.assertTrue(DataArrayDouble(f.normL2()).isEqual(DataArrayDouble([58.16846378340898,1046.1241521947334]),1e-12))
11634         pass
11635
11636     def testSwig2FieldDiscretizationComputeMeshRestrictionFromTupleIds1(self):
11637         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1()
11638         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11639         f.setMesh(m)
11640         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4,5,6,8,9,10,14,15,16,17])
11641         self.assertTrue(a.isEqual(DataArrayInt([1,4])))
11642         self.assertTrue(b.isEqual(DataArrayInt([4,5,6,14,15,16,17])))
11643         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),DataArrayInt([0,1,2,3,5,7,8,9,10,11,12,18]))
11644         self.assertTrue(a.isEqual(DataArrayInt([0,2])))
11645         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,7,8,9])))
11646         #
11647         f=MEDCouplingFieldDouble(ON_CELLS)
11648         f.setMesh(m)
11649         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4])
11650         self.assertTrue(a.isEqual(DataArrayInt([3,4])))
11651         self.assertTrue(b.isEqual(DataArrayInt([3,4])))
11652         #
11653         f=MEDCouplingFieldDouble(ON_NODES)
11654         f.setMesh(m)
11655         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[1,2,3,4])
11656         self.assertTrue(a.isEqual(DataArrayInt([1])))
11657         self.assertTrue(b.isEqual(DataArrayInt([1,2,4])))
11658         #
11659         f=MEDCouplingDataForTest.buildFieldOnGauss_1()
11660         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[0,11,12,13,14,15,17,18,19,36,37,38,115,117,118,119,120,121,122,123,124,125])
11661         self.assertTrue(a.isEqual(DataArrayInt([0,11,12,18,35])))
11662         self.assertTrue(b.isEqual(DataArrayInt([0,11,12,13,14,15,36,37,38,117,118,119,120,121,122,123,124,125])))
11663         #
11664         d=DataArrayInt([0,3,7,9,15,18])
11665         e=DataArrayInt([0,1,2,3,7,8,15,16,17])
11666         a,b=d.searchRangesInListOfIds(e)
11667         self.assertTrue(a.isEqual(DataArrayInt([0,2,4])))
11668         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,7,8,15,16,17])))
11669         pass
11670
11671     def testSwig2BigMem(self):
11672         if MEDCouplingSizeOfVoidStar()==64:
11673             d=DataArrayAsciiChar(223456789,16)
11674             self.assertTrue(d.getNumberOfTuples(),223456789)
11675             self.assertTrue(d.getNumberOfComponents(),16)
11676             d.setIJ(223456788,5,"r")
11677             self.assertTrue(d.getIJ(223456788,5),'r')
11678             d[223456787]="1234567890123456"
11679             self.assertTrue(d[223456787],'1234567890123456')
11680             self.assertRaises(InterpKernelException,d.rearrange,1)# fails because it would lead to nb of tuples > 2147483647
11681             pass
11682         pass
11683
11684     def testSwig2DAReverseMultiCompo1(self):
11685         d=DataArrayDouble(6,2)
11686         d[:,0]=range(6)
11687         d[:,1]=range(10,16)
11688         d.reverse()
11689         self.assertTrue(d.isEqual(DataArrayDouble([5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],6,2),1e-14))
11690         d=DataArrayDouble(7,2)
11691         d[:,0]=range(7)
11692         d[:,1]=range(10,17)
11693         d.reverse()
11694         self.assertTrue(d.isEqual(DataArrayDouble([6.,16.,5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],7,2),1e-14))
11695         #
11696         d=DataArrayInt(6,2)
11697         d[:,0]=range(6)
11698         d[:,1]=range(10,16)
11699         d.reverse()
11700         self.assertTrue(d.isEqual(DataArrayInt([5,15,4,14,3,13,2,12,1,11,0,10],6,2)))
11701         d=DataArrayInt(7,2)
11702         d[:,0]=range(7)
11703         d[:,1]=range(10,17)
11704         d.reverse()
11705         self.assertTrue(d.isEqual(DataArrayInt([6,16,5,15,4,14,3,13,2,12,1,11,0,10],7,2)))
11706         pass
11707
11708     def testSwigDAPow1(self):
11709         d=DataArrayInt(10)
11710         d.iota(0)
11711         d1=d.deepCpy()
11712         d.setIJ(2,0,-2)
11713         self.assertTrue((d**2).isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11714         self.assertTrue((d**3).isEqual(DataArrayInt([0,1,-8,27,64,125,216,343,512,729])))
11715         for elt in [d]:
11716             elt**=2
11717             pass
11718         self.assertTrue(d.isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11719         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayInt([1,1,4,27])))
11720         self.assertTrue((3**d1[:4]).isEqual(DataArrayInt([1,3,9,27])))
11721         d2=d1[:4]
11722         d2**=d2
11723         self.assertTrue(d2.isEqual(DataArrayInt([1,1,4,27])))
11724         self.assertRaises(InterpKernelException,d2.__pow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11725         self.assertRaises(InterpKernelException,d2.__ipow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11726         #
11727         d=DataArrayDouble(10)
11728         d.iota(0)
11729         d1=d.deepCpy()
11730         d.setIJ(2,0,-2.)
11731         self.assertTrue((d**2).isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11732         self.assertTrue((d**3).isEqual(DataArrayDouble([0,1,-8,27,64,125,216,343,512,729]),1e-12))
11733         self.assertRaises(InterpKernelException,d.__pow__,3.1)#3.1 is double not integer -> not supporting negative values in d
11734         for elt in [d]:
11735             elt**=2
11736             pass
11737         self.assertTrue(d.isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11738         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11739         self.assertTrue((3**d1[:4]).isEqual(DataArrayDouble([1,3,9,27]),1e-12))
11740         d2=d1[:4]
11741         d2**=d2
11742         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11743         d2**=-0.5
11744         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,1./2,1./sqrt(27.)]),1e-14))
11745         d3=-1./d1[1:5]
11746         self.assertTrue((3**d3).isEqual(DataArrayDouble([0.3333333333333333,0.5773502691896257,0.6933612743506348,0.7598356856515925]),1e-14))
11747         d4=d3.deepCpy() ; d4.abs()
11748         self.assertTrue((d4**d3).isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11749         d4**=d3
11750         self.assertTrue(d4.isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11751         pass
11752
11753     def testSwig2Baryenter3DForCellsWithVolumeZero1(self):
11754         coo=DataArrayDouble([0.,0.,0.,1.,0.,0.,0.,1.,0.],3,3)
11755         m2=MEDCouplingUMesh("mesh",2)
11756         m2.allocateCells(0)
11757         m2.insertNextCell(NORM_POLYGON,[0,1,2])
11758         m2.setCoords(coo)
11759         m2.checkCoherency1()
11760         #
11761         coo2=DataArrayDouble([0.,0.,0.,0.,0.,0.,0.,0.,2.],3,3)
11762         m1=MEDCouplingUMesh("mesh",1)
11763         m1.allocateCells(0)
11764         m1.insertNextCell(NORM_SEG2,[0,1])
11765         m1.insertNextCell(NORM_SEG2,[1,2])
11766         m1.setCoords(coo2)
11767         m1.checkCoherency1()
11768         #
11769         m3=m2.buildExtrudedMesh(m1,0)
11770         m3.insertNextCell(NORM_POLYHED,[3,4,5,-1,8,7,6,-1,4,3,6,7,-1,5,4,7,8,-1,5,4,-1,3,5,8,6])# addition of face #4 with null surface
11771         self.assertTrue(m3.getBarycenterAndOwner().isEqual(DataArrayDouble([0.3333333333333333,0.3333333333333333,0.,0.3333333333333333,0.3333333333333333,1.,0.3333333333333333,0.3333333333333333,1.],3,3),1e-13))
11772         m4,a,b,c,d=m3.buildDescendingConnectivity()
11773         self.assertTrue(m4.getBarycenterAndOwner().isEqual(DataArrayDouble([0.3333333333333333,0.3333333333333333,0.,0.3333333333333333,0.3333333333333333,0.,0.5,0.,0.,0.5,0.5,0.,0.,0.5,0.,0.3333333333333333,0.3333333333333333,2.,0.5,0.,1.,0.5,0.5,1.,0.,0.5,1.,0.5,0.5,0.],10,3),1e-13))
11774         pass
11775
11776     def testSwigRepr1(self):
11777         d=DataArrayDouble()
11778         self.assertTrue(len(d.__repr__())<100)
11779         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11780         for i in xrange(100):
11781             d.alloc(i,1) ; d.iota(1.1234567890123456) ; d*=1e123
11782             self.assertTrue(len(d.__repr__())<500)
11783             pass
11784         for i in xrange(50):
11785             d.alloc(i,2) ; d.rearrange(1) ; d.iota(1.1234567890123456) ; d.rearrange(2) ; d*=1e123
11786             self.assertTrue(len(d.__repr__())<500)
11787             pass
11788         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
11789         for i in xrange(2,4):
11790             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
11791             pass
11792         d.alloc(0,9)
11793         self.assertTrue(len(d.__repr__())<100)
11794         #
11795         d=DataArrayInt()
11796         self.assertTrue(len(d.__repr__())<100)
11797         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11798         for i in xrange(100):
11799             d.alloc(i,1) ; d.iota(123456789)
11800             self.assertTrue(len(d.__repr__())<500)
11801             pass
11802         for i in xrange(50):
11803             d.alloc(i,2) ; d.rearrange(1) ; d.iota(123456789) ; d.rearrange(2)
11804             self.assertTrue(len(d.__repr__())<500)
11805             pass
11806         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
11807         for i in xrange(2,10):
11808             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
11809             pass
11810         d.alloc(0,9)
11811         self.assertTrue(len(d.__repr__())<100)
11812         #
11813         d=DataArrayAsciiChar()
11814         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11815         d.alloc(2,16) ; d[:]='1234567890ABCDEF'
11816         self.assertTrue(len(d.__repr__())<500)
11817         d.alloc(2000,16) ; d[:]='1234567890ABCDEF'
11818         self.assertTrue(len(d.__repr__())<500)
11819         d.alloc(0,16) ; d[:]='1234567890ABCDEF'
11820         self.assertTrue(len(d.__repr__())<100)
11821         #
11822         d=DataArrayByte()
11823         self.assertTrue(len(d.__repr__())<100)
11824         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11825         d.alloc(0,16) ; self.assertTrue(len(d.__repr__())<100)
11826         d.alloc(5,1) ; d.fillWithValue(127)
11827         self.assertTrue(len(d.__repr__())<200)
11828         d.alloc(1000,1) ; d.fillWithValue(127)
11829         self.assertTrue(len(d.__repr__())<500)
11830         d.alloc(1000,3) ; d.fillWithValue(127)
11831         self.assertTrue(len(d.__repr__())<500)
11832         pass
11833
11834     def testSwig2MeshComputeIsoBarycenterOfNodesPerCell1(self):
11835         coo=DataArrayDouble([26.17509821414239,5.0374,200.,26.175098214142388,-5.0374,200.,17.450065476094927,20.1496,200.,8.725032738047464,25.187,200.,43.62516369023732,5.0374,200.,34.90013095218986,10.0748,200.,34.900130952189855,-10.0748,200.,43.625163690237315,-5.0374,200.,26.175098214142402,25.187,200.,26.175098214142395,35.2618,200.,17.45006547609493,40.2992,200.,8.725032738047469,35.2618,200.,26.17509821414239,5.0374,200.,26.175098214142388,-5.0374,200.,17.450065476094927,20.1496,200.,8.725032738047464,25.187,200.,43.62516369023732,5.0374,200.,34.90013095218986,10.0748,200.,34.900130952189855,-10.0748,200.,43.625163690237315,-5.0374,200.,26.175098214142402,25.187,200.,26.175098214142395,35.2618,200.,17.45006547609493,40.2992,200.,8.725032738047469,35.2618,200.],24,3)
11836         m=MEDCouplingUMesh.New("toto",3)
11837         m.allocateCells(0)
11838         m.insertNextCell(NORM_POLYHED,[4,5,0,1,6,7,-1,19,18,13,12,17,16,-1,5,4,16,17,-1,0,5,17,12,-1,1,0,12,13,-1,6,1,13,18,-1,7,6,18,19,-1,4,7,19,16])
11839         m.insertNextCell(NORM_POLYHED,[9,10,11,3,2,8,-1,20,14,15,23,22,21,-1,10,9,21,22,-1,11,10,22,23,-1,3,11,23,15,-1,2,3,15,14,-1,8,2,14,20,-1,9,8,20,21])
11840         m.setCoords(coo)
11841         m.checkCoherency1()
11842         #
11843         dReference=DataArrayDouble([(34.900130952189848,0.,200),(17.450065476094931,30.2244,200.)])
11844         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
11845         m.getNodalConnectivity().setIJ(87,0,24)
11846         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11847         m.getNodalConnectivity().setIJ(87,0,-2)
11848         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11849         m.getNodalConnectivity().setIJ(87,0,21)# put again 21 as at the beginning
11850         #
11851         self.assertTrue(m.unPolyze())
11852         self.assertEqual([NORM_HEXGP12],m.getAllTypes())
11853         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
11854         m.getNodalConnectivity().setIJ(25,0,24)
11855         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11856         m.getNodalConnectivity().setIJ(25,0,-1)
11857         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11858         pass
11859
11860     def testSwig2NonRegressionBugDescHexa20(self):
11861         coo=DataArrayDouble([0.,0.,0.,1.23,0.,0.,0.615,0.,0.,0.,2.1,0.,0.615,2.1,0.,1.23,2.1,0.,1.23,1.05,0.,0.,1.05,0.,0.,0.,2.16,1.23,0.,2.16,1.23,2.1,2.16,0.,2.1,2.16,0.,0.,4.32,0.615,0.,4.32,1.23,0.,4.32,1.23,1.05,4.32,1.23,2.1,4.32,0.615,2.1,4.32,0.,2.1,4.32,0.,1.05,4.32],20,3)
11862         m=MEDCouplingUMesh('mesh',3)
11863         m.allocateCells(0)
11864         m.insertNextCell(NORM_HEXA20,[0,3,5,1,12,18,16,14,7,4,6,2,19,17,15,13,8,11,10,9])
11865         m.setCoords(coo)
11866         m.checkCoherency1()
11867         #
11868         a,b,c,d,e=m.buildDescendingConnectivity()
11869         m2=MEDCouplingUMesh('mesh',2)
11870         m2.allocateCells(0)
11871         m2.setCoords(coo)
11872         conn2=[[0,3,5,1,7,4,6,2],[12,14,16,18,13,15,17,19],[0,12,18,3,8,19,11,7],[3,18,16,5,11,17,10,4],[5,16,14,1,10,15,9,6],[1,14,12,0,9,13,8,2]]
11873         for i in xrange(6):
11874             m2.insertNextCell(NORM_QUAD8,conn2[i])
11875             pass
11876         self.assertTrue(m2.isEqual(a,1e-12))
11877         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
11878         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
11879         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
11880         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
11881         #
11882         m.convertQuadraticCellsToLinear() ; m.zipCoords()
11883         m.convertLinearCellsToQuadratic(1)
11884         #
11885         coo2=DataArrayDouble([0.,0.,0.,1.23,0.,0.,0.,2.1,0.,1.23,2.1,0.,0.,0.,4.32,1.23,0.,4.32,1.23,2.1,4.32,0.,2.1,4.32,0.,1.05,0.,0.615,2.1,0.,1.23,1.05,0.,0.615,0.,0.,0.,1.05,4.32,0.615,2.1,4.32,1.23,1.05,4.32,0.615,0.,4.32,0.,0.,2.16,0.,2.1,2.16,1.23,2.1,2.16,1.23,0.,2.16,0.615,1.05,0.,0.,1.05,2.16,0.615,2.1,2.16,1.23,1.05,2.16,0.615,0.,2.16,0.615,1.05,4.32,0.615,1.05,2.16],27,3)
11886         m3=MEDCouplingUMesh("mesh",3)
11887         m3.allocateCells(1)
11888         m3.insertNextCell(NORM_HEXA27,[0,2,3,1,4,7,6,5,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26])
11889         m3.setCoords(coo2)
11890         self.assertTrue(m3.isEqual(m,1e-12))
11891         #
11892         a,b,c,d,e=m.buildDescendingConnectivity()
11893         conn4=[[0,2,3,1,8,9,10,11,20],[4,5,6,7,15,14,13,12,25],[0,4,7,2,16,12,17,8,21],[2,7,6,3,17,13,18,9,22],[3,6,5,1,18,14,19,10,23],[1,5,4,0,19,15,16,11,24]]
11894         m4=MEDCouplingUMesh("mesh",2)
11895         m4.allocateCells(0)
11896         for i in xrange(6):
11897             m4.insertNextCell(NORM_QUAD9,conn4[i])
11898             pass
11899         m4.setCoords(coo2)
11900         self.assertTrue(m4.isEqual(a,1e-12))
11901         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
11902         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
11903         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
11904         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
11905         pass
11906
11907     def testSwigAdvGauss(self):
11908         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
11909         f.setDiscretization(None)
11910         f.__repr__() ; f.__str__()
11911         #
11912         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
11913         d=f.getDiscretization()
11914         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
11915         d.setArrayOfDiscIds(i)
11916         f.__repr__() ; f.__str__()
11917         i2=d.getArrayOfDiscIds()
11918         self.assertEqual(i.__repr__(),i2.__repr__())
11919         #
11920         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
11921         f.setDiscretization(None)
11922         f.__repr__() ; f.__str__()
11923         #
11924         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
11925         d=f.getDiscretization()
11926         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
11927         d.setArrayOfDiscIds(i)
11928         f.__repr__() ; f.__str__()
11929         #
11930         gl=MEDCouplingGaussLocalization(NORM_SEG2,[0,1],[0.5],[1.])
11931         gl.setWeights([3.])
11932         gl.__repr__() ; gl.__str__()
11933         gl=MEDCouplingGaussLocalization(NORM_ERROR)
11934         gl.setWeights([3.])
11935         gl.__repr__() ; gl.__str__()
11936         pass
11937
11938     def testSwig2NonRegressionBugSubstractInPlaceDM(self):
11939         m0=MEDCouplingCMesh()
11940         arr=DataArrayDouble(5,1) ; arr.iota(0.)
11941         m0.setCoords(arr,arr)
11942         m0=m0.buildUnstructured()
11943         m00=m0[::2] ; m00.simplexize(0) ; m01=m0[1::2]
11944         m0=MEDCouplingUMesh.MergeUMeshes([m00,m01])
11945         m0.getCoords()[:]*=1/4.
11946         m0.setName("mesh")
11947         #
11948         NodeField=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; NodeField.setTime(5.6,5,6) ; NodeField.setMesh(m0)
11949         NodeField.setName("NodeField")
11950         NodeField.fillFromAnalytic(1,"exp(-((x-1)*(x-1)+(y-1)*(y-1)))") ; NodeField.getArray().setInfoOnComponent(0,"powernode [W]")
11951         proc0=m0.getCellsInBoundingBox([(0.,0.4),(0.,0.4)],1e-10)
11952         proc1=proc0.buildComplement(m0.getNumberOfCells())
11953         #
11954         NodeField0=NodeField[proc0] ; NodeField0.getMesh().setName(m0.getName())
11955         NodeField1=NodeField[proc1] ; NodeField1.getMesh().setName(m0.getName())
11956         #
11957         NodeField_read=MEDCouplingFieldDouble.MergeFields([NodeField0,NodeField1])
11958         NodeField_read.mergeNodes(1e-10)
11959         NodeFieldCpy=NodeField.deepCpy()
11960         NodeFieldCpy.mergeNodes(1e-10)
11961         NodeField.checkCoherency()
11962         self.assertTrue(not NodeField.getArray().isUniform(0.,1e-12))
11963         NodeField.substractInPlaceDM(NodeField_read,10,1e-12)
11964         self.assertTrue(NodeField.getArray().isUniform(0.,1e-12))
11965         pass
11966
11967     def testSwigFieldOperationOpen1(self):
11968         ## MEDCouplingFieldDouble.__add__
11969         m=MEDCouplingDataForTest.build2DTargetMesh_1()
11970         f=MEDCouplingFieldDouble(ON_CELLS)
11971         f.setMesh(m)
11972         arr=DataArrayDouble(5,2)
11973         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
11974         f2=f.clone(True)
11975         self.assertRaises(InterpKernelException,f.__add__,2)
11976         self.assertRaises(InterpKernelException,f.__add__,range(5))
11977         self.assertRaises(InterpKernelException,f.__add__,arr)
11978         self.assertRaises(InterpKernelException,f.__add__,f2)
11979         f.setArray(DataArrayDouble())
11980         self.assertRaises(InterpKernelException,f.__add__,2)
11981         self.assertRaises(InterpKernelException,f.__add__,range(5))
11982         self.assertRaises(InterpKernelException,f.__add__,arr)
11983         self.assertRaises(InterpKernelException,f.__add__,f2)
11984         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
11985         f.getArray().alloc(5,2)
11986         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
11987         ff=f+2
11988         ff.checkCoherency()
11989         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
11990         ff=f+arr
11991         ff.checkCoherency()
11992         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
11993         self.assertRaises(InterpKernelException,f.__add__,f2)
11994         f2.setArray(arr)
11995         ff=f+f2
11996         ff.checkCoherency()
11997         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
11998         ff=f+[5,8]
11999         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
12000         ### MEDCouplingFieldDouble.__sub__
12001         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12002         f=MEDCouplingFieldDouble(ON_CELLS)
12003         f.setMesh(m)
12004         arr=DataArrayDouble(5,2)
12005         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12006         f2=f.clone(True)
12007         self.assertRaises(InterpKernelException,f.__sub__,2)
12008         self.assertRaises(InterpKernelException,f.__sub__,range(5))
12009         self.assertRaises(InterpKernelException,f.__sub__,arr)
12010         self.assertRaises(InterpKernelException,f.__sub__,f2)
12011         f.setArray(DataArrayDouble())
12012         self.assertRaises(InterpKernelException,f.__sub__,2)
12013         self.assertRaises(InterpKernelException,f.__sub__,range(5))
12014         self.assertRaises(InterpKernelException,f.__sub__,arr)
12015         self.assertRaises(InterpKernelException,f.__sub__,f2)
12016         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12017         f.getArray().alloc(5,2)
12018         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12019         ff=f-2
12020         ff.checkCoherency()
12021         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
12022         ff=f-arr
12023         ff.checkCoherency()
12024         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
12025         self.assertRaises(InterpKernelException,f.__sub__,f2)
12026         f2.setArray(arr)
12027         ff=f-f2
12028         ff.checkCoherency()
12029         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
12030         ff=f-[5,8]
12031         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-5,-1),(-4,0),(-3,1),(-2,2),(-1,3)]),1e-12))
12032         ### MEDCouplingFieldDouble.__mul__
12033         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12034         f=MEDCouplingFieldDouble(ON_CELLS)
12035         f.setMesh(m)
12036         arr=DataArrayDouble(5,2)
12037         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12038         f2=f.clone(True)
12039         self.assertRaises(InterpKernelException,f.__mul__,2)
12040         self.assertRaises(InterpKernelException,f.__mul__,range(5))
12041         self.assertRaises(InterpKernelException,f.__mul__,arr)
12042         self.assertRaises(InterpKernelException,f.__mul__,f2)
12043         f.setArray(DataArrayDouble())
12044         self.assertRaises(InterpKernelException,f.__mul__,2)
12045         self.assertRaises(InterpKernelException,f.__mul__,range(5))
12046         self.assertRaises(InterpKernelException,f.__mul__,arr)
12047         self.assertRaises(InterpKernelException,f.__mul__,f2)
12048         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12049         f.getArray().alloc(5,2)
12050         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12051         ff=f*2
12052         ff.checkCoherency()
12053         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12054         ff=f*arr
12055         ff.checkCoherency()
12056         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12057         self.assertRaises(InterpKernelException,f.__mul__,f2)
12058         f2.setArray(arr)
12059         ff=f*f2
12060         ff.checkCoherency()
12061         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12062         ff=f*[5,8]
12063         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
12064         ### MEDCouplingFieldDouble.__div__
12065         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12066         f=MEDCouplingFieldDouble(ON_CELLS)
12067         f.setMesh(m)
12068         arr=DataArrayDouble(5,2)
12069         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12070         f2=f.clone(True)
12071         self.assertRaises(InterpKernelException,f.__div__,2)
12072         self.assertRaises(InterpKernelException,f.__div__,range(5))
12073         self.assertRaises(InterpKernelException,f.__div__,arr)
12074         self.assertRaises(InterpKernelException,f.__div__,f2)
12075         f.setArray(DataArrayDouble())
12076         self.assertRaises(InterpKernelException,f.__div__,2)
12077         self.assertRaises(InterpKernelException,f.__div__,range(5))
12078         self.assertRaises(InterpKernelException,f.__div__,arr)
12079         self.assertRaises(InterpKernelException,f.__div__,f2)
12080         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12081         f.getArray().alloc(5,2)
12082         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12083         self.assertRaises(InterpKernelException,f.__div__,0)
12084         ff=f/2
12085         ff.checkCoherency()
12086         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
12087         ff=f/arr
12088         ff.checkCoherency()
12089         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,2),(0.6666666666666666,1.5),(0.75,1.25),(0.8,1.1)]),1e-12))
12090         self.assertRaises(InterpKernelException,f.__div__,f2)
12091         f2.setArray(arr)
12092         ff=f/f2
12093         ff.checkCoherency()
12094         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,2),(0.6666666666666666,1.5),(0.75,1.25),(0.8,1.1)]),1e-12))
12095         ff=f/[5,8]
12096         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0.875),(0.2,1),(0.4,1.125),(0.6,1.25),(0.8,1.375)]),1e-12))
12097         ### MEDCouplingFieldDouble.__pow__
12098         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12099         f=MEDCouplingFieldDouble(ON_CELLS)
12100         f.setMesh(m)
12101         arr=DataArrayDouble(5)
12102         arr[:]=[1,1,3,2,0]
12103         f2=f.clone(True)
12104         self.assertRaises(InterpKernelException,f.__div__,2)
12105         self.assertRaises(InterpKernelException,f.__div__,range(5))
12106         self.assertRaises(InterpKernelException,f.__div__,arr)
12107         self.assertRaises(InterpKernelException,f.__div__,f2)
12108         f.setArray(DataArrayDouble())
12109         self.assertRaises(InterpKernelException,f.__div__,2)
12110         self.assertRaises(InterpKernelException,f.__div__,range(5))
12111         self.assertRaises(InterpKernelException,f.__div__,arr)
12112         self.assertRaises(InterpKernelException,f.__div__,f2)
12113         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12114         f.getArray().alloc(5,1)
12115         f.getArray()[:]=range(2,7)
12116         ff=f**2
12117         ff.checkCoherency()
12118         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([4,9,16,25,36]),1e-12))
12119         ff=f**arr
12120         ff.checkCoherency()
12121         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
12122         f2.setArray(arr)
12123         ff=f**f2
12124         ff.checkCoherency()
12125         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
12126         ## MEDCouplingFieldDouble.__iadd__
12127         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12128         f=MEDCouplingFieldDouble(ON_CELLS)
12129         f.setMesh(m)
12130         arr=DataArrayDouble(5,2)
12131         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12132         f2=f.clone(True)
12133         self.assertRaises(InterpKernelException,f.__iadd__,2)
12134         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
12135         self.assertRaises(InterpKernelException,f.__iadd__,arr)
12136         self.assertRaises(InterpKernelException,f.__iadd__,f2)
12137         f.setArray(DataArrayDouble())
12138         self.assertRaises(InterpKernelException,f.__iadd__,2)
12139         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
12140         self.assertRaises(InterpKernelException,f.__iadd__,arr)
12141         self.assertRaises(InterpKernelException,f.__iadd__,f2)
12142         f.getArray().alloc(5,2)
12143         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12144         f.checkCoherency()
12145         f+=2
12146         f.checkCoherency()
12147         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12148         f+=arr
12149         f.checkCoherency()
12150         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(4,12),(6,15),(8,18),(10,21)]),1e-12))
12151         f2.setArray(arr)
12152         f+=f2
12153         f.checkCoherency()
12154         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(5,14),(8,19),(11,24),(14,29)]),1e-12))
12155         f+=[0.1,0.2]
12156         f.checkCoherency()
12157         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2.1,9.2),(5.1,14.2),(8.1,19.2),(11.1,24.2),(14.1,29.2)]),1e-12))
12158         ## MEDCouplingFieldDouble.__isub__
12159         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12160         f=MEDCouplingFieldDouble(ON_CELLS)
12161         f.setMesh(m)
12162         arr=DataArrayDouble(5,2)
12163         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12164         f2=f.clone(True)
12165         self.assertRaises(InterpKernelException,f.__isub__,2)
12166         self.assertRaises(InterpKernelException,f.__isub__,range(5))
12167         self.assertRaises(InterpKernelException,f.__isub__,arr)
12168         self.assertRaises(InterpKernelException,f.__isub__,f2)
12169         f.setArray(DataArrayDouble())
12170         self.assertRaises(InterpKernelException,f.__isub__,2)
12171         self.assertRaises(InterpKernelException,f.__isub__,range(5))
12172         self.assertRaises(InterpKernelException,f.__isub__,arr)
12173         self.assertRaises(InterpKernelException,f.__isub__,f2)
12174         f.getArray().alloc(5,2)
12175         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12176         f.checkCoherency()
12177         f-=2
12178         f.checkCoherency()
12179         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
12180         f-=arr
12181         f.checkCoherency()
12182         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-2,4),(-2,3),(-2,2),(-2,1)]),1e-12))
12183         f2.setArray(arr)
12184         f-=f2
12185         f.checkCoherency()
12186         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-3,2),(-4,-1),(-5,-4),(-6,-7)]),1e-12))
12187         f-=[0.1,0.2]
12188         f.checkCoherency()
12189         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2.1,4.8),(-3.1,1.8),(-4.1,-1.2),(-5.1,-4.2),(-6.1,-7.2)]),1e-12))
12190         ## MEDCouplingFieldDouble.__imul__
12191         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12192         f=MEDCouplingFieldDouble(ON_CELLS)
12193         f.setMesh(m)
12194         arr=DataArrayDouble(5,2)
12195         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12196         f2=f.clone(True)
12197         self.assertRaises(InterpKernelException,f.__imul__,2)
12198         self.assertRaises(InterpKernelException,f.__imul__,range(5))
12199         self.assertRaises(InterpKernelException,f.__imul__,arr)
12200         self.assertRaises(InterpKernelException,f.__imul__,f2)
12201         f.setArray(DataArrayDouble())
12202         self.assertRaises(InterpKernelException,f.__imul__,2)
12203         self.assertRaises(InterpKernelException,f.__imul__,range(5))
12204         self.assertRaises(InterpKernelException,f.__imul__,arr)
12205         self.assertRaises(InterpKernelException,f.__imul__,f2)
12206         f.getArray().alloc(5,2)
12207         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12208         f.checkCoherency()
12209         f*=2
12210         f.checkCoherency()
12211         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12212         f*=arr
12213         f.checkCoherency()
12214         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,32),(8,72),(18,120),(32,176)]),1e-12))
12215         f2.setArray(arr)
12216         f*=f2
12217         f.checkCoherency()
12218         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,64),(16,288),(54,720),(128,1408)]),1e-12))
12219         f*=[0.1,0.2]
12220         f.checkCoherency()
12221         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(0.2,12.8),(1.6,57.6),(5.4,144),(12.8,281.6)]),1e-12))
12222         ## MEDCouplingFieldDouble.__idiv__
12223         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12224         f=MEDCouplingFieldDouble(ON_CELLS)
12225         f.setMesh(m)
12226         arr=DataArrayDouble(5,2)
12227         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12228         f2=f.clone(True)
12229         self.assertRaises(InterpKernelException,f.__idiv__,2)
12230         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
12231         self.assertRaises(InterpKernelException,f.__idiv__,arr)
12232         self.assertRaises(InterpKernelException,f.__idiv__,f2)
12233         f.setArray(DataArrayDouble())
12234         self.assertRaises(InterpKernelException,f.__idiv__,2)
12235         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
12236         self.assertRaises(InterpKernelException,f.__idiv__,arr)
12237         self.assertRaises(InterpKernelException,f.__idiv__,f2)
12238         f.getArray().alloc(5,2)
12239         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12240         f.checkCoherency()
12241         f/=2
12242         f.checkCoherency()
12243         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
12244         f/=arr
12245         f.checkCoherency()
12246         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,1.75),(0.25,1),(0.3333333333333333,0.75),(0.375,0.625),(0.4,0.55)]),1e-12))
12247         f2.setArray(arr)
12248         f/=f2
12249         f.checkCoherency()
12250         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0.875),(0.125,0.25),(0.1111111111111111,0.125),(0.09375,0.078125),(0.08,0.055)]),1e-12))
12251         f/=[0.1,0.2]
12252         f.checkCoherency()
12253         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,4.375),(1.25,1.25),(1.1111111111111111,0.625),(0.9375,0.390625),(0.8,0.275)]),1e-12))
12254         ## MEDCouplingFieldDouble.__ipow__
12255         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12256         f=MEDCouplingFieldDouble(ON_CELLS)
12257         f.setMesh(m)
12258         arr=DataArrayDouble(5,2)
12259         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12260         f2=f.clone(True)
12261         self.assertRaises(InterpKernelException,f.__ipow__,2)
12262         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
12263         self.assertRaises(InterpKernelException,f.__ipow__,arr)
12264         self.assertRaises(InterpKernelException,f.__ipow__,f2)
12265         f.setArray(DataArrayDouble())
12266         self.assertRaises(InterpKernelException,f.__ipow__,2)
12267         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
12268         self.assertRaises(InterpKernelException,f.__ipow__,arr)
12269         self.assertRaises(InterpKernelException,f.__ipow__,f2)
12270         f.getArray().alloc(5,2)
12271         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12272         f.checkCoherency()
12273         f**=2
12274         f.checkCoherency()
12275         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,49),(1,64),(4,81),(9,100),(16,121)]),1e-12))
12276          ## MEDCouplingFieldDouble.__radd__
12277         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12278         f=MEDCouplingFieldDouble(ON_CELLS)
12279         f.setMesh(m)
12280         arr=DataArrayDouble(5,2)
12281         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12282         f2=f.clone(True)
12283         self.assertRaises(InterpKernelException,f.__radd__,2)
12284         self.assertRaises(InterpKernelException,f.__radd__,range(5))
12285         self.assertRaises(InterpKernelException,f.__radd__,arr)
12286         self.assertRaises(InterpKernelException,f.__radd__,f2)
12287         f.setArray(DataArrayDouble())
12288         self.assertRaises(InterpKernelException,f.__radd__,2)
12289         self.assertRaises(InterpKernelException,f.__radd__,range(5))
12290         self.assertRaises(InterpKernelException,f.__radd__,arr)
12291         self.assertRaises(InterpKernelException,f.__radd__,f2)
12292         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12293         f.getArray().alloc(5,2)
12294         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12295         ff=2+f
12296         ff.checkCoherency()
12297         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12298         ff=arr+f
12299         ff.checkCoherency()
12300         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12301         self.assertRaises(InterpKernelException,f.__radd__,f2)
12302         ff=[5,8]+f
12303         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
12304         ### MEDCouplingFieldDouble.__rsub__
12305         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12306         f=MEDCouplingFieldDouble(ON_CELLS)
12307         f.setMesh(m)
12308         arr=DataArrayDouble(5,2)
12309         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12310         f2=f.clone(True)
12311         self.assertRaises(InterpKernelException,f.__rsub__,2)
12312         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
12313         self.assertRaises(InterpKernelException,f.__rsub__,arr)
12314         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12315         f.setArray(DataArrayDouble())
12316         self.assertRaises(InterpKernelException,f.__rsub__,2)
12317         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
12318         self.assertRaises(InterpKernelException,f.__rsub__,arr)
12319         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12320         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12321         f.getArray().alloc(5,2)
12322         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12323         ff=2-f
12324         ff.checkCoherency()
12325         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,-5),(1,-6),(0,-7),(-1,-8),(-2,-9)]),1e-12))
12326         ff=arr-f
12327         ff.checkCoherency()
12328         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,-7),(0,-6),(0,-5),(0,-4),(0,-3)]),1e-12))
12329         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12330         ### MEDCouplingFieldDouble.__rmul__
12331         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12332         f=MEDCouplingFieldDouble(ON_CELLS)
12333         f.setMesh(m)
12334         arr=DataArrayDouble(5,2)
12335         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12336         f2=f.clone(True)
12337         self.assertRaises(InterpKernelException,f.__rmul__,2)
12338         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
12339         self.assertRaises(InterpKernelException,f.__rmul__,arr)
12340         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12341         f.setArray(DataArrayDouble())
12342         self.assertRaises(InterpKernelException,f.__rmul__,2)
12343         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
12344         self.assertRaises(InterpKernelException,f.__rmul__,arr)
12345         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12346         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12347         f.getArray().alloc(5,2)
12348         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12349         ff=2*f
12350         ff.checkCoherency()
12351         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12352         ff=arr*f
12353         ff.checkCoherency()
12354         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12355         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12356         ff=f*[5,8]
12357         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
12358         ### MEDCouplingFieldDouble.__rdiv__
12359         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12360         f=MEDCouplingFieldDouble(ON_CELLS)
12361         f.setMesh(m)
12362         arr=DataArrayDouble(5,2)
12363         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12364         f2=f.clone(True)
12365         self.assertRaises(InterpKernelException,f.__rdiv__,2)
12366         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
12367         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
12368         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12369         f.setArray(DataArrayDouble())
12370         self.assertRaises(InterpKernelException,f.__rdiv__,2)
12371         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
12372         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
12373         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12374         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12375         f.getArray().alloc(5,2)
12376         f.getArray()[:,0]=range(1,6) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12377         ff=2/f
12378         ff.checkCoherency()
12379         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,0.25),(1,0.22222222222222221),(0.66666666666666663,0.20000000000000001),(0.5,0.18181818181818182),(0.40000000000000002,0.16666666666666666)]),1e-12))
12380         ff=arr/f
12381         ff.checkCoherency()
12382         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(1,0.25),(1,0.44444444444444442),(1,0.59999999999999998),(1,0.72727272727272729),(1,0.83333333333333337)]),1e-12))
12383         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12384         pass
12385
12386     def testSwig2FieldDoubleBuildSubPartRange1(self):
12387         #ON_CELLS
12388         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12389         f=MEDCouplingFieldDouble(ON_CELLS)
12390         f.setMesh(m)
12391         arr=DataArrayDouble(5,2) ; arr[:,0]=range(7,12) ; arr[:,1]=100+arr[:,0]
12392         f.setArray(arr)
12393         f.checkCoherency()
12394         ff=f[1:-1:2]
12395         ff.checkCoherency()
12396         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12397         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12398         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12399         self.assertTrue(ff.getArray().isEqual(arr[[1,3]],1e-12))
12400         #
12401         a,b=f.buildSubMeshDataRange(2,5,1)
12402         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12403         self.assertEqual(b,slice(2,5,1))
12404         ff=f[2:]
12405         ff.checkCoherency()
12406         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12407         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12408         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12409         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4]],1e-12))
12410         #
12411         ff=f[-2:0:-1]
12412         ff.checkCoherency()
12413         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12414         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12415         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12416         self.assertTrue(ff.getArray().isEqual(arr[[3,2,1]],1e-12))
12417         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[3,2,1],1],1e-12))
12418         #ON_NODES
12419         f=MEDCouplingFieldDouble(ON_NODES)
12420         f.setMesh(m)
12421         arr=DataArrayDouble(9,2) ; arr[:,0]=range(7,16) ; arr[:,1]=100+arr[:,0]
12422         f.setArray(arr)
12423         f.checkCoherency()
12424         ff=f[1:-1:2]
12425         ff.checkCoherency()
12426         self.assertTrue((m.buildPartOfMySelf([1,3],False)).isEqual(ff.getMesh(),1e-12))
12427         self.assertTrue(6,ff.getMesh().getNumberOfNodes())
12428         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12429         self.assertTrue(ff.getArray().isEqual(arr[[1,2,3,4,6,7]],1e-12))
12430         #
12431         m2=m.buildPartRange(2,5,1)
12432         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(m2,1e-12))
12433         m2,b=m.buildPartRangeAndReduceNodes(2,5,1)
12434         self.assertTrue(m.buildPartOfMySelf([2,3,4],False).isEqual(m2,1e-12))
12435         self.assertTrue(b.isEqual(DataArrayInt([-1,-1,0,1,2,3,4,5,6])))
12436         a,b=f.buildSubMeshDataRange(2,5,1)
12437         self.assertTrue(m.buildPartOfMySelf([2,3,4],False).isEqual(a,1e-12))
12438         self.assertTrue(b.isEqual(DataArrayInt([2,3,4,5,6,7,8])))
12439         ff=f[2:]
12440         ff.checkCoherency()
12441         self.assertTrue((m.buildPartOfMySelf([2,3,4],False)).isEqual(ff.getMesh(),1e-12))
12442         self.assertTrue(7,ff.getMesh().getNumberOfNodes())
12443         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12444         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4,5,6,7,8]],1e-12))
12445         #
12446         ff=f[-2:0:-1]
12447         ff.checkCoherency()
12448         self.assertTrue((m.buildPartOfMySelf([3,2,1],False)).isEqual(ff.getMesh(),1e-12))
12449         self.assertTrue(7,ff.getMesh().getNumberOfNodes())
12450         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12451         self.assertTrue(ff.getArray().isEqual(arr[[1,2,3,4,5,6,7]],1e-12))
12452         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[1,2,3,4,5,6,7],1],1e-12))
12453         #ON_GAUSS_NE
12454         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
12455         f.setMesh(m)
12456         arr=DataArrayDouble(18,2) ; arr[:,0]=range(7,25) ; arr[:,1]=100+arr[:,0]
12457         f.setArray(arr)
12458         f.checkCoherency()
12459         ff=f[1:-1:2]
12460         ff.checkCoherency()
12461         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12462         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12463         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12464         self.assertTrue(ff.getArray().isEqual(arr[[4,5,6,10,11,12,13]],1e-12))
12465         #
12466         a,b=f.buildSubMeshDataRange(2,5,1)
12467         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12468         self.assertEqual(b,slice(7,18,1))
12469         ff=f[2:]
12470         ff.checkCoherency()
12471         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12472         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12473         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12474         self.assertTrue(ff.getArray().isEqual(arr[[7,8,9,10,11,12,13,14,15,16,17]],1e-12))
12475         #
12476         ff=f[-2:0:-1]
12477         ff.checkCoherency()
12478         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12479         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12480         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12481         self.assertTrue(ff.getArray().isEqual(arr[[10,11,12,13,7,8,9,4,5,6]],1e-12))
12482         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[10,11,12,13,7,8,9,4,5,6],1],1e-12))
12483         #ON_GAUSS_PT
12484         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
12485         f.setMesh(m)
12486         f.setGaussLocalizationOnCells([0,4],[0,0,1,0,1,1,1,0],[1.1,1.1,2.2,2.2],[0.2,0.8]);
12487         f.setGaussLocalizationOnCells([3],[0,0,1,0,1,1,1,0],[1.1,1.1,2.2,2.2,3.,3.],[0.2,0.4,0.4]);
12488         f.setGaussLocalizationOnCells([1],[0,0,1,0,1,0],[1.1,1.1,2.2,2.2,3.,3.,4.,4.],[0.1,0.1,0.4,0.4]);
12489         f.setGaussLocalizationOnCells([2],[0,0,1,0,1,0],[1.1,1.1,2.2,2.2,3.,3.,4.,4.,5.,5.],[0.1,0.1,0.4,0.3,0.1]);
12490         arr=DataArrayDouble(16,2) ; arr[:,0]=range(7,23) ; arr[:,1]=100+arr[:,0]
12491         f.setArray(arr)
12492         f.checkCoherency()
12493         ff=f[1:-1:2]
12494         ff.checkCoherency()
12495         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12496         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12497         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12498         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4,5,11,12,13]],1e-12))
12499         #
12500         a,b=f.buildSubMeshDataRange(2,5,1)
12501         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12502         self.assertEqual(b,slice(6,16,1))
12503         ff=f[2:]
12504         ff.checkCoherency()
12505         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12506         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12507         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12508         self.assertTrue(ff.getArray().isEqual(arr[[6,7,8,9,10,11,12,13,14,15]],1e-12))
12509         #
12510         ff=f[-2:0:-1]
12511         ff.checkCoherency()
12512         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12513         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12514         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12515         self.assertTrue(ff.getArray().isEqual(arr[[11,12,13,6,7,8,9,10,2,3,4,5]],1e-12))
12516         self.assertTrue(f[-2:0:-1,0].getArray().isEqual(arr[[11,12,13,6,7,8,9,10,2,3,4,5],0],1e-12))
12517         pass
12518
12519     def testSwig2FieldDoubleApplyFuncBug1(self):
12520         f=MEDCouplingFieldDouble(ON_CELLS)
12521         f.setMesh(MEDCouplingDataForTest.build2DTargetMesh_1())
12522         f.applyFunc(3,700.)
12523         f.checkCoherency()
12524         self.assertEqual(3,f.getArray().getNumberOfComponents())
12525         f.getArray().rearrange(1)
12526         self.assertTrue(f.getArray().isUniform(700.,1e-10))
12527         f.getArray().rearrange(3)
12528         f.checkCoherency()
12529         f.applyFunc(4,800.)
12530         f.checkCoherency()
12531         self.assertEqual(4,f.getArray().getNumberOfComponents())
12532         f.getArray().rearrange(1)
12533         self.assertTrue(f.getArray().isUniform(800.,1e-10))
12534         f.getArray().rearrange(4)
12535         f.checkCoherency()
12536         pass
12537
12538     def testSwig2ComputeTupleIdsNearTupleBug1(self):
12539         coords=[1.1,0.0, 1.1,0.0 ];
12540         coordsArr=DataArrayDouble(coords,2,2);
12541         mesh=MEDCouplingUMesh();
12542         mesh.setCoords(coordsArr);
12543         points=[1.1, 0.002]
12544         c,cI=mesh.getNodeIdsNearPoints(points,0.00185);
12545         self.assertTrue(c.isEqual(DataArrayInt([])))
12546         self.assertTrue(cI.isEqual(DataArrayInt([0,0])))
12547         c,cI=mesh.getNodeIdsNearPoints(points,0.00200000000000001);
12548         self.assertTrue(c.isEqual(DataArrayInt([0,1])))
12549         self.assertTrue(cI.isEqual(DataArrayInt([0,2])))
12550         pass
12551
12552     def testSwig2NonRegressionBugChangeUnderlyingWithZeroCells(self):
12553         coords1=[0.,1.,2.,3.]
12554         coords2=[2.,1.,0.,3.] #0 <==> #2
12555         # mesh 1
12556         mesh1=MEDCouplingUMesh.New();
12557         coordsArr=DataArrayDouble.New(coords1,4,1);
12558         mesh1.setCoords(coordsArr);
12559         mesh1.setMeshDimension(0);
12560         mesh1.allocateCells(0);
12561         mesh1.finishInsertingCells();
12562         # mesh 2
12563         mesh2=mesh1.deepCpy();
12564         coordsArr=DataArrayDouble.New(coords2,4,1);
12565         mesh2.setCoords(coordsArr);
12566         field = mesh1.fillFromAnalytic(ON_NODES,1,"x")
12567         field.checkCoherency()
12568         levOfCheck = 10
12569         field.changeUnderlyingMesh( mesh2, levOfCheck, 1e-13, 0 )
12570         self.assertTrue( field.getArray().getValues() == coords2 )
12571         pass
12572
12573     def setUp(self):
12574         pass
12575     pass
12576
12577 unittest.main()