src/MEDCoupling_Swig/MEDCouplingBasicsTest1.py

   1 #  -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2016  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 import sys
  22 if sys.platform == "win32":
  23     from MEDCouplingCompat import *
  24 else:
  25     from MEDCoupling import *
  26
  27 import unittest
  28 from math import pi,e,sqrt,cos,sin
  29 from datetime import datetime
  30 from MEDCouplingDataForTest import MEDCouplingDataForTest
  31 import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@edf.fr
  32
  33 class MEDCouplingBasicsTest1(unittest.TestCase):
  34     def testArray2(self):
  35         arr=DataArrayDouble.New()
  36         arr.setValues([12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.],3,4)
  37         arr.setInfoOnComponent(0,"ggg");
  38         arr.setInfoOnComponent(1,"hhhh");
  39         arr.setInfoOnComponent(2,"jj");
  40         arr.setInfoOnComponent(3,"kkkkkk");
  41         arr2=arr.convertToIntArr();
  42         arr3=arr2.convertToDblArr();
  43         self.assertTrue(arr.isEqual(arr3,1e-14))
  44         pass
  45
  46     def testArray3(self):
  47         arr1=DataArrayInt.New();
  48         arr1Ref=[0,10,1,11,2,12,3,13,4,14,5,15,6,16]
  49         arr1.setValues(arr1Ref,7,2);
  50         self.assertEqual(7,arr1.getNumberOfTuples());
  51         self.assertEqual(2,arr1.getNumberOfComponents());
  52         self.assertEqual(arr1Ref,list(arr1.getValues()));
  53         arr2=arr1.subArray(3);
  54         self.assertEqual(4,arr2.getNumberOfTuples());
  55         self.assertEqual(2,arr2.getNumberOfComponents());
  56         self.assertEqual(arr1Ref[6:],list(arr2.getValues()));
  57         arr3=arr1.subArray(2,5);
  58         self.assertEqual(3,arr3.getNumberOfTuples());
  59         self.assertEqual(2,arr3.getNumberOfComponents());
  60         self.assertEqual(arr1Ref[4:10],list(arr3.getValues()));
  61         #
  62         arr4=DataArrayDouble.New();
  63         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]
  64         arr4.setValues(arr4Ref,7,2);
  65         self.assertEqual(7,arr4.getNumberOfTuples());
  66         self.assertEqual(2,arr4.getNumberOfComponents());
  67         tmp=arr4.getValues()
  68         for i in range(14):
  69             self.assertTrue(abs(arr4Ref[i]-tmp[i])<1e-14);
  70             pass
  71         arr5=arr4.subArray(3);
  72         self.assertEqual(4,arr5.getNumberOfTuples());
  73         self.assertEqual(2,arr5.getNumberOfComponents());
  74         tmp=arr5.getValues()
  75         for i in range(8):
  76             self.assertTrue(abs(arr4Ref[6+i]-tmp[i])<1e-14);
  77             pass
  78         arr6=arr4.subArray(2,5);
  79         self.assertEqual(3,arr6.getNumberOfTuples());
  80         self.assertEqual(2,arr6.getNumberOfComponents());
  81         tmp=arr6.getValues()
  82         for i in range(6):
  83             self.assertTrue(abs(arr4Ref[4+i]-tmp[i])<1e-14);
  84             pass
  85         pass
  86
  87     def testMesh(self):
  88         tab4=[1, 2, 8, 7, 2, 3, 9, 8, 3,
  89               4, 10, 9, 4, 5, 11, 10, 5,
  90               0, 6, 11, 0, 1, 7, 6 ]
  91         nbOfNodes=12
  92         nbOfCells=6
  93         coords=[ 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17,
  94                  -0.305, 0.09662000000000001, -1.832979297858306e-18, -0.305, 0.120775, 0.04183768725682623,
  95                  -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001, 0.08367537451365246,
  96                  -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863,
  97                  0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
  98                  0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
  99         self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI3),3)
 100         self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI3))
 101         self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_TRI3))
 102         self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI3),2)
 103         self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI3),"NORM_TRI3")
 104         self.assertRaises(InterpKernelException,MEDCouplingMesh.GetNumberOfNodesOfGeometricType,NORM_POLYGON)
 105         self.assertTrue(not MEDCouplingMesh.IsStaticGeometricType(NORM_POLYGON))
 106         self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_POLYGON))
 107         self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_POLYGON),2)
 108         self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_POLYGON),"NORM_POLYGON")
 109         self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI6),6)
 110         self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI6))
 111         self.assertTrue(not MEDCouplingMesh.IsLinearGeometricType(NORM_TRI6))
 112         self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI6),2)
 113         self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI6),"NORM_TRI6")
 114         mesh=MEDCouplingUMesh.New()
 115         mesh.setMeshDimension(2)
 116         mesh.allocateCells(8);
 117         mesh.setName("mesh1")
 118         self.assertTrue(mesh.getName()=="mesh1")
 119         for i in range(nbOfCells):
 120             mesh.insertNextCell(NORM_QUAD4,4,tab4[4*i:4*(i+1)]);
 121             pass
 122         mesh.finishInsertingCells()
 123         self.assertTrue(mesh.getNumberOfCells()==nbOfCells)
 124         self.assertTrue(mesh.getNodalConnectivity().getNbOfElems()==30)
 125         self.assertTrue(mesh.getNodalConnectivityIndex().getNbOfElems()==nbOfCells+1)
 126         myCoords=DataArrayDouble.New()
 127         myCoords.setValues(coords,nbOfNodes,3);
 128         self.assertTrue(myCoords.getIJ(3,2)==-0.305)
 129         mesh.setCoords(myCoords);
 130         mesh.checkConsistencyLight();
 131         self.assertTrue(mesh.getAllGeoTypes()==[4])
 132         myFalseConn=DataArrayInt.New()
 133         myFalseConn.setValues(tab4,6,4)
 134         self.assertTrue(myFalseConn.getIJ(1,1)==3)
 135         #
 136         field=MEDCouplingFieldDouble.New(ON_CELLS)
 137         field.setMesh(mesh)
 138         field.setNature(ExtensiveMaximum)
 139         myCoords=DataArrayDouble.New()
 140         sampleTab=[]
 141         for i in range(nbOfCells * 9):
 142             sampleTab.append(float(i))
 143         myCoords.setValues(sampleTab,nbOfCells,9);
 144         field.setArray(myCoords)
 145         self.assertTrue(3==mesh.getSpaceDimension())
 146         field.checkConsistencyLight()
 147         mesh2=mesh.clone(False)
 148         mesh3=mesh.clone(True)
 149         mesh3=0
 150         mesh2=0
 151         ## deep full recursively copy of field -> both field and mesh underneath copied
 152         field2=field.clone(True)
 153         field2.setMesh(field.getMesh().clone(True))
 154         mesh3=mesh.clone(True)
 155         field3=mesh3.fillFromAnalytic(ON_CELLS,2,"x*IVec+(y+z)*JVec")
 156         field3.applyFunc("u*u*u+cos(u)")
 157         pass
 158
 159     def testMeshPointsCloud(self):
 160         targetCoords=[-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5,
 161                       -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]
 162         targetMesh=MEDCouplingUMesh.New();
 163         targetMesh.setMeshDimension(0);
 164         targetMesh.allocateCells(8);
 165         targetMesh.insertNextCell(NORM_POINT1,1,[0]);
 166         targetMesh.insertNextCell(NORM_POINT1,1,[1]);
 167         targetMesh.insertNextCell(NORM_POINT1,1,[2]);
 168         targetMesh.insertNextCell(NORM_POINT1,1,[3]);
 169         targetMesh.insertNextCell(NORM_POINT1,1,[4]);
 170         targetMesh.insertNextCell(NORM_POINT1,1,[5]);
 171         targetMesh.insertNextCell(NORM_POINT1,1,[7]);
 172         targetMesh.insertNextCell(NORM_POINT1,1,[6]);
 173         targetMesh.finishInsertingCells();
 174         self.assertRaises(InterpKernelException,targetMesh.checkConsistencyLight);
 175         myCoords=DataArrayDouble.New();
 176         myCoords.setValues(targetCoords,9,3);
 177         targetMesh.setCoords(myCoords);
 178         self.assertEqual(targetMesh.getSpaceDimension(),3)
 179         self.assertEqual(targetMesh.getNumberOfCells(),8)
 180         self.assertEqual(targetMesh.getNumberOfNodes(),9)
 181         self.assertEqual(targetMesh.getMeshDimension(),0)
 182         pass
 183
 184     def testMeshM1D(self):
 185         meshM1D=MEDCouplingUMesh.New();
 186         self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
 187         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 188         self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
 189         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
 190         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
 191         meshM1D.setMeshDimension(-1);
 192         meshM1D.checkConsistencyLight();
 193         self.assertEqual(meshM1D.getMeshDimension(),-1);
 194         self.assertEqual(meshM1D.getNumberOfCells(),1);
 195         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 196         self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
 197         cpy=meshM1D.clone(True);
 198         self.assertTrue(cpy.isEqual(meshM1D,1e-12));
 199         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
 200         fieldOnCells.setMesh(meshM1D);
 201         array=DataArrayDouble.New();
 202         array.setValues(6*[7.],1,6);
 203         fieldOnCells.setArray(array);
 204         fieldOnCells.checkConsistencyLight();
 205         pass
 206
 207     def testDeepCopy(self):
 208         array=DataArrayDouble.New();
 209         array.setValues(5*3*[7.],5,3);
 210         self.assertEqual(array.getIJ(3,2),7.);
 211         array2=array.deepCopy();
 212         self.assertEqual(array2.getIJ(3,2),7.)
 213         #
 214         array3=DataArrayInt.New();
 215         array3.setValues(5*3*[17],5,3);
 216         self.assertEqual(array3.getIJ(3,2),17);
 217         array4=array3.deepCopy();
 218         self.assertEqual(array4.getIJ(3,2),17);
 219         pass
 220
 221     def testRevNodal(self):
 222         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 223         revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
 224         revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
 225         revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
 226         self.assertEqual(revNodal.getNbOfElems(),18)
 227         self.assertEqual(revNodalIndx.getNbOfElems(),10)
 228         self.assertEqual(list(revNodal.getValues()),revNodalExpected)
 229         self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
 230         pass
 231
 232     def testConvertToPolyTypes(self):
 233         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 234         elts=[1,3];
 235         mesh.convertToPolyTypes(elts);
 236         mesh.checkConsistencyLight();
 237         self.assertEqual(5,mesh.getNumberOfCells());
 238         self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
 239         expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
 240         self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
 241         #
 242         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 243         mesh.convertToPolyTypes(elts);
 244         mesh.checkConsistencyLight();
 245         self.assertEqual(8,mesh.getNumberOfCells());
 246         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 247         mesh.convertToPolyTypes(elts);
 248         mesh.checkConsistencyLight();
 249         self.assertEqual(8,mesh.getNumberOfCells());
 250         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 251         pass
 252
 253     def testDescConn2D(self):
 254         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 255         desc=DataArrayInt.New();
 256         descIndx=DataArrayInt.New();
 257         revDesc=DataArrayInt.New();
 258         revDescIndx=DataArrayInt.New();
 259         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 260         mesh2.checkConsistencyLight();
 261         self.assertEqual(1,mesh2.getMeshDimension());
 262         self.assertEqual(13,mesh2.getNumberOfCells());
 263         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 264         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 265         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 266         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 267         expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
 268         self.assertEqual(expected1,list(desc.getValues()));
 269         expected2=[0,4,7,10,14,18];
 270         self.assertEqual(expected2,list(descIndx.getValues()));
 271         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
 272         self.assertEqual(expected3,list(revDescIndx.getValues()));
 273         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
 274         self.assertEqual(expected4,list(revDesc.getValues()));
 275         conn=mesh2.getNodalConnectivity();
 276         connIndex=mesh2.getNodalConnectivityIndex();
 277         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
 278         self.assertEqual(expected5,list(connIndex.getValues()));
 279         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];
 280         self.assertEqual(expected6,list(conn.getValues()));
 281         #
 282         eltsV=[1,3];
 283         mesh.convertToPolyTypes(eltsV);
 284         mesh.checkConsistencyLight();
 285         #
 286         desc=DataArrayInt.New();
 287         descIndx=DataArrayInt.New();
 288         revDesc=DataArrayInt.New();
 289         revDescIndx=DataArrayInt.New();
 290         #
 291         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 292         mesh2.checkConsistencyLight();
 293         self.assertEqual(1,mesh2.getMeshDimension());
 294         self.assertEqual(13,mesh2.getNumberOfCells());
 295         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 296         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 297         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 298         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 299         self.assertEqual(expected1,list(desc.getValues()));
 300         self.assertEqual(expected2,list(descIndx.getValues()));
 301         self.assertEqual(expected3,list(revDescIndx.getValues()));
 302         self.assertEqual(expected4,list(revDesc.getValues()));
 303         conn=mesh2.getNodalConnectivity();
 304         connIndex=mesh2.getNodalConnectivityIndex();
 305         self.assertEqual(expected5,list(connIndex.getValues()));
 306         self.assertEqual(expected6,list(conn.getValues()));
 307         pass
 308
 309     def testDescConn3D(self):
 310         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 311         desc=DataArrayInt.New();
 312         descIndx=DataArrayInt.New();
 313         revDesc=DataArrayInt.New();
 314         revDescIndx=DataArrayInt.New();
 315         #
 316         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 317         mesh2.checkConsistencyLight();
 318         self.assertEqual(2,mesh2.getMeshDimension());
 319         self.assertEqual(36,mesh2.getNumberOfCells());
 320         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 321         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 322         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 323         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 324         expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
 325         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]
 326         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]
 327         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]
 328         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]
 329         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,
 330                    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,
 331                    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,
 332                    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]
 333         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,
 334                    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,
 335                    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,
 336                    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]
 337
 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(expected6,list(mesh2.getNodalConnectivity().getValues()));
 344         #
 345         eltsV=[1,3]
 346         mesh.convertToPolyTypes(eltsV);
 347         mesh.checkConsistencyLight();
 348         desc=DataArrayInt.New();
 349         descIndx=DataArrayInt.New();
 350         revDesc=DataArrayInt.New();
 351         revDescIndx=DataArrayInt.New();
 352         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 353         mesh2.checkConsistencyLight();
 354         self.assertEqual(2,mesh2.getMeshDimension());
 355         self.assertEqual(36,mesh2.getNumberOfCells());
 356         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 357         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 358         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 359         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 360         self.assertEqual(expected1,list(descIndx.getValues()));
 361         self.assertEqual(expected2,list(desc.getValues()));
 362         self.assertEqual(expected3,list(revDescIndx.getValues()));
 363         self.assertEqual(expected4,list(revDesc.getValues()));
 364         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 365         self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
 366         pass
 367
 368     def testFindBoundaryNodes(self):
 369         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 370         boundaryNodes=mesh.findBoundaryNodes();
 371         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];
 372         self.assertEqual(expected1,boundaryNodes.getValues());
 373         pass
 374
 375     def testBoundaryMesh(self):
 376         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 377         mesh2=mesh.buildBoundaryMesh(False);
 378         self.assertEqual(24,mesh2.getNumberOfCells());
 379         self.assertEqual(26,mesh2.getNumberOfNodes());
 380         pass
 381
 382     def testBuildPartOfMySelf(self):
 383         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 384         mesh.setName("Toto");
 385         tab1=[0,4]
 386         tab2=[0,2,3]
 387         #
 388         subMesh=mesh.buildPart(tab1)
 389         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 390         subMesh=mesh.buildPartOfMySelf(tab1,True);
 391         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 392         name=subMesh.getName();
 393         self.assertEqual(2,len(mesh.getAllGeoTypes()));
 394         self.assertEqual(NORM_TRI3,mesh.getAllGeoTypes()[0]);
 395         self.assertEqual(NORM_QUAD4,mesh.getAllGeoTypes()[1]);
 396         self.assertEqual(1,len(subMesh.getAllGeoTypes()));
 397         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
 398         self.assertEqual(name,"Toto");
 399         self.assertEqual(2,subMesh.getNumberOfCells());
 400         subConn=[4,0,3,4,1,4,7,8,5,4];
 401         subConnIndex=[0,5,10];
 402         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 403         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 404         self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
 405         self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
 406         #
 407         subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
 408         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
 409         name=subMesh.getName();
 410         self.assertEqual(2,len(subMesh.getAllGeoTypes()));
 411         self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
 412         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
 413         self.assertEqual(name,"Toto");
 414         self.assertEqual(3,subMesh.getNumberOfCells());
 415         subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
 416         subConnIndex2=[0,5,9,14]
 417         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 418         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 419         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 420         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 421         dd=DataArrayInt.New()
 422         dd.alloc(3,1)
 423         dd.iota(0)
 424         dd.setName("coucou")
 425         subMesh=subMesh.buildPartOfMySelf(dd,True);
 426         self.assertEqual("coucou",subMesh.getName());
 427         pass
 428
 429     def testBuildPartOfMySelfNode(self):
 430         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 431         tab1=[5,7,8,4]
 432         subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
 433         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 434         self.assertEqual(1,len(subMesh.getAllGeoTypes()));
 435         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
 436         self.assertEqual(1,subMesh.getNumberOfCells());
 437         self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
 438         self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
 439         subConn=[4,7,8,5,4]
 440         subConnIndex=[0,5]
 441         self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
 442         self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
 443         #
 444         ddd=DataArrayInt.New()
 445         ddd.setValues(tab1[0:2],2,1)
 446         ddd.setName("ddd")
 447         subMesh=mesh.buildPartOfMySelfNode(ddd,False);
 448         self.assertEqual("ddd",subMesh.getName())
 449         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 450         self.assertEqual(2,len(subMesh.getAllGeoTypes()));
 451         self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
 452         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
 453         self.assertEqual(3,subMesh.getNumberOfCells());
 454         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 455         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 456         subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
 457         subConnIndex2=[0,4,9,14]
 458         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 459         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 460         #testing the case where length of tab2 is greater than max number of node per cell.
 461         tab2=[0,3,2,1,4,5,6]
 462         subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
 463         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 464         self.assertEqual(2,len(subMesh.getAllGeoTypes()));
 465         self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
 466         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
 467         self.assertEqual(3,subMesh.getNumberOfCells());
 468         pass
 469
 470     def testZipCoords(self):
 471         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 472         self.assertEqual(2,len(mesh.getAllGeoTypes()));
 473         self.assertEqual(2,mesh.getSpaceDimension());
 474         self.assertEqual(9,mesh.getNumberOfNodes());
 475         self.assertEqual(5,mesh.getNumberOfCells());
 476         oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
 477         oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
 478         oldCoords=mesh.getCoords();
 479         mesh.zipCoords();
 480         self.assertEqual(2,len(mesh.getAllGeoTypes()));
 481         self.assertEqual(2,mesh.getSpaceDimension());
 482         self.assertEqual(9,mesh.getNumberOfNodes());
 483         self.assertEqual(5,mesh.getNumberOfCells());
 484         self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
 485         self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
 486         self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
 487         #
 488         tab1=[0,4]
 489         subMesh=mesh.buildPartOfMySelf(tab1,True);
 490         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 491         traducer=subMesh.zipCoordsTraducer();
 492         expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
 493         self.assertEqual(expectedTraducer,list(traducer.getValues()));
 494         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
 495         self.assertEqual(2,subMesh.getNumberOfCells());
 496         subConn=[4,0,2,3,1,4,5,6,4,3]
 497         subConnIndex=[0,5,10]
 498         self.assertEqual(7,subMesh.getNumberOfNodes());
 499         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 500         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 501         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 502         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 503         #
 504         subMesh=mesh.buildPartOfMySelf(tab1,False);
 505         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 506         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
 507         self.assertEqual(2,subMesh.getNumberOfCells());
 508         self.assertEqual(7,subMesh.getNumberOfNodes());
 509         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 510         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 511         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 512         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 513         pass
 514
 515     def testZipConnectivity(self):
 516         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 517         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 518         cells1=[2,3,4]
 519         m3=m2.buildPartOfMySelf(cells1,True);
 520         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
 521         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
 522         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
 523         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
 524         #
 525         self.assertEqual(10,m6.getNumberOfCells());
 526         self.assertEqual(22,m6.getNumberOfNodes());
 527         (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
 528         self.assertTrue(areNodesMerged);
 529         self.assertEqual(10,m6.getNumberOfCells());
 530         self.assertEqual(9,m6.getNumberOfNodes());
 531         #
 532         arr=m6.zipConnectivityTraducer(0);
 533         self.assertEqual(7,m6.getNumberOfCells());
 534         m7=m6.clone(True);
 535         arr=m6.zipConnectivityTraducer(0);
 536         self.assertTrue(m7.isEqual(m6,1e-12));
 537         self.assertEqual(7,m6.getNumberOfCells());
 538         pass
 539
 540     def testEqualMesh(self):
 541         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 542         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 543         #
 544         self.assertTrue(mesh1.isEqual(mesh1,1e-12));
 545         #
 546         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 547         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 548         pt=mesh2.getCoords().getValues();
 549         tmp=pt[1]
 550         mesh2.getCoords().setIJ(0,1,5.999);
 551         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 552         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 553         mesh2.getCoords().setIJ(0,1,tmp);
 554         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 555         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 556         #
 557         pt2=mesh1.getNodalConnectivity().getValues();
 558         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
 559         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 560         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 561         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
 562         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 563         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 564         #
 565         pt2=mesh1.getNodalConnectivityIndex().getValues();
 566         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
 567         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 568         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 569         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
 570         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 571         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 572         #
 573         tmp3=mesh1.getName();
 574         mesh1.setName("lllll");
 575         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 576         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 577         mesh1.setName(tmp3);
 578         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 579         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 580         #
 581         tmp3=mesh2.getCoords().getInfoOnComponent(1);
 582         mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
 583         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 584         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 585         mesh2.getCoords().setInfoOnComponent(1,tmp3);
 586         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 587         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 588         pass
 589
 590     def testEqualFieldDouble(self):
 591         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 592         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 593         #
 594         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 595         fieldOnCells1.setMesh(mesh1);
 596         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 597         fieldOnCells2.setMesh(mesh2);
 598         #
 599         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 600         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 601         #
 602         fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 603         self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
 604         self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
 605         #
 606         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 607         self.assertEqual(fieldOnCells2.getMesh(),None) # to check that convertMesh wrapping do not raise but return Py_None
 608         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 609         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 610         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 611         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 612         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 613         fieldOnCells1.setTime(4.,6,7);
 614         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 615         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 616         fieldOnCells2.setTime(4.,6,7);
 617         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 618         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 619         fieldOnCells1.setName("Power");
 620         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 621         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 622         fieldOnCells2.setName("Power");
 623         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 624         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 625         #
 626         fieldOnCells1.setMesh(mesh1);
 627         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 628         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 629         fieldOnCells2.setMesh(mesh1);
 630         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 631         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 632         arr=DataArrayDouble.New();
 633         arr.setName("popo");
 634         arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
 635         fieldOnCells1.setArray(arr);
 636         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 637         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 638         fieldOnCells2.setArray(arr);
 639         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 640         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 641         #
 642         arr2=arr.deepCopy();
 643         fieldOnCells2.setArray(arr2);
 644         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 645         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 646         arr.setIJ(1,2,6.1);
 647         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 648         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 649         arr.setIJ(1,2,6.);
 650         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 651         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 652         arr2.setName("popo2");
 653         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 654         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 655         #
 656         arr2.setName("popo");
 657         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 658         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 659         #
 660         arr2.setInfoOnComponent(2,"jjj");
 661         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 662         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 663         arr.setInfoOnComponent(2,"jjj");
 664         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 665         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 666         pass
 667
 668     def testNatureChecking(self):
 669         field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 670         field.setNature(ExtensiveMaximum);
 671         field.setNature(IntensiveMaximum);
 672         field.setNature(ExtensiveConservation);
 673         field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 674         field.setNature(IntensiveMaximum);
 675         self.assertRaises(InterpKernelException,field.setNature,ExtensiveMaximum);
 676         self.assertRaises(InterpKernelException,field.setNature,ExtensiveConservation);
 677         pass
 678
 679     def testNatureOperations(self):
 680         """ Check nature constraints on field operations """
 681         m = MEDCouplingCMesh()
 682         m.setCoordsAt(0, DataArrayDouble([1.0,2.0,3.0]))
 683         m.setCoordsAt(1, DataArrayDouble([1.0,2.0,3.0]))
 684         m = m.buildUnstructured()
 685         f1, f2 = MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME), MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME)
 686         f1.setNature(ExtensiveMaximum)
 687         f2.setNature(IntensiveMaximum)
 688         self.assertEqual(ExtensiveMaximum, f1.getNature())
 689         self.assertEqual(IntensiveMaximum, f2.getNature())
 690
 691         da = DataArrayDouble([1.0,2.0,3.0,4.0])
 692         f1.setMesh(m); f2.setMesh(m)
 693         f1.setArray(da); f2.setArray(da.deepCopy())
 694         # All this should complain about nature:
 695         self.assertRaises(InterpKernelException, f1.__add__, f2)
 696         self.assertRaises(InterpKernelException, f1.__iadd__, f2)
 697         self.assertRaises(InterpKernelException, f1.__sub__, f2)
 698         self.assertRaises(InterpKernelException, f1.__isub__, f2)
 699         self.assertRaises(InterpKernelException, f1.__radd__, f2)
 700         self.assertRaises(InterpKernelException, f1.__rsub__, f2)
 701         self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.AddFields, f1, f2)
 702         self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.SubstractFields, f1, f2)
 703         self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MaxFields, f1, f2)
 704         self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MinFields, f1, f2)
 705         # Not those ones:
 706         f3 = MEDCouplingFieldDouble.MultiplyFields(f1,f2)
 707         self.assertEqual(NoNature, f3.getNature())
 708         f3 = f1*f2
 709         self.assertEqual(NoNature, f3.getNature())
 710         f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m);  f1Tmp *= f2
 711         self.assertEqual(NoNature, f1Tmp.getNature())
 712         f3 = MEDCouplingFieldDouble.DivideFields(f1,f2)
 713         self.assertEqual(NoNature, f3.getNature())
 714         f3 = f1/f2
 715         self.assertEqual(NoNature, f3.getNature())
 716         f1Tmp = f1.deepCopy();  f1Tmp.setMesh(m);  f1Tmp /= f2
 717         self.assertEqual(NoNature, f1Tmp.getNature())
 718 #         f3 = MEDCouplingFieldDouble.PowFields(f1,f2)
 719 #         self.assertEqual(NoNature, f3.getNature())
 720         f3 = f1**f2
 721         self.assertEqual(NoNature, f3.getNature())
 722         f1Tmp = f1.deepCopy();  f1Tmp.setMesh(m);  f1Tmp **= f2
 723         self.assertEqual(NoNature, f1Tmp.getNature())
 724         f3 = MEDCouplingFieldDouble.DotFields(f1,f2)
 725         self.assertEqual(NoNature, f3.getNature())
 726         f3 = f1.dot(f2)
 727         self.assertEqual(NoNature, f3.getNature())
 728
 729         da = DataArrayDouble.Meld([da, da, da])
 730         f1.setArray(da); f2.setArray(da.deepCopy())
 731         f3 = MEDCouplingFieldDouble.CrossProductFields(f1,f2)
 732         self.assertEqual(NoNature, f3.getNature())
 733         f3 = f1.crossProduct(f2)
 734
 735     def testBuildSubMeshData(self):
 736         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 737         #check buildSubMesh on field on cells
 738         fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 739         fieldCells.setMesh(targetMesh);
 740         elts=[1,2,4]
 741         ret1,di=fieldCells.buildSubMeshData(elts);
 742         self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
 743         self.assertEqual(3,ret1.getNumberOfCells());
 744         self.assertEqual(9,ret1.getNumberOfNodes());
 745         self.assertEqual(3,di.getNumberOfTuples());
 746         self.assertEqual(1,di.getNumberOfComponents());
 747         toCheck=di.getValues();
 748         self.assertTrue(elts,toCheck);
 749         #check buildSubMesh on field on nodes
 750         fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 751         fieldNodes.setMesh(targetMesh);
 752         ret2,di=fieldNodes.buildSubMeshData(elts);
 753         self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
 754         self.assertEqual(3,ret2.getNumberOfCells());
 755         self.assertEqual(6,ret2.getNumberOfNodes());
 756         self.assertEqual(6,di.getNumberOfTuples());
 757         self.assertEqual(1,di.getNumberOfComponents());
 758         toCheck=di.getValues();
 759         expected=[1,2,4,5,7,8]
 760         self.assertEqual(expected,list(toCheck));
 761         pass
 762
 763     def testExtrudedMesh1(self):
 764         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
 765         ext=MEDCouplingMappedExtrudedMesh.New(mesh3D,mesh2D,1);
 766         self.assertEqual(18,ext.getNumberOfCells());
 767         self.assertEqual(60,ext.getNumberOfNodes());
 768         ids3D=ext.getMesh3DIds();
 769         ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
 770         self.assertEqual(18,ids3D.getNumberOfTuples());
 771         self.assertEqual(1,ids3D.getNumberOfComponents());
 772         self.assertEqual(ids3DExpected,list(ids3D.getValues()));
 773         mesh1D=ext.getMesh1D();
 774         self.assertEqual(4,mesh1D.getNumberOfNodes());
 775         self.assertEqual(3,mesh1D.getNumberOfCells());
 776         mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
 777                         1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
 778                         2, 0.66666666666666663, 1.4583333333333333, 3]
 779         mesh1DCoords=mesh1D.getCoords();
 780         self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
 781         self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
 782         self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
 783         conn1D=mesh1D.getNodalConnectivity();
 784         self.assertEqual(9,conn1D.getNumberOfTuples());
 785         self.assertEqual(1,conn1D.getNumberOfComponents());
 786         conn1DExpected=[1,0,1,1,1,2,1,2,3]
 787         self.assertEqual(conn1DExpected,list(conn1D.getValues()));
 788         pass
 789
 790     def testExtrudedMesh3(self):
 791         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 792         m1.changeSpaceDimension(3);
 793         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 794         m2.changeSpaceDimension(3);
 795         center=[0.,0.,0.]
 796         vector=[0.,1.,0.]
 797         m2.rotate(center,vector,-pi/2.);
 798         m3=m1.buildExtrudedMesh(m2,0);
 799         #
 800         m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
 801         self.assertEqual(15,m4.getNumberOfCells());
 802         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 803         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 804         m3DIds=m4.getMesh3DIds().getValues();
 805         self.assertEqual(list(range(15)), list(m3DIds));
 806         #some random in cells to check that extrusion alg find it correctly
 807         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 808         m3.renumberCells(expected1,False);
 809         m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
 810         self.assertEqual(15,m4.getNumberOfCells());
 811         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 812         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 813         m3DIds=m4.getMesh3DIds().getValues();
 814         self.assertEqual(expected1,list(m3DIds));
 815         #play with polygons and polyedrons
 816         cells=[2,3]
 817         m1.convertToPolyTypes(cells);
 818         m3=m1.buildExtrudedMesh(m2,0);
 819         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
 820         self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
 821         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
 822         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
 823         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
 824         m3.renumberCells(expected1,False);
 825         m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
 826         self.assertEqual(15,m4.getNumberOfCells());
 827         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 828         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 829         m3DIds=m4.getMesh3DIds().getValues();
 830         self.assertEqual(expected1,list(m3DIds));
 831         pass
 832
 833     def testExtrudedMesh4(self):
 834         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 835         cells=[2,4];
 836         m1.convertToPolyTypes(cells);
 837         m1.changeSpaceDimension(3);
 838         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 839         m2.changeSpaceDimension(3);
 840         center=[0.,0.,0.]
 841         vector=[0.,1.,0.]
 842         m2.rotate(center,vector,-pi/2.);
 843         m1.zipCoords()
 844         m3=m1.buildExtrudedMesh(m2,0);
 845         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 846         rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
 847         m3.renumberCells(expected1,False);
 848         m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
 849         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
 850         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
 851         self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
 852         self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
 853         f=m4.getMeasureField(True);
 854         arr=f.getArray();
 855         self.assertEqual(15,arr.getNumberOfTuples());
 856         self.assertEqual(1,arr.getNumberOfComponents());
 857         arrPtr=arr.getValues();
 858         expected2=[0.075,0.0375,0.0375,0.075,0.075,
 859                    0.1125,0.05625,0.05625,0.1125,0.1125,
 860                    0.0625,0.03125,0.03125,0.0625,0.0625]
 861         for i in range(15):
 862             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
 863             pass
 864         m5=m4.build3DUnstructuredMesh();
 865         m5.zipCoords()
 866         self.assertTrue(m5.isEqual(m3,1e-12));
 867         f=m5.getMeasureField(True);
 868         f.setMesh(m4)
 869         self.assertTrue(isinstance(f.getMesh(),MEDCouplingMappedExtrudedMesh))
 870         arr=f.getArray();
 871         arrPtr=arr.getValues();
 872         for i in range(15):
 873             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
 874             pass
 875         pass
 876
 877     def testFindCommonNodes(self):
 878         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 879         comm,commI=targetMesh.findCommonNodes(1e-10,-1);
 880         self.assertEqual(1,commI.getNumberOfTuples());
 881         self.assertEqual(0,comm.getNumberOfTuples());
 882         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 883         self.assertEqual(27,newNbOfNodes);
 884         self.assertEqual(27,o2n.getNumberOfTuples());
 885         o2nExp1 = list(range(27))
 886         self.assertEqual(o2nExp1,list(o2n.getValues()));
 887         #
 888         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 889         self.assertEqual(31,targetMesh.getNumberOfNodes());
 890         comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
 891         self.assertEqual(3,commI.getNumberOfTuples());
 892         self.assertEqual(6,comm.getNumberOfTuples());
 893         commExpected=[1,27,28,29,23,30]
 894         commIExpected=[0,4,6]
 895         self.assertEqual(commExpected,list(comm.getValues()));
 896         self.assertEqual(commIExpected,list(commI.getValues()));
 897         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 898         self.assertEqual(31,o2n.getNumberOfTuples());
 899         self.assertEqual(27,newNbOfNodes);
 900         o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
 901                  21,22,23,24,25,26,1,1,1,23]
 902         self.assertEqual(o2nExp2,list(o2n.getValues()));
 903         #
 904         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 905         time=targetMesh.getTimeOfThis();
 906         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 907         targetMesh.updateTime();
 908         self.assertEqual(time,targetMesh.getTimeOfThis());
 909         self.assertTrue(not areNodesMerged);
 910         #
 911         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 912         time=targetMesh.getTimeOfThis();
 913         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 914         targetMesh.updateTime();
 915         self.assertTrue(time!=targetMesh.getTimeOfThis());
 916         self.assertTrue(areNodesMerged);
 917         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,
 918                  18,4,5,8,7,13,14,17,16,
 919                  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,
 920                  18,13,14,17,16,22,23,26,25]
 921         self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
 922         self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
 923         self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
 924         coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0.  , 0., 50., 0., 50., 50., 0. ,
 925                     200., 50., 0.,   0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
 926                     0., 0., 50., 50., 0., 50. , 200., 0., 50.  , 0., 50., 50., 50.,
 927                     50., 50. , 200., 50., 50.,   0., 200., 50., 50., 200., 50. ,
 928                     200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
 929                     , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
 930                     0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
 931         self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
 932         # 2D
 933         targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
 934         self.assertEqual(18,targetMesh.getNumberOfNodes());
 935         time=targetMesh.getTimeOfThis();
 936         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 937         self.assertTrue(time!=targetMesh.getTimeOfThis());
 938         self.assertTrue(areNodesMerged);
 939         self.assertEqual(9,targetMesh.getNumberOfNodes());
 940         connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
 941         self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
 942         self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
 943         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]
 944         self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
 945         self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
 946         pass
 947
 948     def testCheckButterflyCells(self):
 949         sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 950         cells=sourceMesh.checkButterflyCells();
 951         self.assertEqual(0,len(cells));
 952         conn=sourceMesh.getNodalConnectivity()
 953         tmp=conn.getIJ(15,0)
 954         conn.setIJ(15,0,conn.getIJ(16,0))
 955         conn.setIJ(16,0,tmp)
 956         cells=sourceMesh.checkButterflyCells();
 957         self.assertEqual(1,len(cells));
 958         self.assertEqual([3],cells.getValues());
 959         tmp=conn.getIJ(15,0)
 960         conn.setIJ(15,0,conn.getIJ(16,0))
 961         conn.setIJ(16,0,tmp)
 962         cells=sourceMesh.checkButterflyCells();
 963         self.assertEqual(0,len(cells));
 964         # 3D surf
 965         sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
 966         cells=sourceMesh.checkButterflyCells();
 967         self.assertEqual(0,len(cells));
 968         conn=sourceMesh.getNodalConnectivity()
 969         tmp=conn.getIJ(15,0)
 970         conn.setIJ(15,0,conn.getIJ(16,0))
 971         conn.setIJ(16,0,tmp)
 972         cells=sourceMesh.checkButterflyCells();
 973         self.assertEqual(1,len(cells));
 974         self.assertEqual([3],cells.getValues());
 975         tmp=conn.getIJ(15,0)
 976         conn.setIJ(15,0,conn.getIJ(16,0))
 977         conn.setIJ(16,0,tmp)
 978         cells=sourceMesh.checkButterflyCells();
 979         self.assertEqual(0,len(cells));
 980         pass
 981
 982     def testMergeMesh1(self):
 983         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 984         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 985         vec=[1.,0.]
 986         m2.translate(vec);
 987         m3=m1.mergeMyselfWith(m2);
 988         self.assertTrue(isinstance(m3,MEDCouplingUMesh));
 989         m3.checkConsistencyLight();
 990         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 991         self.assertTrue(m3.isEqual(m4,1.e-12));
 992         da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
 993         self.assertEqual(11,m3.getNumberOfNodes());
 994         self.assertTrue(isMerged);
 995         pass
 996
 997     def testMergeMeshOnSameCoords1(self):
 998         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 999         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1000         cells = list(range(5));
1001         m2.convertToPolyTypes(cells);
1002         m1.tryToShareSameCoords(m2,1e-12);
1003         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
1004         m3.tryToShareSameCoords(m2,1e-12);
1005         meshes=[m1,m2,m3]
1006         m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
1007         m4.checkConsistencyLight();
1008         self.assertEqual(15,m4.getNumberOfCells());
1009         cells1=[0,1,2,3,4]
1010         m1_1=m4.buildPartOfMySelf(cells1,True);
1011         m1_1.setName(m1.getName());
1012         self.assertTrue(m1.isEqual(m1_1,1e-12));
1013         cells2=[5,6,7,8,9]
1014         m2_1=m4.buildPartOfMySelf(cells2,True);
1015         m2_1.setName(m2.getName());
1016         self.assertTrue(m2.isEqual(m2_1,1e-12));
1017         cells3=[10,11,12,13,14]
1018         m3_1=m4.buildPartOfMySelf(cells3,True);
1019         m3_1.setName(m3.getName());
1020         self.assertTrue(m3.isEqual(m3_1,1e-12));
1021         pass
1022
1023     def testMergeField1(self):
1024         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1025         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1026         vec=[1.,0.]
1027         m2.translate(vec);
1028         f1=m1.getMeasureField(True);
1029         f2=m2.getMeasureField(True);
1030         f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
1031         f3.checkConsistencyLight();
1032         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
1033         self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
1034         name=f3.getName();
1035         self.assertEqual(name,"MeasureOfMesh_");
1036         self.assertEqual(f3.getTypeOfField(),ON_CELLS);
1037         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1038         self.assertEqual(1,f3.getNumberOfComponents());
1039         self.assertEqual(7,f3.getNumberOfTuples());
1040         values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
1041         tmp=f3.getArray().getValues();
1042         self.assertEqual(len(values),len(tmp))
1043         for i in range(7):
1044             self.assertTrue(abs(values[i]-tmp[i])<1e-12)
1045             pass
1046         pass
1047
1048     def testFillFromAnalytic(self):
1049         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1050         m.setTime(3.4,5,6); m.setTimeUnit("us");
1051         f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
1052         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1053         self.assertEqual("us",f1.getTimeUnit())
1054         f1.checkConsistencyLight();
1055         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1056         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1057         self.assertEqual(1,f1.getNumberOfComponents());
1058         self.assertEqual(5,f1.getNumberOfTuples());
1059         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1060         tmp=f1.getArray().getValues();
1061         self.assertEqual(len(values1),len(tmp))
1062         for i in range(len(tmp)):
1063             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1064             pass
1065         #
1066         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1067         f1.checkConsistencyLight();
1068         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1069         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1070         self.assertEqual(1,f1.getNumberOfComponents());
1071         self.assertEqual(9,f1.getNumberOfTuples());
1072         values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
1073         tmp=f1.getArray().getValues();
1074         self.assertEqual(len(values2),len(tmp))
1075         for i in range(len(tmp)):
1076             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1077             pass
1078         #
1079         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1080         f1.checkConsistencyLight();
1081         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1082         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1083         self.assertEqual(2,f1.getNumberOfComponents());
1084         self.assertEqual(9,f1.getNumberOfTuples());
1085         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]
1086         tmp=f1.getArray().getValues();
1087         self.assertEqual(len(values3),len(tmp))
1088         for i in range(len(tmp)):
1089             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1090             pass
1091         values4=f1.accumulate();
1092         self.assertEqual(2,len(values4))
1093         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1094         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1095         values4=f1.integral(True);
1096         self.assertEqual(2,len(values4))
1097         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1098         self.assertTrue(abs(1.-values4[1])<1.e-12);
1099         #
1100         self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1101         pass
1102
1103     def testFillFromAnalytic2(self):
1104         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1105         f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1106         f1.checkConsistencyLight();
1107         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1108         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1109         self.assertEqual(1,f1.getNumberOfComponents());
1110         self.assertEqual(5,f1.getNumberOfTuples());
1111         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1112         tmp=f1.getArray().getValues();
1113         self.assertEqual(len(values1),len(tmp))
1114         for i in range(len(values1)):
1115             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1116             pass
1117         #
1118         f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1119         f1.checkConsistencyLight();
1120         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1121         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1122         self.assertEqual(1,f1.getNumberOfComponents());
1123         self.assertEqual(9,f1.getNumberOfTuples());
1124         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1125         tmp=f1.getArray().getValues();
1126         self.assertEqual(len(values2),len(tmp))
1127         for i in range(len(values2)):
1128             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1129             pass
1130         f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1131         f1.checkConsistencyLight();
1132         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1133         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1134         self.assertEqual(1,f1.getNumberOfComponents());
1135         self.assertEqual(9,f1.getNumberOfTuples());
1136         tmp=f1.getArray().getValues();
1137         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1138         self.assertEqual(len(values2Bis),len(tmp))
1139         for i in range(len(values2Bis)):
1140             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1141             pass
1142         #
1143         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1144         f1.checkConsistencyLight();
1145         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1146         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1147         self.assertEqual(2,f1.getNumberOfComponents());
1148         self.assertEqual(9,f1.getNumberOfTuples());
1149         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]
1150         tmp=f1.getArray().getValues();
1151         self.assertEqual(len(values3),len(tmp))
1152         for i in range(len(values3)):
1153             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1154             pass
1155         values4=f1.accumulate();
1156         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1157         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1158         values4=f1.integral(True);
1159         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1160         self.assertTrue(abs(1.-values4[1])<1.e-12);
1161         pass
1162
1163     def testApplyFunc(self):
1164         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1165         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1166         f1.checkConsistencyLight();
1167         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1168         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1169         self.assertEqual(2,f1.getNumberOfComponents());
1170         self.assertEqual(9,f1.getNumberOfTuples());
1171         f1.applyFunc(1,"x+y");
1172         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1173         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1174         self.assertEqual(1,f1.getNumberOfComponents());
1175         self.assertEqual(9,f1.getNumberOfTuples());
1176         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1177         tmp=f1.getArray().getValues();
1178         self.assertEqual(len(values1),len(tmp))
1179         for i in range(len(tmp)):
1180             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1181             pass
1182         pass
1183
1184     def testApplyFunc2(self):
1185         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1186         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1187         f1.checkConsistencyLight();
1188         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1189         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1190         self.assertEqual(2,f1.getNumberOfComponents());
1191         self.assertEqual(9,f1.getNumberOfTuples());
1192         #
1193         f2=f1.clone(True);
1194         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1195         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1196         self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1197         f2.applyFunc("abs(u)^2.4+2*u");
1198         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1199         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1200         self.assertEqual(2,f1.getNumberOfComponents());
1201         self.assertEqual(9,f1.getNumberOfTuples());
1202         values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1203                  0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1204                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1205                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1206                  5.0423700574830965, 17.435300118916864]
1207         tmp=f2.getArray().getValues();
1208         self.assertEqual(len(tmp),len(values2))
1209         for i in range(len(tmp)):
1210             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1211             pass
1212         #
1213         f1.applyFunc(1,"x+y");
1214         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1215         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1216         self.assertEqual(1,f1.getNumberOfComponents());
1217         self.assertEqual(9,f1.getNumberOfTuples());
1218         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1219         tmp=f1.getArray().getValues();
1220         self.assertEqual(len(tmp),len(values1))
1221         for i in range(len(tmp)):
1222             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1223             pass
1224         pass
1225
1226     def testOperationsOnFields(self):
1227         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1228         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1229         f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1230         f1.checkConsistencyLight();
1231         f2.checkConsistencyLight();
1232         f3=f1+f2;
1233         f3.checkConsistencyLight();
1234         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1235         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1236         values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1237         tmp=f3.getArray().getValues();
1238         self.assertEqual(len(values1),len(tmp))
1239         for i in range(len(tmp)):
1240             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1241             pass
1242         #
1243         f3=f1*f2;
1244         f3.checkConsistencyLight();
1245         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1246         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1247         values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1248         tmp=f3.getArray().getValues();
1249         self.assertEqual(len(values2),len(tmp))
1250         for i in range(len(tmp)):
1251             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1252             pass
1253         #
1254         f3=f1+f2;
1255         f4=f1-f3;
1256         f4.checkConsistencyLight();
1257         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1258         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1259         values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1260         tmp=f4.getArray().getValues();
1261         self.assertEqual(len(values3),len(tmp))
1262         for i in range(len(tmp)):
1263             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1264             pass
1265         #
1266         f3=f1+f2;
1267         f4=f3/f2;
1268         f4.checkConsistencyLight();
1269         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1270         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1271         tmp=f4.getArray().getValues();
1272         for i in range(len(tmp)):
1273             self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1274             pass
1275         #
1276         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1277         f4.checkConsistencyLight();
1278         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1279         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1280         self.assertRaises(InterpKernelException,f1.__add__,f4);
1281         f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1282         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1283         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1284         f3=f1+f5;
1285         tmp=f3.getArray().getValues();
1286         values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1287         self.assertEqual(len(values3),len(tmp))
1288         for i in range(len(tmp)):
1289             self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1290             pass
1291         #
1292         f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1293         f4.checkConsistencyLight();
1294         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1295         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1296         self.assertRaises(InterpKernelException,f1.__add__,f4);
1297         f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1298         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1299         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1300         f3=f1+f5;
1301         tmp=f3.getArray().getValues();
1302         values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1303         self.assertEqual(len(values5),len(tmp))
1304         for i in range(len(tmp)):
1305             self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1306             pass
1307         pass
1308
1309     def testOperationsOnFields2(self):
1310         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1311         m.setTime(3.4,5,6); m.setTimeUnit("us");
1312         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1313         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1314         f3=f1/f2;
1315         f3.checkConsistencyLight();
1316         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1317         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1318         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1319                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1320                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1321         self.assertEqual(1,f3.getNumberOfComponents());
1322         self.assertEqual(9,f3.getNumberOfTuples());
1323         val=f3.getArray().getValues();
1324         for i in range(9):
1325             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1326         #
1327         f1=m.buildOrthogonalField();
1328         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1329         self.assertEqual("us",f1.getTimeUnit())
1330         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1331         f3=f1*f2;
1332         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]
1333         val=f3.getArray().getValues();
1334         for i in range(15):
1335             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1336             pass
1337         #
1338         f3=f2*f1;
1339         val=f3.getArray().getValues();
1340         for i in range(15):
1341             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1342             pass
1343         pass
1344
1345     def testOperationsOnFields3(self):
1346         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1347         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1348         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1349         f1/=f2
1350         f1.checkConsistencyLight();
1351         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1352         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1353         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1354                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1355                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1356         self.assertEqual(1,f1.getNumberOfComponents());
1357         self.assertEqual(9,f1.getNumberOfTuples());
1358         val=f1.getArray().getValues();
1359         for i in range(9):
1360             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1361             pass
1362         #
1363         f1=m.buildOrthogonalField();
1364         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1365         f1*=f2
1366         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]
1367         val=f1.getArray().getValues();
1368         for i in range(15):
1369             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1370             pass
1371         #
1372         f1=m.buildOrthogonalField();
1373         # to avoid valgrind leaks
1374         # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1375         pass
1376
1377     def testOperationsOnFields4(self):
1378         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1379         nbOfCells=m.getNumberOfCells();
1380         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1381         f1.setMesh(m);
1382         array=DataArrayDouble.New();
1383         f1.setArray(array);
1384         self.assertRaises(InterpKernelException,f1.setEndArray,array);
1385         self.assertRaises(InterpKernelException,f1.getEndArray);
1386         arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1387         arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1388         array.setValues(arr1,nbOfCells,3);
1389         f1.setStartTime(2.,0,0);
1390         f1.setEndTime(3.,0,0);
1391         f1.checkConsistencyLight();
1392         pos=[0.3,-0.2]
1393         res=f1.getValueOn(pos);
1394         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1395         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1396         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1397         res=None
1398         res=f1.getValueOn(pos,2.2);
1399         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1400         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1401         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1402         res=None
1403         self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1404         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1405         f2.setMesh(m);
1406         f2.setArray(f1.getArray());
1407         f2.setStartTime(2.,3,0);
1408         f2.setEndTime(4.,13,0);
1409         self.assertRaises(InterpKernelException,f2.checkConsistencyLight)
1410         array2=DataArrayDouble.New();
1411         array2.setValues(arr2,nbOfCells,3);
1412         f2.setEndArray(array2);
1413         f2.checkConsistencyLight();
1414         #
1415         res=None
1416         res=f2.getValueOn(pos,3.21);
1417         self.assertTrue(abs(4.025-res[0])<1.e-12);
1418         self.assertTrue(abs(14.025-res[1])<1.e-12);
1419         self.assertTrue(abs(24.025-res[2])<1.e-12);
1420         f3=f2.clone(True);
1421         self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1422         f3.getEndArray().setIJ(0,0,5.001);
1423         self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1424         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1425         f3.setStartTime(2.1,3,0);
1426         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1427         f3.setStartTime(2.,3,0);
1428         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1429         f3.setStartTime(2.,4,0);
1430         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1431         f3.setStartTime(2.,3,1);
1432         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1433         f3.setStartTime(2.,3,0);
1434         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1435         f3.setEndTime(4.1,13,0);
1436         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1437         f3.setEndTime(4.,13,0);
1438         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1439         f3.setEndTime(4.,14,0);
1440         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1441         f3.setEndTime(4.,13,1);
1442         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1443         f3.setEndTime(4.,13,0);
1444         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1445         f4=f2+f2
1446         res=None
1447         res=f4.getValueOn(pos,3.21);
1448         self.assertTrue(abs(8.05-res[0])<1.e-12);
1449         self.assertTrue(abs(28.05-res[1])<1.e-12);
1450         self.assertTrue(abs(48.05-res[2])<1.e-12);
1451         f4+=f2;
1452         res=None
1453         res=f4.getValueOn(pos,3.21);
1454         self.assertTrue(abs(12.075-res[0])<1.e-12);
1455         self.assertTrue(abs(42.075-res[1])<1.e-12);
1456         self.assertTrue(abs(72.075-res[2])<1.e-12);
1457         pass
1458
1459     def testMergeNodesOnField(self):
1460         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1461         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1462         f1.mergeNodes(1e-10);
1463         #
1464         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1465         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1466         tmp=f1.getArray()
1467         tmp.setIJ(0,0,1000.);
1468         f1.mergeNodes(1e-10);
1469         #
1470         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1471         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1472         tmp=f1.getArray()
1473         tmp.setIJ(1,0,1000.);
1474         self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1475         pass
1476
1477     def testCheckConsecutiveCellTypes(self):
1478         sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1479         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1480         self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1481         order1=[NORM_TRI3,NORM_QUAD4]
1482         order2=[NORM_QUAD4,NORM_TRI3]
1483         self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1484         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1485         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1486         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1487         self.assertEqual(5,da.getNumberOfTuples());
1488         self.assertEqual(1,da.getNumberOfComponents());
1489         expected1=[2,0,1,3,4]
1490         self.assertTrue(expected1==list(da.getValues()));
1491         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1492         self.assertEqual(5,da.getNumberOfTuples());
1493         self.assertEqual(1,da.getNumberOfComponents());
1494         expected2=[0,3,4,1,2]
1495         self.assertTrue(expected2==list(da.getValues()));
1496         renumber1=[4,0,1,2,3]
1497         targetMesh.renumberCells(renumber1,False);
1498         self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1499         self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1500         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1501         pass
1502
1503     def testRearrange2ConsecutiveCellTypes(self):
1504         m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1505         m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1506         arr1=m1_1.rearrange2ConsecutiveCellTypes();
1507         m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1508         self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1509         expected1=[0,1]
1510         self.assertEqual(2,arr1.getNumberOfTuples());
1511         self.assertEqual(1,arr1.getNumberOfComponents());
1512         self.assertEqual(expected1,arr1.getValues());
1513         expected2=[0,3,4,1,2]
1514         arr1=m2_1.rearrange2ConsecutiveCellTypes();
1515         self.assertEqual(5,arr1.getNumberOfTuples());
1516         self.assertEqual(1,arr1.getNumberOfComponents());
1517         self.assertEqual(expected2,list(arr1.getValues()));
1518         m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1519         self.assertEqual(5,arr1.getNumberOfTuples());
1520         self.assertEqual(1,arr1.getNumberOfComponents());
1521         self.assertEqual(expected2,list(arr1.getValues()));
1522         self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1523         m2_2.renumberCells(expected2,False);
1524         self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1525         pass
1526
1527     def testSplitByType(self):
1528         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1529         v=m1.splitByType();
1530         self.assertEqual(3,len(v));
1531         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1532         m2.setName(m1.getName());
1533         self.assertTrue(m1.isEqual(m2,1.e-12));
1534         pass
1535
1536     def testFuseUMeshesOnSameCoords(self):
1537         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1538         cells1=[2,3,4]
1539         m3=m2.buildPartOfMySelf(cells1,True);
1540         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1541         cells2=[1,2,4]
1542         m4=m2.buildPartOfMySelf(cells2,True);
1543         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1544         cells3=[1,2]
1545         m5=m2.buildPartOfMySelf(cells3,True);
1546         self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1547         meshes=[m3,m4,m5]
1548         #
1549         m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1550         self.assertEqual(4,m7.getNumberOfCells());
1551         self.assertEqual(3,len(corr));
1552         expectedVals1=[3,3,2]
1553         expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1554         for i in range(3):
1555             arr=corr[i];
1556             self.assertEqual(1,arr.getNumberOfComponents());
1557             nbOfVals=expectedVals1[i];
1558             self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1559             vals=arr.getValues();
1560             self.assertEqual(expectedVals2[i],list(vals));
1561             pass
1562         arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1563         fidExp=[5,1,3,4]
1564         fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1565         self.assertEqual(3,len(fidsOfGroups));
1566         self.assertEqual(1,arr2.getNumberOfComponents());
1567         self.assertEqual(4,arr2.getNumberOfTuples());
1568         self.assertEqual(fidExp,list(arr2.getValues()));
1569         for i in range(3):
1570             nbOfVals=expectedVals1[i];
1571             self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1572             pass
1573         pass
1574
1575     def testFuseUMeshesOnSameCoords2(self):
1576         m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1577         part1=[2,3,6,4,10]
1578         m3=m1.buildPartOfMySelf(part1,True);
1579         part2=[5,6,4,7]
1580         m4=m1.buildPartOfMySelf(part2,True);
1581         meshes=[m1,m3,m3,m4]
1582         m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1583         self.assertEqual(18,m5.getNumberOfCells());
1584         exp2=[
1585             [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1586             [2,3,6,4,10],
1587             [2,3,6,4,10],
1588             [5,6,4,7]]
1589         i=0;
1590         for it in corr:
1591             self.assertEqual(exp2[i],list(it.getValues()));
1592             i+=1
1593             pass
1594         pass
1595
1596     def testBuildOrthogonalField(self):
1597         targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1598         field=targetMesh.buildOrthogonalField();
1599         expected=[0.70710678118654746,0.,-0.70710678118654746]
1600         self.assertEqual(5,field.getNumberOfTuples());
1601         self.assertEqual(3,field.getNumberOfComponents());
1602         vals=field.getArray().getValues();
1603         for i in range(15):
1604             self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1605         # testing
1606         targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1607         targetConn=[0,1,2,3]
1608         targetMesh=MEDCouplingUMesh.New();
1609         targetMesh.setMeshDimension(2);
1610         targetMesh.allocateCells(1);
1611         targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1612         targetMesh.finishInsertingCells();
1613         myCoords=DataArrayDouble.New();
1614         myCoords.setValues(targetCoords,4,3);
1615         targetMesh.setCoords(myCoords);
1616         field=targetMesh.buildOrthogonalField();
1617         self.assertEqual(1,field.getNumberOfTuples());
1618         self.assertEqual(3,field.getNumberOfComponents());
1619         vals=field.getArray().getValues();
1620         self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1621         self.assertTrue(abs(0.-vals[1])<1e-12);
1622         self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1623         pass
1624
1625     def testGetCellsContainingPoint(self):
1626         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1627         pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1628         #2D basic
1629         t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1630         self.assertEqual(6,t1.getNumberOfTuples());
1631         self.assertEqual(1,t1.getNumberOfComponents());
1632         self.assertEqual(7,t2.getNumberOfTuples());
1633         self.assertEqual(1,t2.getNumberOfComponents());
1634         expectedValues1=[0,4,3,0,1,2]
1635         expectedValues2=[0,1,2,3,4,5,6]
1636         self.assertEqual(list(t1.getValues()),expectedValues1);
1637         self.assertEqual(list(t2.getValues()),expectedValues2);
1638         #2D with no help of bounding box.
1639         center=[0.2,0.2]
1640         MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1641         targetMesh.rotate(center,0.78539816339744830962);
1642         t1=None
1643         t2=None
1644         t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1645         self.assertEqual(6,t1.getNumberOfTuples());
1646         self.assertEqual(7,t2.getNumberOfTuples());
1647         self.assertEqual(list(t1.getValues()),expectedValues1);
1648         self.assertEqual(list(t2.getValues()),expectedValues2);
1649         t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1650         self.assertEqual(6,t1.getNumberOfTuples());
1651         self.assertEqual(7,t2.getNumberOfTuples());
1652         self.assertEqual(list(t1.getValues()),expectedValues1);
1653         self.assertEqual(list(t2.getValues()),expectedValues2);
1654         self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1655         #2D outside
1656         pos1bis=[-0.3303300858899107,-0.11819805153394641]
1657         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1658         #test limits 2D
1659         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1660         pos2=[0.2,-0.05]
1661         t1=None
1662         t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1663         self.assertEqual(2,len(t1));
1664         expectedValues3=[0,1]
1665         self.assertEqual(list(t1.getValues()),expectedValues3);
1666         pos3=[0.2,0.2]
1667         t1=None
1668         t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1669         self.assertEqual(5,len(t1));
1670         expectedValues4=[0,1,2,3,4]
1671         self.assertEqual(list(t1.getValues()),expectedValues4);
1672         self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1673         #3D
1674         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1675         pos4=[25.,25.,25.]
1676         self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1677         pos5=[50.,50.,50.]
1678         t1=None
1679         t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1680         self.assertEqual(8,len(t1));
1681         expectedValues5=[0,1,2,3,4,5,6,7]
1682         self.assertEqual(list(t1.getValues()),expectedValues5);
1683         pos6=[0., 50., 0.]
1684         t1=None
1685         t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1686         self.assertEqual(2,len(t1));
1687         expectedValues6=[0,2]
1688         self.assertEqual(list(t1.getValues()),expectedValues6);
1689         #3D outside
1690         pos7=[-1.0,-1.0,0.]
1691         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1692         #3D outside 2
1693         center2=[0.,0.,0.]
1694         vec2=[0.,-1.,0.]
1695         targetMesh.rotate(center2,vec2,0.78539816339744830962);
1696         pos8=[-25.,25.,12.]
1697         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1698         pass
1699
1700     def testGetValueOn1(self):
1701         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1702         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1703         nbOfCells=targetMesh.getNumberOfCells();
1704         fieldOnCells.setMesh(targetMesh);
1705         array=DataArrayDouble.New();
1706         tmp=2*nbOfCells*[None]
1707         for i in range(nbOfCells):
1708             tmp[2*i]=7.+float(i);
1709             tmp[2*i+1]=17.+float(i)
1710             pass
1711         array.setValues(tmp,nbOfCells,2);
1712         fieldOnCells.setArray(array);
1713         #
1714         pos1=[0.25,0.]
1715         res=fieldOnCells.getValueOn(pos1);
1716         self.assertEqual(2,len(res))
1717         self.assertTrue(abs(8.-res[0])<1e-12);
1718         self.assertTrue(abs(18.-res[1])<1e-12);
1719         #
1720         #
1721         targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1722         fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1723         nbOfNodes=targetMesh.getNumberOfNodes();
1724         fieldOnNodes.setMesh(targetMesh);
1725         array=DataArrayDouble.New();
1726         tmp=2*nbOfNodes*[None]
1727         for i in range(nbOfNodes):
1728             tmp[2*i]=17.+float(i);
1729             tmp[2*i+1]=27.+float(i)
1730             pass
1731         array.setValues(tmp,nbOfNodes,2);
1732         fieldOnNodes.setArray(array);
1733         #
1734         pos2=[-0.13333333333333333,-0.13333333333333333]
1735         res=None
1736         res=fieldOnNodes.getValueOn(pos2);
1737         self.assertEqual(2,len(res))
1738         self.assertTrue(abs(17.5-res[0])<1e-12);
1739         self.assertTrue(abs(27.5-res[1])<1e-12);
1740         pos3=[0.033333333333333326,0.36666666666666664]
1741         res=None
1742         res=fieldOnNodes.getValueOn(pos3);
1743         self.assertEqual(2,len(res))
1744         self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1745         self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1746         pass
1747
1748     def testCMesh0(self):
1749         mesh=MEDCouplingCMesh.New();
1750         meshEmpty=mesh.clone(True);
1751         self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1752
1753         coordsX=DataArrayDouble.New();
1754         arrX=[ -1., 1., 2., 4. ]
1755         coordsX.setValues(arrX, 4, 1);
1756         coordsY=DataArrayDouble.New();
1757         arrY=[ -2., 2., 4., 8. ]
1758         coordsY.setValues(arrY, 4, 1);
1759         coordsZ=DataArrayDouble.New();
1760         arrZ=[ -3., 3., 6., 12. ]
1761         coordsZ.setValues(arrZ, 4, 1);
1762         mesh.setCoords(coordsX, coordsY, coordsZ);
1763         #
1764         fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1765         self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1766         self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1767         expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1768                     4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1769                     7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1770                     7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1771
1772         val=fieldOnNodes.getArray().getValues();
1773         for i in range(64):
1774           self.assertAlmostEqual(expected1[i], val[i], 12)
1775         res=fieldOnNodes.getValueOnPos(1, 3, 2);
1776         self.assertAlmostEqual(7., res[0], 12);
1777         #
1778         fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1779         self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1780         self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1781         val=fieldOnCells.getArray().getValues();
1782         expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1783                     6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1784         for i in range(27):
1785           self.assertAlmostEqual(expected2[i], val[i], 12);
1786         #res=fieldOnCells.getValueOnPos(1,2,1);
1787         #self.assertAlmostEqual(6.,res,12);
1788         #
1789         meshDeepCopy=mesh.deepCopy();
1790         meshClone=mesh.clone(False);
1791
1792         meshEmpty.copyTinyStringsFrom(mesh);
1793         #no data in meshEmpty, expected False
1794         self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1795
1796         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1797         meshDeepCopy.copyTinyStringsFrom(mesh);
1798         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1799         self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1800
1801         self.assertEqual(CARTESIAN, mesh.getType());
1802         self.assertEqual(CARTESIAN, meshEmpty.getType());
1803         self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1804         self.assertEqual(CARTESIAN, meshClone.getType());
1805         pass
1806
1807     def testCMesh1(self):
1808         mesh1=MEDCouplingCMesh.New();
1809         coordsX1=DataArrayDouble.New();
1810         arrX1=[ -1., 1., 2., 4. ]
1811         coordsX1.setValues(arrX1, 4, 1);
1812         coordsY1=DataArrayDouble.New();
1813         arrY1=[ -2., 2., 4., 8. ]
1814         coordsY1.setValues(arrY1, 4, 1);
1815         coordsZ1=DataArrayDouble.New();
1816         arrZ1=[ -3., 3., 6., 12. ]
1817         coordsZ1.setValues(arrZ1, 4, 1);
1818         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1819
1820         mesh2=MEDCouplingCMesh.New();
1821         coordsX2=DataArrayDouble.New();
1822         arrX2=[ -1., 1., 2., 4. ]
1823         coordsX2.setValues(arrX2, 4, 1);
1824         coordsY2=DataArrayDouble.New();
1825         arrY2=[ -2., 2., 4., 8. ]
1826         coordsY2.setValues(arrY2, 4, 1);
1827         coordsZ2=DataArrayDouble.New();
1828         arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1829         coordsZ2.setValues(arrZ2, 4, 1);
1830         mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1831
1832         mesh3=MEDCouplingCMesh.New();
1833         coordsX3=DataArrayDouble.New();
1834         arrX3=[-1.]
1835         coordsX3.setValues(arrX3, 1, 1);
1836         coordsY3=DataArrayDouble.New();
1837         arrY3=[-2.]
1838         coordsY3.setValues(arrY3, 1, 1);
1839         coordsZ3=DataArrayDouble.New();
1840         arrZ3=[-3.]
1841         coordsZ3.setValues(arrZ3, 1, 1);
1842         mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1843
1844         self.assertEqual(3, mesh1.getSpaceDimension());
1845         self.assertEqual(3, mesh1.getMeshDimension());
1846
1847         self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1848         self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1849         self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1850         self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1851         self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1852
1853         self.assertRaises(InterpKernelException, mesh3.checkConsistency, 1e-12);
1854         mesh1.checkConsistency(1e-12);
1855         self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1856
1857         self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1858         self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1859         self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1860
1861         coo=mesh1.getCoordinatesOfNode(0);
1862         self.assertEqual(3, len(coo));
1863         self.assertAlmostEqual(-1., coo[0], 14);
1864         self.assertAlmostEqual(-2., coo[1], 14);
1865         self.assertAlmostEqual(-3., coo[2], 14);
1866         coo=mesh1.getCoordinatesOfNode(63);
1867         self.assertEqual(3, len(coo));
1868         self.assertAlmostEqual(4., coo[0], 14);
1869         self.assertAlmostEqual(8., coo[1], 14);
1870         self.assertAlmostEqual(12., coo[2], 14);
1871
1872         a=str(mesh1)
1873         repr=mesh1.simpleRepr();
1874         repr=mesh1.advancedRepr();
1875         self.assertTrue("Cartesian" in repr);
1876         self.assertTrue("Number of components : 1" in repr);
1877         self.assertTrue("Number of tuples : 4" in repr);
1878         self.assertTrue("Z Array :" in repr);
1879         pass
1880
1881     def testCMesh2(self):
1882         mesh1=MEDCouplingCMesh.New();
1883         coordsX1=DataArrayDouble.New();
1884         arrX1=[ -1., 1., 2., 4. ]
1885         coordsX1.setValues(arrX1, 4, 1);
1886         coordsY1=DataArrayDouble.New();
1887         arrY1=[ -2., 2., 4., 8. ]
1888         coordsY1.setValues(arrY1, 4, 1);
1889         coordsZ1=DataArrayDouble.New();
1890         arrZ1=[ -3., 3., 6., 12. ]
1891         coordsZ1.setValues(arrZ1, 4, 1);
1892         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1893
1894         dis=mesh1.getDistributionOfTypes();
1895         self.assertEqual(1, len(dis));
1896         self.assertEqual(NORM_HEXA8, dis[0][0]);
1897         self.assertEqual(27, dis[0][1]);
1898         self.assertEqual(-1, dis[0][2]);
1899
1900         idsPerType=[]
1901         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1902         dis[0][0]=NORM_QUAD4;
1903         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1904         dis[0][0]=NORM_HEXA8;
1905         dis[0][2]=0;
1906         ids=DataArrayInt.New();
1907         ids.alloc(10, 1);
1908         ids.fillWithValue(23);
1909         idsPerType=[ids];
1910         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1911         self.assertTrue(check);
1912         self.assertTrue(check.isEqual(ids));
1913
1914         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1915         self.assertEqual(1, len(code));
1916         self.assertEqual(NORM_HEXA8, code[0][0]);
1917         self.assertEqual(10, code[0][1]);
1918         self.assertEqual(0, code[0][2]);
1919         self.assertEqual(1, len(idsInPflPerType));
1920         self.assertEqual(1, len(pfls));
1921         self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1922         self.assertTrue(pfls[0].isEqual(ids));
1923
1924         cells1=[0, 1, 25, 26]
1925         partMesh1=mesh1.buildPart(cells1)
1926         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1927         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1928         self.assertEqual(64, mesh1.getNumberOfNodes());
1929         self.assertEqual(64, partMesh1.getNumberOfNodes());
1930
1931         cells2=[25, 26]
1932         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1933         self.assertTrue(isinstance(partMesh2,MEDCouplingCMesh))
1934         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1935         self.assertEqual(12,partMesh2.getNumberOfNodes());
1936
1937         cells3=[2, 3]
1938         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1939         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1940         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1941         self.assertEqual(12, partMesh3.getNumberOfNodes());
1942
1943         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1944         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1945
1946         #double bbox1[6];
1947         #double bbox2[6];
1948         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1949         bbox2=partMesh1.getBoundingBox();
1950         self.assertTrue(bbox1==bbox2);
1951         bbox1=partMesh3.getBoundingBox();
1952         bbox2=partMesh2.getBoundingBox();
1953         self.assertTrue(bbox1==bbox2);
1954
1955         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1956         mesh2d=MEDCouplingCMesh.New();
1957         mesh2d.setCoords(coordsX1, coordsY1);
1958         f1=mesh2d.buildOrthogonalField();
1959
1960         pass
1961
1962     def testScale(self):
1963         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1964         pos=[0.2,0.2]
1965         mesh.scale(pos,0.5);
1966         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,
1967                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1968         val=mesh.getCoords().getValues();
1969         self.assertEqual(18,len(val))
1970         for i in range(18):
1971             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1972             pass
1973         pass
1974
1975     def testTryToShareSameCoords(self):
1976         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1977         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1978         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1979         m1.tryToShareSameCoords(m2,1e-12);
1980         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1981         m1.tryToShareSameCoords(m2,1e-12);
1982         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1983         m2.tryToShareSameCoords(m1,1e-12);
1984         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1985         #
1986         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1987         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1988         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1989         m1.tryToShareSameCoords(m2,1e-12);
1990         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1991         m1.tryToShareSameCoords(m2,1e-12);
1992         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1993         m2.tryToShareSameCoords(m1,1e-12);
1994         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1995         #
1996         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1997         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1998         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1999         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
2000         pass
2001
2002     def testFindNodeOnPlane(self):
2003         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
2004         pt=[300.,300.,0.]
2005         v=[0.,0.,2.]
2006         n=mesh.findNodesOnPlane(pt,v,1e-12);
2007         self.assertEqual(9,len(n));
2008         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2009         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2010         me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2011         da=me.getMesh3DIds();
2012         self.assertEqual(8,me.getNumberOfCells());
2013         expected=[0,1,2,3,4,5,6,7]
2014         val=da.getValues();
2015         self.assertEqual(expected,list(val));
2016         #
2017         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2018         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2019         me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2020         da=me.getMesh3DIds();
2021         self.assertEqual(8,me.getNumberOfCells());
2022         expected=[0,1,2,3,4,5,6,7]
2023         val=da.getValues();
2024         self.assertEqual(expected,list(val));
2025         pass
2026
2027     def testRenumberCells(self):
2028         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2029         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2030         self.assertTrue(m.isEqual(m2,0));
2031         arr=[12,3,25,2,26]
2032         m.renumberCells(arr,True);
2033         self.assertTrue(not m.isEqual(m2,0));
2034         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
2035         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2036         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
2037         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2038         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
2039         arr2=[5,-1,-5,4,8]
2040         m.renumberCells(arr2,True);
2041         self.assertTrue(m.isEqual(m2,0));
2042         pass
2043
2044     def testChangeSpaceDimension(self):
2045         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2046         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2047         #
2048         self.assertEqual(3,m1.getSpaceDimension());
2049         m1.changeSpaceDimension(2);
2050         self.assertEqual(2,m1.getSpaceDimension());
2051         m1.setName(m2.getName());
2052         self.assertTrue(m1.isEqual(m2,1e-12));
2053         m1.changeSpaceDimension(3);
2054         self.assertEqual(3,m1.getSpaceDimension());
2055         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.]
2056         val=m1.getCoords().getValues();
2057         for i in range(27):
2058             self.assertTrue(abs(expected[i]-val[i])<1e-14);
2059             pass
2060         pass
2061
2062     def testGaussPointField1(self):
2063         _a=0.446948490915965;
2064         _b=0.091576213509771;
2065         _p1=0.11169079483905;
2066         _p2=0.0549758718227661;
2067         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2068         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2069                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2070         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2071         _refCoo1=refCoo1
2072         _gsCoo1=gsCoo1
2073         _wg1=wg1
2074         #
2075         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2076         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2077         f.setMesh(m);
2078         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2079         self.assertEqual(0,f.getNbOfGaussLocalization());
2080         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2081         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2082         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2083         self.assertEqual(1,f.getNbOfGaussLocalization());
2084         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2085         _refCoo2=refCoo2
2086         _gsCoo1=_gsCoo1[0:4]
2087         _wg1=_wg1[0:2]
2088         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2089         self.assertEqual(2,f.getNbOfGaussLocalization());
2090         array=DataArrayDouble.New();
2091         ptr=18*2*[None]
2092         for i in range(18 * 2):
2093             ptr[i]=float(i+1)
2094         array.setValues(ptr,18,2);
2095         ptr=array.getPointer();
2096         f.setArray(array);
2097         f.setName("MyFirstFieldOnGaussPoint");
2098         f.checkConsistencyLight();
2099         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2100         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2101         #
2102         f.clearGaussLocalizations();
2103         self.assertEqual(0,f.getNbOfGaussLocalization());
2104         self.assertRaises(InterpKernelException,f.checkConsistencyLight);
2105         ids1=[0,1,3,4]
2106         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2107         self.assertEqual(0,f.getNbOfGaussLocalization());
2108         ids2=[0,4]
2109         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2110         self.assertEqual(1,f.getNbOfGaussLocalization());
2111         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2112         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2113         ids3=[1,2]
2114         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2115         self.assertEqual(2,f.getNbOfGaussLocalization());
2116         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2117         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2118         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2119         self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- cell 3 has no localization
2120         ids4=[3]
2121         _gsCoo2=_gsCoo1;
2122         _wg2=_wg1;
2123         _gsCoo2[0]=0.8888777776666;
2124         _wg2[0]=0.1234567892377;
2125         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2126         self.assertEqual(3,f.getNbOfGaussLocalization());
2127         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2128         self.assertEqual(ids2,list(tmpIds.getValues()));
2129         self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- it's always not ok because undelying array not with the good size.
2130         array2=f.getArray().subArray(0,10);
2131         f.setArray(array2);
2132         f.checkConsistencyLight();#<- here it is OK
2133         f2=f.clone(True);
2134         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2135         gl1=f2.getGaussLocalization(0);
2136         tmp=gl1.getGaussCoord(1,1);
2137         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2138         gl1.setGaussCoord(1,1,0.07);
2139         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2140         gl1.setGaussCoord(1,1,tmp);
2141         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2142         f2.checkConsistencyLight();
2143         pass
2144
2145     def testGaussPointNEField1(self):
2146         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2147         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2148         f.setMesh(m);
2149         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2150         f.setName("MyFirstFieldOnNE");
2151         f.setDescription("MyDescriptionNE");
2152         array=DataArrayDouble.New();
2153         tmp=18*2*[None]
2154         for i in range(18 * 2):
2155             tmp[i]=float(i+7)
2156             pass
2157         array.setValues(tmp,18,2);
2158         ptr=array.getPointer();
2159         f.setArray(array);
2160         #
2161         f.checkConsistencyLight();
2162         f2=f.clone(True);
2163         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2164         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2165         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2166         pass
2167
2168     def testCellOrientation1(self):
2169         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2170         vec=[0.,0.,-1.]
2171         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2172         m.changeSpaceDimension(3);
2173         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2174         self.assertTrue(len(res1)==0);
2175         vec[2]=1.;
2176         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2177         self.assertEqual(5,len(res1));
2178         #
2179         vec[2]=-1.;
2180         # connectivity inversion
2181         conn=m.getNodalConnectivity().getValues();
2182         tmp=conn[11];
2183         conn[11]=conn[12];
2184         conn[12]=tmp;
2185         m.getNodalConnectivity().setValues(conn,len(conn),1)
2186         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2187         self.assertEqual(1,len(res1));
2188         self.assertEqual(2,res1.getValues()[0]);
2189         m.orientCorrectly2DCells(vec,False);
2190         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2191         self.assertTrue(len(res1)==0);
2192         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2193         m2.changeSpaceDimension(3);
2194         self.assertTrue(m.isEqual(m2,1e-12));
2195         pass
2196
2197     def testCellOrientation2(self):
2198         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2199         res1=m2.arePolyhedronsNotCorrectlyOriented();
2200         self.assertEqual(6,len(res1));
2201         m2.orientCorrectlyPolyhedrons();
2202         res1=m2.arePolyhedronsNotCorrectlyOriented();
2203         self.assertTrue(len(res1)==0);
2204         m2.checkConsistencyLight();
2205         self.assertEqual(18,m2.getNumberOfCells());
2206         cellIds2=[0,6,12]
2207         m2.convertToPolyTypes(cellIds2);
2208         m2.orientCorrectlyPolyhedrons();
2209         res1=m2.arePolyhedronsNotCorrectlyOriented();
2210         self.assertTrue(len(res1)==0);
2211         f2=m2.getMeasureField(False);
2212         f2Ptr=f2.getArray().getValues();
2213         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2214         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2215         vec=[0.,0.,1.]
2216         m3.changeSpaceDimension(3);
2217         ids2=[0,1,2,3,4]
2218         m3.convertToPolyTypes(ids2);
2219         m3.orientCorrectly2DCells(vec,False);
2220         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2221         m4.changeSpaceDimension(3);
2222         center=[0.,0.,0.]
2223         vector=[0.,1.,0.]
2224         m4.rotate(center,vector,-pi/2.);
2225         m5=m3.buildExtrudedMesh(m4,0);
2226         res1=m5.arePolyhedronsNotCorrectlyOriented();
2227         self.assertEqual(15,len(res1));
2228         m5.orientCorrectlyPolyhedrons();
2229         res1=m5.arePolyhedronsNotCorrectlyOriented();
2230         self.assertTrue(len(res1)==0);
2231         f3=m5.getMeasureField(False);
2232         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2233         self.assertEqual(1,f3.getNumberOfComponents());
2234         f3Ptr=f3.getArray().getValues();
2235         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];
2236         for i in range(15):
2237             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2238             pass
2239         f4=m5.computeCellCenterOfMass();
2240         self.assertEqual(15,f4.getNumberOfTuples());
2241         self.assertEqual(3,f4.getNumberOfComponents());
2242         f4Ptr=f4.getValues();
2243         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];
2244         for i in range(45):
2245             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2246             pass
2247         pass
2248
2249     def testCellOrientation3(self):
2250         from cmath import rect
2251
2252         c = [rect(1.0, i * pi / 4.0) for i in range(8)]
2253         coords = [c[-1].real,c[-1].imag,  c[3].real,c[3].imag,
2254                    c[5].real,c[5].imag,  c[1].real,c[1].imag]
2255         connec = [0,1,2,3]
2256         baseMesh = MEDCouplingUMesh.New("circle", 2)
2257         baseMesh.allocateCells(1)
2258         meshCoords = DataArrayDouble.New(coords, 4, 2)
2259         baseMesh.setCoords(meshCoords)
2260         baseMesh.insertNextCell(NORM_QPOLYG, connec)  # a circle
2261         baseMesh.finishInsertingCells()
2262         baseMesh.changeSpaceDimension(3)
2263         Oz = [0.0, 0.0, -1.0]
2264         cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2265         self.assertEqual(cell_lst.getNumberOfTuples(), 0)
2266         Oz[2] = 1.0
2267         cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2268         self.assertEqual(cell_lst.getNumberOfTuples(), 1)
2269
2270     def testPolyhedronBarycenter(self):
2271         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];
2272         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];
2273         meshN=MEDCouplingUMesh.New();
2274         meshN.setName("ForBary");
2275         meshN.setMeshDimension(3);
2276         meshN.allocateCells(4);
2277         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2278         meshN.finishInsertingCells();
2279         myCoords=DataArrayDouble.New();
2280         myCoords.setValues(coords,9,3);
2281         meshN.setCoords(myCoords);
2282         meshN.checkConsistencyLight();
2283         #
2284         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2285         meshN.orientCorrectlyPolyhedrons();
2286         self.assertTrue(len(res1)==0);
2287         da=meshN.computeCellCenterOfMass();
2288         self.assertEqual(1,da.getNumberOfTuples());
2289         self.assertEqual(3,da.getNumberOfComponents());
2290         daPtr=da.getValues();
2291         ref=meshN.getCoords().getValues()[24:];
2292         for i in range(3):
2293             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2294             pass
2295         #
2296         center=[0.,0.,0.]
2297         vec=[0.,2.78,0.]
2298         da=meshN.computeCellCenterOfMass();
2299         daPtr=da.getValues();
2300         ref=meshN.getCoords().getValues()[24:];
2301         for i in range(3):
2302             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2303             pass
2304         #
2305         meshN.rotate(center,vec,pi/7.);
2306         meshN.translate(vec);
2307         da=meshN.computeCellCenterOfMass();
2308         daPtr=da.getValues();
2309         ref=meshN.getCoords().getValues()[24:];
2310         for i in range(3):
2311             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2312             pass
2313         #
2314         center2=[1.12,3.45,6.78]
2315         vec2=[4.5,9.3,2.8]
2316         meshN.rotate(center2,vec2,e);
2317         meshN.translate(vec2);
2318         da=meshN.computeCellCenterOfMass();
2319         daPtr=da.getValues();
2320         ref=meshN.getCoords().getValues()[24:];
2321         for i in range(3):
2322             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2323             pass
2324         pass
2325
2326     def testNormL12Integ1D(self):
2327         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2328         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2329         f1.setMesh(m1);
2330         array=DataArrayDouble.New();
2331         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]
2332         array.setValues(arr,m1.getNumberOfCells(),3);
2333         f1.setArray(array);
2334         #
2335         f3=m1.computeCellCenterOfMass();
2336         self.assertEqual(4,f3.getNumberOfTuples());
2337         self.assertEqual(1,f3.getNumberOfComponents());
2338         expected9=[0.75,5.105,0.8,5.155]
2339         ptr=f3.getValues();
2340         for i in range(4):
2341             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2342             pass
2343         #
2344         f2=m1.getMeasureField(False);
2345         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2346         self.assertEqual(1,f2.getNumberOfComponents());
2347         expected1=[0.5,0.21,-0.6,-0.31]
2348         ptr=f2.getArray().getValues();
2349         for i in range(4):
2350             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2351             pass
2352         expected2=[0.5,0.21,0.6,0.31]
2353         f2=m1.getMeasureField(True);
2354         ptr=f2.getArray().getValues();
2355         for i in range(4):
2356             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2357             pass
2358         #integral
2359         self.assertTrue(4,f1.getNumberOfTuples())
2360         res=f1.integral(False);
2361         self.assertTrue(3,len(res))
2362         expected3=[0.9866,-0.3615,0.4217]
2363         for i in range(3):
2364             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2365             pass
2366         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2367         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2368         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2369         res=f1.integral(True);
2370         expected4=[-3.4152,8.7639,-14.6879]
2371         for i in range(3):
2372             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2373             pass
2374         #normL1
2375         res=f1.normL1();
2376         self.assertTrue(3,len(res))
2377         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2378         for i in range(3):
2379             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2380             pass
2381         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2382         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2383         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2384         #normL2
2385         res=f1.normL2();
2386         self.assertTrue(3,len(res))
2387         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2388         for i in range(3):
2389             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2390             pass
2391         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2392         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2393         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2394         #buildMeasureField
2395         f4=f1.buildMeasureField(False);
2396         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2397         f4=f1.buildMeasureField(True);
2398         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2399         # Testing with 2D Curve
2400         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2401         f2=m1.getMeasureField(False);
2402         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2403         self.assertEqual(1,f2.getNumberOfComponents());
2404         ptr=f2.getArray().getValues();
2405         for i in range(4):
2406             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2407             pass
2408         f2=m1.getMeasureField(True);
2409         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2410         self.assertEqual(1,f2.getNumberOfComponents());
2411         ptr=f2.getArray().getValues();
2412         for i in range(4):
2413             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2414             pass
2415         #bary
2416         f3=m1.computeCellCenterOfMass();
2417         self.assertEqual(4,f3.getNumberOfTuples());
2418         self.assertEqual(2,f3.getNumberOfComponents());
2419         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2420         ptr=f3.getValues();
2421         for i in range(8):
2422             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2423             pass
2424         #
2425         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2426         f1.setMesh(m1);
2427         array=DataArrayDouble.New();
2428         array.setValues(arr,m1.getNumberOfCells(),3);
2429         f1.setArray(array);
2430         res=f1.integral(False);
2431         for i in range(3):
2432             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2433             pass
2434         res=f1.integral(True);
2435         for i in range(3):
2436             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2437             pass
2438         res=f1.normL1();
2439         for i in range(3):
2440             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2441             pass
2442         res=f1.normL2();
2443         for i in range(3):
2444             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2445             pass
2446         pass
2447
2448     def testAreaBary2D(self):
2449         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2450         f1=m1.getMeasureField(False);
2451         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2452         self.assertEqual(1,f1.getNumberOfComponents());
2453         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2454         ptr=f1.getArray().getValues();
2455         for i in range(10):
2456             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2457             pass
2458         f1=m1.getMeasureField(True);
2459         ptr=f1.getArray().getValues();
2460         for i in range(10):
2461             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2462             pass
2463         f2=m1.computeCellCenterOfMass();
2464         self.assertEqual(10,f2.getNumberOfTuples());
2465         self.assertEqual(2,f2.getNumberOfComponents());
2466         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]
2467         ptr=f2.getValues();
2468         for i in range(20):
2469             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2470             pass
2471         m1.changeSpaceDimension(3);
2472         f1=m1.getMeasureField(False);
2473         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2474         self.assertEqual(1,f1.getNumberOfComponents());
2475         ptr=f1.getArray().getValues();
2476         for i in range(10):
2477             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2478             pass
2479         f2=m1.computeCellCenterOfMass();
2480         self.assertEqual(10,f2.getNumberOfTuples());
2481         self.assertEqual(3,f2.getNumberOfComponents());
2482         ptr=f2.getValues();
2483         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.]
2484         for i in range(30):
2485             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2486             pass
2487         pass
2488
2489     def testAreaBary3D(self):
2490         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2491                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2492                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2493                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2494                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2495                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2496                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2497                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2498                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2499                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2500                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2501                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2502                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2503                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2504                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2505                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2506                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2507                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2508                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2509                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2510                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2511                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2512                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2513                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2514                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2515                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2516                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2517                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2518                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2519                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2520                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2521                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2522                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2523                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2524                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2525
2526         connN = [ #polyhedron 0
2527             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
2528             , 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
2529             , 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
2530             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2531             # polyhedron 1
2532             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
2533             , 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
2534             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2535             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2536             # polyhedron 2
2537             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
2538             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2539             # polyhedron 3
2540             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
2541             , 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
2542             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2543             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2544
2545         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2546                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2547                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2548                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2549         meshN=MEDCouplingUMesh.New();
2550         meshN.setName("ForBary");
2551         meshN.setMeshDimension(3);
2552         meshN.allocateCells(4);
2553         meshN.insertNextCell(NORM_POLYHED,113,connN);
2554         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2555         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2556         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2557         meshN.finishInsertingCells();
2558         myCoords=DataArrayDouble.New();
2559         myCoords.setValues(coords,69,3);
2560         meshN.setCoords(myCoords);
2561         meshN.checkConsistencyLight();
2562         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2563         meshN.orientCorrectlyPolyhedrons();
2564         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2565         self.assertTrue(len(res1)==0);
2566         #
2567         da=meshN.computeCellCenterOfMass();
2568         self.assertEqual(4,da.getNumberOfTuples());
2569         self.assertEqual(3,da.getNumberOfComponents());
2570         daPtr=da.getValues();
2571         for i in range(12):
2572             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2573             pass
2574         pass
2575
2576     def testRenumberCellsForFields(self):
2577         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2578         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2579         f.setMesh(m);
2580         arr=DataArrayDouble.New();
2581         nbOfCells=m.getNumberOfCells();
2582         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2583         arr.setValues(values1,nbOfCells,3);
2584         f.setArray(arr);
2585         renumber1=[3,1,0,4,2]
2586         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2587         for j in range(5):
2588             res=f.getValueOn(loc[2*j:2*j+2]);
2589             for i in range(3):
2590                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2591                 pass
2592             pass
2593         f.renumberCells(renumber1,False);
2594         ptr=f.getArray().getValues();
2595         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2596         for i in range(15):
2597             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2598             pass
2599         #check that fields remains the same geometrically
2600         for j in range(5):
2601             res=f.getValueOn(loc[2*j:2*(j+1)]);
2602             for i in range(3):
2603                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2604                 pass
2605             pass
2606         #On gauss
2607         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2608         f.setMesh(m);
2609         _a=0.446948490915965;
2610         _b=0.091576213509771;
2611         _p1=0.11169079483905;
2612         _p2=0.0549758718227661;
2613         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2614         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 ];
2615         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2616         _refCoo1=refCoo1[0:6];
2617         _gsCoo1=gsCoo1[0:12];
2618         _wg1=wg1[0:6];
2619         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2620         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2621         _refCoo2=refCoo2[0:8];
2622         _gsCoo1=_gsCoo1[0:4]
2623         _wg1=_wg1[0:2]
2624         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2625         arr=DataArrayDouble.New();
2626         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.]
2627         arr.setValues(values2,18,2);
2628         f.setArray(arr);
2629         f.checkConsistencyLight();
2630         fCpy=f.clone(True);
2631         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2632         f.renumberCells(renumber1,False);
2633         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2634         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.]
2635         ptr=f.getArray().getValues();
2636         for i in range(36):
2637             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2638             pass
2639         renumber2=[2,1,4,0,3]
2640         f.renumberCells(renumber2,False);
2641         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2642         #GaussNE
2643         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2644         f.setMesh(m);
2645         arr=DataArrayDouble.New();
2646         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.]
2647         arr.setValues(values3,18,2);
2648         f.setArray(arr);
2649         f.checkConsistencyLight();
2650         fCpy=f.clone(True);
2651         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2652         f.renumberCells(renumber1,False);
2653         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2654         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.]
2655         ptr=f.getArray().getValues();
2656         for i in range(36):
2657             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2658             pass
2659         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2660         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2661         #
2662         pass
2663
2664     def testRenumberNodesForFields(self):
2665         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2666         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2667         f.setMesh(m);
2668         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2669         arr=DataArrayDouble.New();
2670         nbOfNodes=m.getNumberOfNodes();
2671         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.]
2672         arr.setValues(values1,nbOfNodes,3);
2673         f.setArray(arr);
2674         f.checkConsistencyLight();
2675         renumber1=[0,4,1,3,5,2,6,7,8]
2676         loc=[0.5432,-0.2432, 0.5478,0.1528]
2677         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2678         for j in range(2):
2679             res=f.getValueOn(loc[2*j:2*j+2]);
2680             for i in range(3):
2681                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2682                 pass
2683             pass
2684         fCpy=f.clone(True);
2685         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2686         f.renumberNodes(renumber1);
2687         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2688         for j in range(2):
2689             res=f.getValueOn(loc[2*j:2*j+2]);
2690             for i in range(3):
2691                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2692                 pass
2693             pass
2694         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.]
2695         for i in range(27):
2696             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2697             pass
2698         renumber2=[0,2,5,3,1,4,6,7,8]
2699         f.renumberNodes(renumber2);
2700         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2701         pass
2702
2703     def testConvertQuadraticCellsToLinear(self):
2704         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2705         mesh.checkConsistencyLight();
2706         types=mesh.getAllGeoTypes();
2707         types.sort()
2708         self.assertEqual(5,len(types));
2709         expected1 = [NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2710         expected1.sort()
2711         self.assertEqual(expected1,types);
2712         self.assertTrue(mesh.isPresenceOfQuadratic());
2713         self.assertEqual(62,mesh.getNodalConnectivityArrayLen());
2714         f1=mesh.getMeasureField(False);
2715         #
2716         mesh.convertQuadraticCellsToLinear();
2717         self.assertTrue(not mesh.isPresenceOfQuadratic());
2718         #
2719         mesh.checkConsistencyLight();
2720         f2=mesh.getMeasureField(False);
2721         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2722         self.assertEqual(48,mesh.getNodalConnectivityArrayLen());
2723         types2=mesh.getAllGeoTypes();
2724         types2.sort()
2725         self.assertEqual(3,len(types2));
2726         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2727         expected2.sort()
2728         self.assertEqual(expected2,types2);
2729         pass
2730
2731     def testCheckGeoEquivalWith(self):
2732         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2733         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2734         #First test mesh1
2735         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2736         self.assertTrue(cellCor==None);
2737         self.assertTrue(nodeCor==None);
2738         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2739         self.assertTrue(cellCor==None);
2740         self.assertTrue(nodeCor==None);
2741         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2742         self.assertTrue(cellCor==None);
2743         self.assertTrue(nodeCor==None);
2744         #Second test mesh1 and mesh2 are 2 different meshes instance
2745         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2746         self.assertTrue(cellCor==None);
2747         self.assertTrue(nodeCor==None);
2748         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2749         self.assertTrue(cellCor==None);
2750         self.assertTrue(nodeCor==None);
2751         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2752         self.assertTrue(cellCor==None);
2753         self.assertTrue(nodeCor==None);
2754         #Third test : cell permutation by keeping the first the middle and the last as it is.
2755         renum=[0,2,1,3,4,5,6,8,7,9]
2756         mesh2.renumberCells(renum,False);
2757         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2758         self.assertTrue(cellCor==None);
2759         self.assertTrue(nodeCor==None);
2760         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2761         self.assertTrue(cellCor==None);
2762         self.assertTrue(nodeCor==None);
2763         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2764         self.assertTrue(cellCor);
2765         self.assertEqual(10,cellCor.getNumberOfTuples());
2766         self.assertEqual(1,cellCor.getNumberOfComponents());
2767         self.assertEqual(renum,list(cellCor.getValues()))
2768         self.assertTrue(nodeCor==None);
2769         cellCor=0;
2770         self.assertTrue(nodeCor==None);
2771         a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2772         self.assertEqual(renum,list(a.getValues()))
2773         self.assertTrue(b==None);
2774         mesh2.setCoords(mesh1.getCoords())
2775         a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2776         self.assertEqual(renum,list(a.getValues()))
2777         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2778         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2779         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2780         mesh2.renumberCells(renum,False);
2781         mesh2.renumberNodes(renum2,11);
2782         cellCor=None
2783         nodeCor=None
2784         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2785         self.assertTrue(cellCor==None);
2786         self.assertTrue(nodeCor==None);
2787         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2788         self.assertTrue(cellCor==None);
2789         self.assertTrue(nodeCor==None);
2790         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2791         self.assertTrue(cellCor);
2792         self.assertEqual(10,cellCor.getNumberOfTuples());
2793         self.assertEqual(1,cellCor.getNumberOfComponents());
2794         self.assertEqual(renum,list(cellCor.getValues()))
2795         self.assertTrue(nodeCor);
2796         self.assertEqual(11,nodeCor.getNumberOfTuples());
2797         self.assertEqual(1,nodeCor.getNumberOfComponents());
2798         self.assertEqual(renum2,list(nodeCor.getValues()))
2799         cellCor=0;
2800         nodeCor=0;
2801         #5th test : modification of the last cell to check fastCheck detection.
2802         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2803         renum3=[0,2,1,3,4,5,6,8,9,7]
2804         mesh2.renumberCells(renum3,False);
2805         mesh2.renumberNodes(renum2,11);
2806         cellCor=None
2807         nodeCor=None
2808         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2809         self.assertTrue(cellCor==None);
2810         self.assertTrue(nodeCor==None);
2811         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2812         self.assertTrue(cellCor==None);
2813         self.assertTrue(nodeCor==None);
2814         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2815         self.assertTrue(cellCor!=None);
2816         self.assertEqual(10,cellCor.getNumberOfTuples());
2817         self.assertEqual(1,cellCor.getNumberOfComponents());
2818         self.assertEqual(renum3,list(cellCor.getValues()))
2819         self.assertTrue(nodeCor!=None);
2820         self.assertEqual(11,nodeCor.getNumberOfTuples());
2821         self.assertEqual(1,nodeCor.getNumberOfComponents());
2822         self.assertEqual(renum2,list(nodeCor.getValues()));
2823         pass
2824
2825     def testCheckGeoEquivalWith2(self):
2826         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2827         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2828         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2829         self.assertEqual(None,cellCor);
2830         self.assertNotEqual(None,nodeCor);
2831         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2832         for i in range(9):
2833             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2834             pass
2835         pass
2836
2837     def testSwig2CheckDeepEquivalWith1(self):
2838         eps = 1.0e-8
2839         mcart = MEDCouplingCMesh()
2840         mcart.setCoordsAt(0, DataArrayDouble([0.0,1.5,2.0]))
2841         mcart.setCoordsAt(1, DataArrayDouble([1.0,2.5,3.0,4.0]))
2842         m = mcart.buildUnstructured()
2843         m2 = m[1:m.getNumberOfCells()]
2844         self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 0, eps)
2845         self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 1, eps)
2846         self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 2, eps)
2847         pass
2848
2849     def testSwig2CheckDeepEquivalWith2(self):
2850         eps = 1.0e-8
2851         m = MEDCouplingUMesh("tst", 2)
2852         m.setCoords(DataArrayDouble([], 0,2))
2853         m.setConnectivity(DataArrayInt([]), DataArrayInt([0]))
2854         m2 = m.deepCopy()
2855         m.checkDeepEquivalWith(m2, 0, eps)  # Should not raise!
2856         pass
2857
2858     def testCopyTinyStringsFromOnFields(self):
2859         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2860         nbOfCells=m.getNumberOfCells();
2861         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2862         f.setMesh(m);
2863         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2864         f.setName("a");
2865         f.setDescription("b");
2866         a1=DataArrayDouble.New();
2867         a1.alloc(nbOfCells,2);
2868         a1.fillWithZero();
2869         a1.setInfoOnComponent(0,"c");
2870         a1.setInfoOnComponent(1,"d");
2871         a2=a1.deepCopy();
2872         a2.setInfoOnComponent(0,"e");
2873         a2.setInfoOnComponent(1,"f");
2874         f.setArray(a1);
2875         f.setEndArray(a2);
2876         f.setEndTime(3.,3,4);
2877         m.setName("g");
2878         m.getCoords().setInfoOnComponent(0,"h");
2879         m.getCoords().setInfoOnComponent(1,"i");
2880         m.getCoords().setInfoOnComponent(2,"j");
2881         #
2882         f.checkConsistencyLight();
2883         f2=f.clone(True);
2884         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2885         f2.setName("smth");
2886         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2887         f2.copyTinyStringsFrom(f);
2888         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2889         f2.setDescription("GGG");
2890         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2891         f2.copyTinyStringsFrom(f);
2892         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2893         f2.getArray().setInfoOnComponent(0,"mmmm");
2894         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2895         f2.copyTinyStringsFrom(f);
2896         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2897         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2898         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2899         f2.copyTinyStringsFrom(f);
2900         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2901         m2=m.clone(True);
2902         self.assertTrue(m2.isEqual(m,1e-12));
2903         m2.setName("123");
2904         self.assertTrue(not m2.isEqual(m,1e-12));
2905         m2.copyTinyStringsFrom(m);
2906         self.assertTrue(m2.isEqual(m,1e-12));
2907         m2.getCoords().setInfoOnComponent(1,"eee");
2908         self.assertTrue(not m2.isEqual(m,1e-12));
2909         m2.copyTinyStringsFrom(m);
2910         self.assertTrue(m2.isEqual(m,1e-12));
2911         pass
2912
2913     def testTryToShareSameCoordsPermute(self):
2914         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2915         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2916         #self.assertTrue(m.getCoords()!=m2.getCoords());
2917         m.tryToShareSameCoordsPermute(m2,1e-12);
2918         #self.assertTrue(m.getCoords()==m2.getCoords());
2919         self.assertTrue(m2.isEqual(m,1e-12));
2920         renum1=[1,2,0,5,8,7,4,3,6]
2921         r1=DataArrayInt.New()
2922         r1.setValues(renum1,len(renum1),1)
2923         m.renumberNodes(r1,9);
2924         #self.assertTrue(m.getCoords()!=m2.getCoords());
2925         self.assertTrue(not m2.isEqual(m,1e-12));
2926         m.tryToShareSameCoordsPermute(m2,1e-12);
2927         #self.assertTrue(m.getCoords()==m2.getCoords());
2928         self.assertTrue(m2.isEqual(m,1e-12));
2929         pass
2930
2931     def testTryToShareSameCoordsPermute2(self):
2932         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2933         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2934         targetConn=[0,2,3,1]
2935         m2=MEDCouplingUMesh.New();
2936         m2.setMeshDimension(2);
2937         m2.allocateCells(1);
2938         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2939         m2.finishInsertingCells();
2940         myCoords=DataArrayDouble.New();
2941         myCoords.setValues(targetCoords,4,2);
2942         m2.setCoords(myCoords);
2943         m2.checkConsistencyLight();
2944         m1.checkConsistencyLight();
2945         #
2946         expected1=[0.25,0.125,0.125,0.25,0.25]
2947         f1=m1.getMeasureField(False);
2948         f2=m2.getMeasureField(False);
2949         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2950         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2951         for i in range(5):
2952             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2953             pass
2954         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2955         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2956         # Let's go for deeper test of tryToShareSameCoordsPermute
2957         m2.tryToShareSameCoordsPermute(m1,1e-12);
2958         f1=m1.getMeasureField(False);
2959         f2=m2.getMeasureField(False);
2960         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2961         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2962         for i in range(5):
2963             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2964             pass
2965         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2966         pass
2967
2968     def testChangeUnderlyingMesh1(self):
2969         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2970         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2971         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2972         f1.setMesh(mesh1);
2973         array=DataArrayDouble.New();
2974         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2975         array.setValues(arr,mesh1.getNumberOfCells(),2);
2976         f1.setArray(array);
2977         #
2978         renum=[0,2,1,3,4,5,6,8,7,9]
2979         mesh2.renumberCells(renum,False);
2980         #self.assertTrue(f1.getMesh()==mesh1);
2981         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2982         #self.assertTrue(f1.getMesh()==mesh1);
2983         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2984         #self.assertTrue(f1.getMesh()==mesh2);
2985         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2986         for i in range(20):
2987             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2988             pass
2989         #
2990         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2991         f1.setMesh(mesh1);
2992         array=DataArrayDouble.New();
2993         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2994         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2995         f1.setArray(array);
2996         #
2997         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2998         mesh2.renumberNodes(renum2,11);
2999         #self.assertTrue(f1.getMesh()==mesh1);
3000         f1.changeUnderlyingMesh(mesh2,10,1e-12);
3001         #self.assertTrue(f1.getMesh()==mesh2);
3002         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
3003         for i in range(22):
3004             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
3005             pass
3006         pass
3007
3008     def testGetMaxValue1(self):
3009         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3010         nbOfCells=m.getNumberOfCells();
3011         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3012         f.setMesh(m);
3013         a1=DataArrayDouble.New();
3014         val1=[3.,4.,5.,6.,7.]
3015         a1.setValues(val1,nbOfCells,1);
3016         a2=DataArrayDouble.New();
3017         val2=[0.,1.,2.,8.,7.]
3018         a2.setValues(val2,nbOfCells,1);
3019         f.setArray(a1);
3020         f.setEndArray(a2);
3021         f.setEndTime(3.,3,4);
3022         f.checkConsistencyLight();
3023         #
3024         self.assertAlmostEqual(8.,f.getMaxValue(),14);
3025         self.assertAlmostEqual(0.,f.getMinValue(),14);
3026         self.assertAlmostEqual(5.,f.getAverageValue(),14);
3027         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
3028         a1.setIJ(0,2,9.5);
3029         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3030         self.assertAlmostEqual(0.,f.getMinValue(),14);
3031         a2.setIJ(0,0,9.);
3032         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3033         self.assertAlmostEqual(1.,f.getMinValue(),14);
3034         pass
3035
3036     def testSubstractInPlaceDM1(self):
3037         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3038         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3039         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3040         f1.setMesh(mesh1);
3041         array=DataArrayDouble.New();
3042         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3043         array.setValues(arr,mesh1.getNumberOfCells(),2);
3044         f1.setArray(array);
3045         #
3046         self.assertEqual(10,f1.getNumberOfTuples());
3047         self.assertEqual(2,f1.getNumberOfComponents());
3048         self.assertEqual(20,f1.getNumberOfValues());
3049         #
3050         renum=[0,2,3,1,4,5,6,8,7,9]
3051         mesh2.renumberCells(renum,False);
3052         #
3053         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3054         f2.setMesh(mesh2);
3055         array=DataArrayDouble.New();
3056         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]
3057         array.setValues(arr2,mesh2.getNumberOfCells(),2);
3058         f2.setArray(array);
3059         #
3060         f1.substractInPlaceDM(f2,10,1e-12);
3061         f1.applyFunc(1,"abs(x+y+0.2)");
3062         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
3063         pass
3064
3065     def testDotCrossProduct1(self):
3066         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3067         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3068         f1.setTime(2.3,5,6);
3069         f1.setMesh(mesh1);
3070         array=DataArrayDouble.New();
3071         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.]
3072         array.setValues(arr1,mesh1.getNumberOfCells(),3);
3073         f1.setArray(array);
3074         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3075         f2.setTime(7.8,4,5);
3076         f2.setMesh(mesh1);
3077         array=DataArrayDouble.New();
3078         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.]
3079         array.setValues(arr2,mesh1.getNumberOfCells(),3);
3080         f2.setArray(array);
3081         #
3082         f3=f1.dot(f2);
3083         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
3084         for i in range(10):
3085             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
3086             pass
3087         #
3088         f4=f1.crossProduct(f2);
3089         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.]
3090         for i in range(30):
3091             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3092             pass
3093         pass
3094
3095     pass
3096
3097 if __name__ == '__main__':
3098     unittest.main()