src/MEDCoupling_Swig/MEDCouplingBasicsTest1.py

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