src/MEDCoupling_Swig/MEDCouplingBasicsTest1.py

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