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