src/MEDCoupling_Swig/MEDCouplingBasicsTest1.py

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