src/MEDCoupling_Swig/MEDCouplingBasicsTest1.py

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