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         m4.setName(f1.getMesh().getName())
1034         self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
1035         name=f3.getName();
1036         self.assertEqual(name,"MeasureOfMesh_");
1037         self.assertEqual(f3.getTypeOfField(),ON_CELLS);
1038         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1039         self.assertEqual(1,f3.getNumberOfComponents());
1040         self.assertEqual(7,f3.getNumberOfTuples());
1041         values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
1042         tmp=f3.getArray().getValues();
1043         self.assertEqual(len(values),len(tmp))
1044         for i in range(7):
1045             self.assertTrue(abs(values[i]-tmp[i])<1e-12)
1046             pass
1047         pass
1048
1049     def testFillFromAnalytic(self):
1050         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1051         m.setTime(3.4,5,6); m.setTimeUnit("us");
1052         f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
1053         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1054         self.assertEqual("us",f1.getTimeUnit())
1055         f1.checkConsistencyLight();
1056         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1057         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1058         self.assertEqual(1,f1.getNumberOfComponents());
1059         self.assertEqual(5,f1.getNumberOfTuples());
1060         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1061         tmp=f1.getArray().getValues();
1062         self.assertEqual(len(values1),len(tmp))
1063         for i in range(len(tmp)):
1064             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1065             pass
1066         #
1067         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1068         f1.checkConsistencyLight();
1069         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1070         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1071         self.assertEqual(1,f1.getNumberOfComponents());
1072         self.assertEqual(9,f1.getNumberOfTuples());
1073         values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
1074         tmp=f1.getArray().getValues();
1075         self.assertEqual(len(values2),len(tmp))
1076         for i in range(len(tmp)):
1077             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1078             pass
1079         #
1080         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1081         f1.checkConsistencyLight();
1082         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1083         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1084         self.assertEqual(2,f1.getNumberOfComponents());
1085         self.assertEqual(9,f1.getNumberOfTuples());
1086         values3=[-0.6,-1.2,-0.1,-0.2,0.4,0.8,-0.1,-0.2,0.4,0.8,0.9,1.8,0.4,0.8,0.9,1.8,1.4,2.8]
1087         tmp=f1.getArray().getValues();
1088         self.assertEqual(len(values3),len(tmp))
1089         for i in range(len(tmp)):
1090             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1091             pass
1092         values4=f1.accumulate();
1093         self.assertEqual(2,len(values4))
1094         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1095         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1096         values4=f1.integral(True);
1097         #0.4 == 0.25/4*-0.6+(0.25/4+0.125/3)*-0.1+0.4*(0.125/3.+0.125/3)+(-0.1)*(0.25/4+0.25/4)+0.4*(0.25/4+0.125/3+0.125/3+0.25/4+0.25/4)+0.9*(0.25/4+0.125/3)+0.4*0.25/4+0.9*(0.25/4+0.25/4)+1.4*0.25/4
1098         self.assertEqual(2,len(values4))
1099         self.assertTrue(abs(0.4-values4[0])<1.e-12);
1100         self.assertTrue(abs(0.8-values4[1])<1.e-12);
1101         #
1102         self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1103         pass
1104
1105     def testFillFromAnalytic2(self):
1106         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1107         f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1108         f1.checkConsistencyLight();
1109         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1110         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1111         self.assertEqual(1,f1.getNumberOfComponents());
1112         self.assertEqual(5,f1.getNumberOfTuples());
1113         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1114         tmp=f1.getArray().getValues();
1115         self.assertEqual(len(values1),len(tmp))
1116         for i in range(len(values1)):
1117             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1118             pass
1119         #
1120         f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1121         f1.checkConsistencyLight();
1122         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1123         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1124         self.assertEqual(1,f1.getNumberOfComponents());
1125         self.assertEqual(9,f1.getNumberOfTuples());
1126         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1127         tmp=f1.getArray().getValues();
1128         self.assertEqual(len(values2),len(tmp))
1129         for i in range(len(values2)):
1130             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1131             pass
1132         f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1133         f1.checkConsistencyLight();
1134         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1135         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1136         self.assertEqual(1,f1.getNumberOfComponents());
1137         self.assertEqual(9,f1.getNumberOfTuples());
1138         tmp=f1.getArray().getValues();
1139         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1140         self.assertEqual(len(values2Bis),len(tmp))
1141         for i in range(len(values2Bis)):
1142             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1143             pass
1144         #
1145         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1146         f1.checkConsistencyLight();
1147         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1148         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1149         self.assertEqual(2,f1.getNumberOfComponents());
1150         self.assertEqual(9,f1.getNumberOfTuples());
1151         values3=[-0.6,-1.2,-0.1,-0.2,0.4,0.8,-0.1,-0.2,0.4,0.8,0.9,1.8,0.4,0.8,0.9,1.8,1.4,2.8]
1152         tmp=f1.getArray().getValues();
1153         self.assertEqual(len(values3),len(tmp))
1154         for i in range(len(values3)):
1155             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1156             pass
1157         values4=f1.accumulate();
1158         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1159         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1160         values4=f1.integral(True);
1161         self.assertTrue(abs(0.4-values4[0])<1.e-12);
1162         self.assertTrue(abs(0.8-values4[1])<1.e-12);
1163         pass
1164
1165     def testApplyFunc(self):
1166         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1167         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1168         f1.checkConsistencyLight();
1169         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1170         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1171         self.assertEqual(2,f1.getNumberOfComponents());
1172         self.assertEqual(9,f1.getNumberOfTuples());
1173         f1.applyFunc(1,"x+y");
1174         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1175         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1176         self.assertEqual(1,f1.getNumberOfComponents());
1177         self.assertEqual(9,f1.getNumberOfTuples());
1178         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1179         tmp=f1.getArray().getValues();
1180         self.assertEqual(len(values1),len(tmp))
1181         for i in range(len(tmp)):
1182             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1183             pass
1184         pass
1185
1186     def testApplyFunc2(self):
1187         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1188         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1189         f1.checkConsistencyLight();
1190         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1191         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1192         self.assertEqual(2,f1.getNumberOfComponents());
1193         self.assertEqual(9,f1.getNumberOfTuples());
1194         #
1195         f2=f1.clone(True);
1196         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1197         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1198         self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1199         f2.applyFunc("abs(u)^2.4+2*u");
1200         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1201         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1202         self.assertEqual(2,f1.getNumberOfComponents());
1203         self.assertEqual(9,f1.getNumberOfTuples());
1204         values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1205                  0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1206                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1207                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1208                  5.0423700574830965, 17.435300118916864]
1209         tmp=f2.getArray().getValues();
1210         self.assertEqual(len(tmp),len(values2))
1211         for i in range(len(tmp)):
1212             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1213             pass
1214         #
1215         f1.applyFunc(1,"x+y");
1216         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1217         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1218         self.assertEqual(1,f1.getNumberOfComponents());
1219         self.assertEqual(9,f1.getNumberOfTuples());
1220         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1221         tmp=f1.getArray().getValues();
1222         self.assertEqual(len(tmp),len(values1))
1223         for i in range(len(tmp)):
1224             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1225             pass
1226         pass
1227
1228     def testOperationsOnFields(self):
1229         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1230         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1231         f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1232         f1.checkConsistencyLight();
1233         f2.checkConsistencyLight();
1234         f3=f1+f2;
1235         f3.checkConsistencyLight();
1236         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1237         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1238         values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1239         tmp=f3.getArray().getValues();
1240         self.assertEqual(len(values1),len(tmp))
1241         for i in range(len(tmp)):
1242             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1243             pass
1244         #
1245         f3=f1*f2;
1246         f3.checkConsistencyLight();
1247         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1248         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1249         values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1250         tmp=f3.getArray().getValues();
1251         self.assertEqual(len(values2),len(tmp))
1252         for i in range(len(tmp)):
1253             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1254             pass
1255         #
1256         f3=f1+f2;
1257         f4=f1-f3;
1258         f4.checkConsistencyLight();
1259         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1260         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1261         values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1262         tmp=f4.getArray().getValues();
1263         self.assertEqual(len(values3),len(tmp))
1264         for i in range(len(tmp)):
1265             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1266             pass
1267         #
1268         f3=f1+f2;
1269         f4=f3/f2;
1270         f4.checkConsistencyLight();
1271         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1272         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1273         tmp=f4.getArray().getValues();
1274         for i in range(len(tmp)):
1275             self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1276             pass
1277         #
1278         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1279         f4.checkConsistencyLight();
1280         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1281         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1282         self.assertRaises(InterpKernelException,f1.__add__,f4);
1283         f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1284         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1285         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1286         f3=f1+f5;
1287         tmp=f3.getArray().getValues();
1288         values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1289         self.assertEqual(len(values3),len(tmp))
1290         for i in range(len(tmp)):
1291             self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1292             pass
1293         #
1294         f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1295         f4.checkConsistencyLight();
1296         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1297         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1298         self.assertRaises(InterpKernelException,f1.__add__,f4);
1299         f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1300         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1301         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1302         f3=f1+f5;
1303         tmp=f3.getArray().getValues();
1304         values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1305         self.assertEqual(len(values5),len(tmp))
1306         for i in range(len(tmp)):
1307             self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1308             pass
1309         pass
1310
1311     def testOperationsOnFields2(self):
1312         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1313         m.setTime(3.4,5,6); m.setTimeUnit("us");
1314         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1315         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1316         f3=f1/f2;
1317         f3.checkConsistencyLight();
1318         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1319         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1320         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1321                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1322                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1323         self.assertEqual(1,f3.getNumberOfComponents());
1324         self.assertEqual(9,f3.getNumberOfTuples());
1325         val=f3.getArray().getValues();
1326         for i in range(9):
1327             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1328         #
1329         f1=m.buildOrthogonalField();
1330         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1331         self.assertEqual("us",f1.getTimeUnit())
1332         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1333         f3=f1*f2;
1334         expected2=[-0.035355339059327376,0.,0.035355339059327376, 0.2592724864350674,0.,-0.2592724864350674, 0.37712361663282529,0.,-0.37712361663282529, -0.035355339059327376,0.,0.035355339059327376, 0.31819805153394637,0.,-0.31819805153394637]
1335         val=f3.getArray().getValues();
1336         for i in range(15):
1337             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1338             pass
1339         #
1340         f3=f2*f1;
1341         val=f3.getArray().getValues();
1342         for i in range(15):
1343             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1344             pass
1345         pass
1346
1347     def testOperationsOnFields3(self):
1348         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1349         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1350         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1351         f1/=f2
1352         f1.checkConsistencyLight();
1353         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1354         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1355         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1356                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1357                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1358         self.assertEqual(1,f1.getNumberOfComponents());
1359         self.assertEqual(9,f1.getNumberOfTuples());
1360         val=f1.getArray().getValues();
1361         for i in range(9):
1362             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1363             pass
1364         #
1365         f1=m.buildOrthogonalField();
1366         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1367         f1*=f2
1368         expected2=[-0.035355339059327376,0.,0.035355339059327376, 0.2592724864350674,0.,-0.2592724864350674, 0.37712361663282529,0.,-0.37712361663282529, -0.035355339059327376,0.,0.035355339059327376, 0.31819805153394637,0.,-0.31819805153394637]
1369         val=f1.getArray().getValues();
1370         for i in range(15):
1371             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1372             pass
1373         #
1374         f1=m.buildOrthogonalField();
1375         # to avoid valgrind leaks
1376         # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1377         pass
1378
1379     def testOperationsOnFields4(self):
1380         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1381         nbOfCells=m.getNumberOfCells();
1382         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1383         f1.setMesh(m);
1384         array=DataArrayDouble.New();
1385         f1.setArray(array);
1386         self.assertRaises(InterpKernelException,f1.setEndArray,array);
1387         self.assertRaises(InterpKernelException,f1.getEndArray);
1388         arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1389         arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1390         array.setValues(arr1,nbOfCells,3);
1391         f1.setStartTime(2.,0,0);
1392         f1.setEndTime(3.,0,0);
1393         f1.checkConsistencyLight();
1394         pos=[0.3,-0.2]
1395         res=f1.getValueOn(pos);
1396         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1397         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1398         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1399         res=None
1400         res=f1.getValueOn(pos,2.2);
1401         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1402         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1403         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1404         res=None
1405         self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1406         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1407         f2.setMesh(m);
1408         f2.setArray(f1.getArray());
1409         f2.setStartTime(2.,3,0);
1410         f2.setEndTime(4.,13,0);
1411         self.assertRaises(InterpKernelException,f2.checkConsistencyLight)
1412         array2=DataArrayDouble.New();
1413         array2.setValues(arr2,nbOfCells,3);
1414         f2.setEndArray(array2);
1415         f2.checkConsistencyLight();
1416         #
1417         res=None
1418         res=f2.getValueOn(pos,3.21);
1419         self.assertTrue(abs(4.025-res[0])<1.e-12);
1420         self.assertTrue(abs(14.025-res[1])<1.e-12);
1421         self.assertTrue(abs(24.025-res[2])<1.e-12);
1422         f3=f2.clone(True);
1423         self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1424         f3.getEndArray().setIJ(0,0,5.001);
1425         self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1426         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1427         f3.setStartTime(2.1,3,0);
1428         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1429         f3.setStartTime(2.,3,0);
1430         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1431         f3.setStartTime(2.,4,0);
1432         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1433         f3.setStartTime(2.,3,1);
1434         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1435         f3.setStartTime(2.,3,0);
1436         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1437         f3.setEndTime(4.1,13,0);
1438         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1439         f3.setEndTime(4.,13,0);
1440         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1441         f3.setEndTime(4.,14,0);
1442         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1443         f3.setEndTime(4.,13,1);
1444         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1445         f3.setEndTime(4.,13,0);
1446         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1447         f4=f2+f2
1448         res=None
1449         res=f4.getValueOn(pos,3.21);
1450         self.assertTrue(abs(8.05-res[0])<1.e-12);
1451         self.assertTrue(abs(28.05-res[1])<1.e-12);
1452         self.assertTrue(abs(48.05-res[2])<1.e-12);
1453         f4+=f2;
1454         res=None
1455         res=f4.getValueOn(pos,3.21);
1456         self.assertTrue(abs(12.075-res[0])<1.e-12);
1457         self.assertTrue(abs(42.075-res[1])<1.e-12);
1458         self.assertTrue(abs(72.075-res[2])<1.e-12);
1459         pass
1460
1461     def testMergeNodesOnField(self):
1462         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1463         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1464         f1.mergeNodes(1e-10);
1465         #
1466         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1467         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1468         tmp=f1.getArray()
1469         tmp.setIJ(0,0,1000.);
1470         f1.mergeNodes(1e-10);
1471         #
1472         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1473         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1474         tmp=f1.getArray()
1475         tmp.setIJ(1,0,1000.);
1476         self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1477         pass
1478
1479     def testCheckConsecutiveCellTypes(self):
1480         sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1481         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1482         self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1483         order1=[NORM_TRI3,NORM_QUAD4]
1484         order2=[NORM_QUAD4,NORM_TRI3]
1485         self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1486         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1487         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1488         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1489         self.assertEqual(5,da.getNumberOfTuples());
1490         self.assertEqual(1,da.getNumberOfComponents());
1491         expected1=[2,0,1,3,4]
1492         self.assertTrue(expected1==list(da.getValues()));
1493         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1494         self.assertEqual(5,da.getNumberOfTuples());
1495         self.assertEqual(1,da.getNumberOfComponents());
1496         expected2=[0,3,4,1,2]
1497         self.assertTrue(expected2==list(da.getValues()));
1498         renumber1=[4,0,1,2,3]
1499         targetMesh.renumberCells(renumber1,False);
1500         self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1501         self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1502         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1503         pass
1504
1505     def testRearrange2ConsecutiveCellTypes(self):
1506         m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1507         m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1508         arr1=m1_1.rearrange2ConsecutiveCellTypes();
1509         m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1510         self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1511         expected1=[0,1]
1512         self.assertEqual(2,arr1.getNumberOfTuples());
1513         self.assertEqual(1,arr1.getNumberOfComponents());
1514         self.assertEqual(expected1,arr1.getValues());
1515         expected2=[0,3,4,1,2]
1516         arr1=m2_1.rearrange2ConsecutiveCellTypes();
1517         self.assertEqual(5,arr1.getNumberOfTuples());
1518         self.assertEqual(1,arr1.getNumberOfComponents());
1519         self.assertEqual(expected2,list(arr1.getValues()));
1520         m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1521         self.assertEqual(5,arr1.getNumberOfTuples());
1522         self.assertEqual(1,arr1.getNumberOfComponents());
1523         self.assertEqual(expected2,list(arr1.getValues()));
1524         self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1525         m2_2.renumberCells(expected2,False);
1526         self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1527         pass
1528
1529     def testSplitByType(self):
1530         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1531         v=m1.splitByType();
1532         self.assertEqual(3,len(v));
1533         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1534         m2.setName(m1.getName());
1535         self.assertTrue(m1.isEqual(m2,1.e-12));
1536         pass
1537
1538     def testFuseUMeshesOnSameCoords(self):
1539         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1540         cells1=[2,3,4]
1541         m3=m2.buildPartOfMySelf(cells1,True);
1542         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1543         cells2=[1,2,4]
1544         m4=m2.buildPartOfMySelf(cells2,True);
1545         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1546         cells3=[1,2]
1547         m5=m2.buildPartOfMySelf(cells3,True);
1548         self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1549         meshes=[m3,m4,m5]
1550         #
1551         m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1552         self.assertEqual(4,m7.getNumberOfCells());
1553         self.assertEqual(3,len(corr));
1554         expectedVals1=[3,3,2]
1555         expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1556         for i in range(3):
1557             arr=corr[i];
1558             self.assertEqual(1,arr.getNumberOfComponents());
1559             nbOfVals=expectedVals1[i];
1560             self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1561             vals=arr.getValues();
1562             self.assertEqual(expectedVals2[i],list(vals));
1563             pass
1564         arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1565         fidExp=[5,1,3,4]
1566         fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1567         self.assertEqual(3,len(fidsOfGroups));
1568         self.assertEqual(1,arr2.getNumberOfComponents());
1569         self.assertEqual(4,arr2.getNumberOfTuples());
1570         self.assertEqual(fidExp,list(arr2.getValues()));
1571         for i in range(3):
1572             nbOfVals=expectedVals1[i];
1573             self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1574             pass
1575         pass
1576
1577     def testFuseUMeshesOnSameCoords2(self):
1578         m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1579         part1=[2,3,6,4,10]
1580         m3=m1.buildPartOfMySelf(part1,True);
1581         part2=[5,6,4,7]
1582         m4=m1.buildPartOfMySelf(part2,True);
1583         meshes=[m1,m3,m3,m4]
1584         m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1585         self.assertEqual(18,m5.getNumberOfCells());
1586         exp2=[
1587             [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1588             [2,3,6,4,10],
1589             [2,3,6,4,10],
1590             [5,6,4,7]]
1591         i=0;
1592         for it in corr:
1593             self.assertEqual(exp2[i],list(it.getValues()));
1594             i+=1
1595             pass
1596         pass
1597
1598     def testBuildOrthogonalField(self):
1599         targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1600         field=targetMesh.buildOrthogonalField();
1601         expected=[0.70710678118654746,0.,-0.70710678118654746]
1602         self.assertEqual(5,field.getNumberOfTuples());
1603         self.assertEqual(3,field.getNumberOfComponents());
1604         vals=field.getArray().getValues();
1605         for i in range(15):
1606             self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1607         # testing
1608         targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1609         targetConn=[0,1,2,3]
1610         targetMesh=MEDCouplingUMesh.New();
1611         targetMesh.setMeshDimension(2);
1612         targetMesh.allocateCells(1);
1613         targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1614         targetMesh.finishInsertingCells();
1615         myCoords=DataArrayDouble.New();
1616         myCoords.setValues(targetCoords,4,3);
1617         targetMesh.setCoords(myCoords);
1618         field=targetMesh.buildOrthogonalField();
1619         self.assertEqual(1,field.getNumberOfTuples());
1620         self.assertEqual(3,field.getNumberOfComponents());
1621         vals=field.getArray().getValues();
1622         self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1623         self.assertTrue(abs(0.-vals[1])<1e-12);
1624         self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1625         pass
1626
1627     def testGetCellsContainingPoint(self):
1628         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1629         pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1630         #2D basic
1631         t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1632         self.assertEqual(6,t1.getNumberOfTuples());
1633         self.assertEqual(1,t1.getNumberOfComponents());
1634         self.assertEqual(7,t2.getNumberOfTuples());
1635         self.assertEqual(1,t2.getNumberOfComponents());
1636         expectedValues1=[0,4,3,0,1,2]
1637         expectedValues2=[0,1,2,3,4,5,6]
1638         self.assertEqual(list(t1.getValues()),expectedValues1);
1639         self.assertEqual(list(t2.getValues()),expectedValues2);
1640         #2D with no help of bounding box.
1641         center=[0.2,0.2]
1642         MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1643         targetMesh.rotate(center,0.78539816339744830962);
1644         t1=None
1645         t2=None
1646         t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1647         self.assertEqual(6,t1.getNumberOfTuples());
1648         self.assertEqual(7,t2.getNumberOfTuples());
1649         self.assertEqual(list(t1.getValues()),expectedValues1);
1650         self.assertEqual(list(t2.getValues()),expectedValues2);
1651         t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1652         self.assertEqual(6,t1.getNumberOfTuples());
1653         self.assertEqual(7,t2.getNumberOfTuples());
1654         self.assertEqual(list(t1.getValues()),expectedValues1);
1655         self.assertEqual(list(t2.getValues()),expectedValues2);
1656         self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1657         #2D outside
1658         pos1bis=[-0.3303300858899107,-0.11819805153394641]
1659         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1660         #test limits 2D
1661         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1662         pos2=[0.2,-0.05]
1663         t1=None
1664         t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1665         self.assertEqual(2,len(t1));
1666         expectedValues3=[0,1]
1667         self.assertEqual(list(t1.getValues()),expectedValues3);
1668         pos3=[0.2,0.2]
1669         t1=None
1670         t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1671         self.assertEqual(5,len(t1));
1672         expectedValues4=[0,1,2,3,4]
1673         self.assertEqual(list(t1.getValues()),expectedValues4);
1674         self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1675         #3D
1676         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1677         pos4=[25.,25.,25.]
1678         self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1679         pos5=[50.,50.,50.]
1680         t1=None
1681         t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1682         self.assertEqual(8,len(t1));
1683         expectedValues5=[0,1,2,3,4,5,6,7]
1684         self.assertEqual(list(t1.getValues()),expectedValues5);
1685         pos6=[0., 50., 0.]
1686         t1=None
1687         t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1688         self.assertEqual(2,len(t1));
1689         expectedValues6=[0,2]
1690         self.assertEqual(list(t1.getValues()),expectedValues6);
1691         #3D outside
1692         pos7=[-1.0,-1.0,0.]
1693         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1694         #3D outside 2
1695         center2=[0.,0.,0.]
1696         vec2=[0.,-1.,0.]
1697         targetMesh.rotate(center2,vec2,0.78539816339744830962);
1698         pos8=[-25.,25.,12.]
1699         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1700         pass
1701
1702     def testGetValueOn1(self):
1703         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1704         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1705         nbOfCells=targetMesh.getNumberOfCells();
1706         fieldOnCells.setMesh(targetMesh);
1707         array=DataArrayDouble.New();
1708         tmp=2*nbOfCells*[None]
1709         for i in range(nbOfCells):
1710             tmp[2*i]=7.+float(i);
1711             tmp[2*i+1]=17.+float(i)
1712             pass
1713         array.setValues(tmp,nbOfCells,2);
1714         fieldOnCells.setArray(array);
1715         #
1716         pos1=[0.25,0.]
1717         res=fieldOnCells.getValueOn(pos1);
1718         self.assertEqual(2,len(res))
1719         self.assertTrue(abs(8.-res[0])<1e-12);
1720         self.assertTrue(abs(18.-res[1])<1e-12);
1721         #
1722         #
1723         targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1724         fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1725         nbOfNodes=targetMesh.getNumberOfNodes();
1726         fieldOnNodes.setMesh(targetMesh);
1727         array=DataArrayDouble.New();
1728         tmp=2*nbOfNodes*[None]
1729         for i in range(nbOfNodes):
1730             tmp[2*i]=17.+float(i);
1731             tmp[2*i+1]=27.+float(i)
1732             pass
1733         array.setValues(tmp,nbOfNodes,2);
1734         fieldOnNodes.setArray(array);
1735         #
1736         pos2=[-0.13333333333333333,-0.13333333333333333]
1737         res=None
1738         res=fieldOnNodes.getValueOn(pos2);
1739         self.assertEqual(2,len(res))
1740         self.assertTrue(abs(17.5-res[0])<1e-12);
1741         self.assertTrue(abs(27.5-res[1])<1e-12);
1742         pos3=[0.033333333333333326,0.36666666666666664]
1743         res=None
1744         res=fieldOnNodes.getValueOn(pos3);
1745         self.assertEqual(2,len(res))
1746         self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1747         self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1748         pass
1749
1750     def testCMesh0(self):
1751         mesh=MEDCouplingCMesh.New();
1752         meshEmpty=mesh.clone(True);
1753         self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1754
1755         coordsX=DataArrayDouble.New();
1756         arrX=[ -1., 1., 2., 4. ]
1757         coordsX.setValues(arrX, 4, 1);
1758         coordsY=DataArrayDouble.New();
1759         arrY=[ -2., 2., 4., 8. ]
1760         coordsY.setValues(arrY, 4, 1);
1761         coordsZ=DataArrayDouble.New();
1762         arrZ=[ -3., 3., 6., 12. ]
1763         coordsZ.setValues(arrZ, 4, 1);
1764         mesh.setCoords(coordsX, coordsY, coordsZ);
1765         #
1766         fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1767         self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1768         self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1769         expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1770                     4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1771                     7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1772                     7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1773
1774         val=fieldOnNodes.getArray().getValues();
1775         for i in range(64):
1776           self.assertAlmostEqual(expected1[i], val[i], 12)
1777         res=fieldOnNodes.getValueOnPos(1, 3, 2);
1778         self.assertAlmostEqual(7., res[0], 12);
1779         #
1780         fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1781         self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1782         self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1783         val=fieldOnCells.getArray().getValues();
1784         expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1785                     6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1786         for i in range(27):
1787           self.assertAlmostEqual(expected2[i], val[i], 12);
1788         #res=fieldOnCells.getValueOnPos(1,2,1);
1789         #self.assertAlmostEqual(6.,res,12);
1790         #
1791         meshDeepCopy=mesh.deepCopy();
1792         meshClone=mesh.clone(False);
1793
1794         meshEmpty.copyTinyStringsFrom(mesh);
1795         #no data in meshEmpty, expected False
1796         self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1797
1798         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1799         meshDeepCopy.copyTinyStringsFrom(mesh);
1800         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1801         self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1802
1803         self.assertEqual(CARTESIAN, mesh.getType());
1804         self.assertEqual(CARTESIAN, meshEmpty.getType());
1805         self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1806         self.assertEqual(CARTESIAN, meshClone.getType());
1807         pass
1808
1809     def testCMesh1(self):
1810         mesh1=MEDCouplingCMesh.New();
1811         coordsX1=DataArrayDouble.New();
1812         arrX1=[ -1., 1., 2., 4. ]
1813         coordsX1.setValues(arrX1, 4, 1);
1814         coordsY1=DataArrayDouble.New();
1815         arrY1=[ -2., 2., 4., 8. ]
1816         coordsY1.setValues(arrY1, 4, 1);
1817         coordsZ1=DataArrayDouble.New();
1818         arrZ1=[ -3., 3., 6., 12. ]
1819         coordsZ1.setValues(arrZ1, 4, 1);
1820         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1821
1822         mesh2=MEDCouplingCMesh.New();
1823         coordsX2=DataArrayDouble.New();
1824         arrX2=[ -1., 1., 2., 4. ]
1825         coordsX2.setValues(arrX2, 4, 1);
1826         coordsY2=DataArrayDouble.New();
1827         arrY2=[ -2., 2., 4., 8. ]
1828         coordsY2.setValues(arrY2, 4, 1);
1829         coordsZ2=DataArrayDouble.New();
1830         arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1831         coordsZ2.setValues(arrZ2, 4, 1);
1832         mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1833
1834         mesh3=MEDCouplingCMesh.New();
1835         coordsX3=DataArrayDouble.New();
1836         arrX3=[-1.]
1837         coordsX3.setValues(arrX3, 1, 1);
1838         coordsY3=DataArrayDouble.New();
1839         arrY3=[-2.]
1840         coordsY3.setValues(arrY3, 1, 1);
1841         coordsZ3=DataArrayDouble.New();
1842         arrZ3=[-3.]
1843         coordsZ3.setValues(arrZ3, 1, 1);
1844         mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1845
1846         self.assertEqual(3, mesh1.getSpaceDimension());
1847         self.assertEqual(3, mesh1.getMeshDimension());
1848
1849         self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1850         self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1851         self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1852         self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1853         self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1854
1855         self.assertRaises(InterpKernelException, mesh3.checkConsistency, 1e-12);
1856         mesh1.checkConsistency(1e-12);
1857         self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1858
1859         self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1860         self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1861         self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1862
1863         coo=mesh1.getCoordinatesOfNode(0);
1864         self.assertEqual(3, len(coo));
1865         self.assertAlmostEqual(-1., coo[0], 14);
1866         self.assertAlmostEqual(-2., coo[1], 14);
1867         self.assertAlmostEqual(-3., coo[2], 14);
1868         coo=mesh1.getCoordinatesOfNode(63);
1869         self.assertEqual(3, len(coo));
1870         self.assertAlmostEqual(4., coo[0], 14);
1871         self.assertAlmostEqual(8., coo[1], 14);
1872         self.assertAlmostEqual(12., coo[2], 14);
1873
1874         a=str(mesh1)
1875         repr=mesh1.simpleRepr();
1876         repr=mesh1.advancedRepr();
1877         self.assertTrue("Cartesian" in repr);
1878         self.assertTrue("Number of components : 1" in repr);
1879         self.assertTrue("Number of tuples : 4" in repr);
1880         self.assertTrue("Z Array :" in repr);
1881         pass
1882
1883     def testCMesh2(self):
1884         mesh1=MEDCouplingCMesh.New();
1885         coordsX1=DataArrayDouble.New();
1886         arrX1=[ -1., 1., 2., 4. ]
1887         coordsX1.setValues(arrX1, 4, 1);
1888         coordsY1=DataArrayDouble.New();
1889         arrY1=[ -2., 2., 4., 8. ]
1890         coordsY1.setValues(arrY1, 4, 1);
1891         coordsZ1=DataArrayDouble.New();
1892         arrZ1=[ -3., 3., 6., 12. ]
1893         coordsZ1.setValues(arrZ1, 4, 1);
1894         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1895
1896         dis=mesh1.getDistributionOfTypes();
1897         self.assertEqual(1, len(dis));
1898         self.assertEqual(NORM_HEXA8, dis[0][0]);
1899         self.assertEqual(27, dis[0][1]);
1900         self.assertEqual(-1, dis[0][2]);
1901
1902         idsPerType=[]
1903         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1904         dis[0][0]=NORM_QUAD4;
1905         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1906         dis[0][0]=NORM_HEXA8;
1907         dis[0][2]=0;
1908         ids=DataArrayInt.New();
1909         ids.alloc(10, 1);
1910         ids.fillWithValue(23);
1911         idsPerType=[ids];
1912         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1913         self.assertTrue(check);
1914         self.assertTrue(check.isEqual(ids));
1915
1916         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1917         self.assertEqual(1, len(code));
1918         self.assertEqual(NORM_HEXA8, code[0][0]);
1919         self.assertEqual(10, code[0][1]);
1920         self.assertEqual(0, code[0][2]);
1921         self.assertEqual(1, len(idsInPflPerType));
1922         self.assertEqual(1, len(pfls));
1923         self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1924         self.assertTrue(pfls[0].isEqual(ids));
1925
1926         cells1=[0, 1, 25, 26]
1927         partMesh1=mesh1.buildPart(cells1)
1928         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1929         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1930         self.assertEqual(64, mesh1.getNumberOfNodes());
1931         self.assertEqual(64, partMesh1.getNumberOfNodes());
1932
1933         cells2=[25, 26]
1934         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1935         self.assertTrue(isinstance(partMesh2,MEDCouplingCMesh))
1936         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1937         self.assertEqual(12,partMesh2.getNumberOfNodes());
1938
1939         cells3=[2, 3]
1940         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1941         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1942         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1943         self.assertEqual(12, partMesh3.getNumberOfNodes());
1944
1945         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1946         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1947
1948         #double bbox1[6];
1949         #double bbox2[6];
1950         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1951         bbox2=partMesh1.getBoundingBox();
1952         self.assertTrue(bbox1==bbox2);
1953         bbox1=partMesh3.getBoundingBox();
1954         bbox2=partMesh2.getBoundingBox();
1955         self.assertTrue(bbox1==bbox2);
1956
1957         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1958         mesh2d=MEDCouplingCMesh.New();
1959         mesh2d.setCoords(coordsX1, coordsY1);
1960         f1=mesh2d.buildOrthogonalField();
1961
1962         pass
1963
1964     def testScale(self):
1965         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1966         pos=[0.2,0.2]
1967         mesh.scale(pos,0.5);
1968         expected1=[-0.05,-0.05, 0.2,-0.05, 0.45,-0.05, -0.05,0.2, 0.2,0.2, 0.45,0.2,
1969                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1970         val=mesh.getCoords().getValues();
1971         self.assertEqual(18,len(val))
1972         for i in range(18):
1973             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1974             pass
1975         pass
1976
1977     def testTryToShareSameCoords(self):
1978         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1979         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1980         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1981         m1.tryToShareSameCoords(m2,1e-12);
1982         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1983         m1.tryToShareSameCoords(m2,1e-12);
1984         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1985         m2.tryToShareSameCoords(m1,1e-12);
1986         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1987         #
1988         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1989         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1990         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1991         m1.tryToShareSameCoords(m2,1e-12);
1992         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1993         m1.tryToShareSameCoords(m2,1e-12);
1994         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1995         m2.tryToShareSameCoords(m1,1e-12);
1996         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1997         #
1998         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1999         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
2000         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
2001         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
2002         pass
2003
2004     def testFindNodeOnPlane(self):
2005         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
2006         pt=[300.,300.,0.]
2007         v=[0.,0.,2.]
2008         n=mesh.findNodesOnPlane(pt,v,1e-12);
2009         self.assertEqual(9,len(n));
2010         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2011         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2012         me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2013         da=me.getMesh3DIds();
2014         self.assertEqual(8,me.getNumberOfCells());
2015         expected=[0,1,2,3,4,5,6,7]
2016         val=da.getValues();
2017         self.assertEqual(expected,list(val));
2018         #
2019         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2020         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2021         me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2022         da=me.getMesh3DIds();
2023         self.assertEqual(8,me.getNumberOfCells());
2024         expected=[0,1,2,3,4,5,6,7]
2025         val=da.getValues();
2026         self.assertEqual(expected,list(val));
2027         pass
2028
2029     def testRenumberCells(self):
2030         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2031         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2032         self.assertTrue(m.isEqual(m2,0));
2033         arr=[12,3,25,2,26]
2034         m.renumberCells(arr,True);
2035         self.assertTrue(not m.isEqual(m2,0));
2036         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
2037         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2038         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
2039         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2040         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
2041         arr2=[5,-1,-5,4,8]
2042         m.renumberCells(arr2,True);
2043         self.assertTrue(m.isEqual(m2,0));
2044         pass
2045
2046     def testChangeSpaceDimension(self):
2047         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2048         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2049         #
2050         self.assertEqual(3,m1.getSpaceDimension());
2051         m1.changeSpaceDimension(2);
2052         self.assertEqual(2,m1.getSpaceDimension());
2053         m1.setName(m2.getName());
2054         self.assertTrue(m1.isEqual(m2,1e-12));
2055         m1.changeSpaceDimension(3);
2056         self.assertEqual(3,m1.getSpaceDimension());
2057         expected=[-0.3,-0.3,0., 0.2,-0.3,0., 0.7,-0.3,0., -0.3,0.2,0., 0.2,0.2,0., 0.7,0.2,0., -0.3,0.7,0., 0.2,0.7,0., 0.7,0.7,0.]
2058         val=m1.getCoords().getValues();
2059         for i in range(27):
2060             self.assertTrue(abs(expected[i]-val[i])<1e-14);
2061             pass
2062         pass
2063
2064     def testGaussPointField1(self):
2065         _a=0.446948490915965;
2066         _b=0.091576213509771;
2067         _p1=0.11169079483905;
2068         _p2=0.0549758718227661;
2069         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2070         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2071                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2072         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2073         _refCoo1=refCoo1
2074         _gsCoo1=gsCoo1
2075         _wg1=wg1
2076         #
2077         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2078         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2079         f.setMesh(m);
2080         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2081         self.assertEqual(0,f.getNbOfGaussLocalization());
2082         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2083         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2084         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2085         self.assertEqual(1,f.getNbOfGaussLocalization());
2086         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2087         _refCoo2=refCoo2
2088         _gsCoo1=_gsCoo1[0:4]
2089         _wg1=_wg1[0:2]
2090         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2091         self.assertEqual(2,f.getNbOfGaussLocalization());
2092         array=DataArrayDouble.New();
2093         ptr=18*2*[None]
2094         for i in range(18 * 2):
2095             ptr[i]=float(i+1)
2096         array.setValues(ptr,18,2);
2097         ptr=array.getPointer();
2098         f.setArray(array);
2099         f.setName("MyFirstFieldOnGaussPoint");
2100         f.checkConsistencyLight();
2101         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2102         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2103         #
2104         f.clearGaussLocalizations();
2105         self.assertEqual(0,f.getNbOfGaussLocalization());
2106         self.assertRaises(InterpKernelException,f.checkConsistencyLight);
2107         ids1=[0,1,3,4]
2108         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2109         self.assertEqual(0,f.getNbOfGaussLocalization());
2110         ids2=[0,4]
2111         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2112         self.assertEqual(1,f.getNbOfGaussLocalization());
2113         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2114         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2115         ids3=[1,2]
2116         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2117         self.assertEqual(2,f.getNbOfGaussLocalization());
2118         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2119         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2120         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2121         self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- cell 3 has no localization
2122         ids4=[3]
2123         _gsCoo2=_gsCoo1;
2124         _wg2=_wg1;
2125         _gsCoo2[0]=0.8888777776666;
2126         _wg2[0]=0.1234567892377;
2127         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2128         self.assertEqual(3,f.getNbOfGaussLocalization());
2129         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2130         self.assertEqual(ids2,list(tmpIds.getValues()));
2131         self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- it's always not ok because undelying array not with the good size.
2132         array2=f.getArray().subArray(0,10);
2133         f.setArray(array2);
2134         f.checkConsistencyLight();#<- here it is OK
2135         f2=f.clone(True);
2136         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2137         gl1=f2.getGaussLocalization(0);
2138         tmp=gl1.getGaussCoord(1,1);
2139         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2140         gl1.setGaussCoord(1,1,0.07);
2141         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2142         gl1.setGaussCoord(1,1,tmp);
2143         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2144         f2.checkConsistencyLight();
2145         pass
2146
2147     def testGaussPointNEField1(self):
2148         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2149         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2150         f.setMesh(m);
2151         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2152         f.setName("MyFirstFieldOnNE");
2153         f.setDescription("MyDescriptionNE");
2154         array=DataArrayDouble.New();
2155         tmp=18*2*[None]
2156         for i in range(18 * 2):
2157             tmp[i]=float(i+7)
2158             pass
2159         array.setValues(tmp,18,2);
2160         ptr=array.getPointer();
2161         f.setArray(array);
2162         #
2163         f.checkConsistencyLight();
2164         f2=f.clone(True);
2165         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2166         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2167         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2168         pass
2169
2170     def testCellOrientation1(self):
2171         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2172         vec=[0.,0.,-1.]
2173         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2174         m.changeSpaceDimension(3);
2175         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2176         self.assertTrue(len(res1)==0);
2177         vec[2]=1.;
2178         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2179         self.assertEqual(5,len(res1));
2180         #
2181         vec[2]=-1.;
2182         # connectivity inversion
2183         conn=m.getNodalConnectivity().getValues();
2184         tmp=conn[11];
2185         conn[11]=conn[12];
2186         conn[12]=tmp;
2187         m.getNodalConnectivity().setValues(conn,len(conn),1)
2188         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2189         self.assertEqual(1,len(res1));
2190         self.assertEqual(2,res1.getValues()[0]);
2191         m.orientCorrectly2DCells(vec,False);
2192         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2193         self.assertTrue(len(res1)==0);
2194         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2195         m2.changeSpaceDimension(3);
2196         self.assertTrue(m.isEqual(m2,1e-12));
2197         pass
2198
2199     def testCellOrientation2(self):
2200         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2201         res1=m2.arePolyhedronsNotCorrectlyOriented();
2202         self.assertEqual(6,len(res1));
2203         m2.orientCorrectlyPolyhedrons();
2204         res1=m2.arePolyhedronsNotCorrectlyOriented();
2205         self.assertTrue(len(res1)==0);
2206         m2.checkConsistencyLight();
2207         self.assertEqual(18,m2.getNumberOfCells());
2208         cellIds2=[0,6,12]
2209         m2.convertToPolyTypes(cellIds2);
2210         m2.orientCorrectlyPolyhedrons();
2211         res1=m2.arePolyhedronsNotCorrectlyOriented();
2212         self.assertTrue(len(res1)==0);
2213         f2=m2.getMeasureField(False);
2214         f2Ptr=f2.getArray().getValues();
2215         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2216         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2217         vec=[0.,0.,1.]
2218         m3.changeSpaceDimension(3);
2219         ids2=[0,1,2,3,4]
2220         m3.convertToPolyTypes(ids2);
2221         m3.orientCorrectly2DCells(vec,False);
2222         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2223         m4.changeSpaceDimension(3);
2224         center=[0.,0.,0.]
2225         vector=[0.,1.,0.]
2226         m4.rotate(center,vector,-pi/2.);
2227         m5=m3.buildExtrudedMesh(m4,0);
2228         res1=m5.arePolyhedronsNotCorrectlyOriented();
2229         self.assertEqual(15,len(res1));
2230         m5.orientCorrectlyPolyhedrons();
2231         res1=m5.arePolyhedronsNotCorrectlyOriented();
2232         self.assertTrue(len(res1)==0);
2233         f3=m5.getMeasureField(False);
2234         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2235         self.assertEqual(1,f3.getNumberOfComponents());
2236         f3Ptr=f3.getArray().getValues();
2237         expected1=[0.075,0.0375,0.0375,0.075,0.075, 0.1125,0.05625,0.05625,0.1125,0.1125, 0.0625,0.03125,0.03125,0.0625,0.0625];
2238         for i in range(15):
2239             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2240             pass
2241         f4=m5.computeCellCenterOfMass();
2242         self.assertEqual(15,f4.getNumberOfTuples());
2243         self.assertEqual(3,f4.getNumberOfComponents());
2244         f4Ptr=f4.getValues();
2245         expected2=[-0.05,-0.05,0.15, 0.3666666666666667,-0.13333333333333333,0.15, 0.53333333333333333,0.033333333333333333,0.15, -0.05,0.45,0.15, 0.45,0.45,0.15,-0.05,-0.05,0.525, 0.3666666666666667,-0.13333333333333333,0.525, 0.53333333333333333,0.033333333333333333,0.525, -0.05,0.45,0.525, 0.45,0.45,0.525,-0.05,-0.05,0.875, 0.3666666666666667,-0.13333333333333333,0.875, 0.53333333333333333,0.033333333333333333,0.875, -0.05,0.45,0.875, 0.45,0.45,0.875];
2246         for i in range(45):
2247             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2248             pass
2249         pass
2250
2251     def testCellOrientation3(self):
2252         from cmath import rect
2253
2254         c = [rect(1.0, i * pi / 4.0) for i in range(8)]
2255         coords = [c[-1].real,c[-1].imag,  c[3].real,c[3].imag,
2256                    c[5].real,c[5].imag,  c[1].real,c[1].imag]
2257         connec = [0,1,2,3]
2258         baseMesh = MEDCouplingUMesh.New("circle", 2)
2259         baseMesh.allocateCells(1)
2260         meshCoords = DataArrayDouble.New(coords, 4, 2)
2261         baseMesh.setCoords(meshCoords)
2262         baseMesh.insertNextCell(NORM_QPOLYG, connec)  # a circle
2263         baseMesh.finishInsertingCells()
2264         baseMesh.changeSpaceDimension(3)
2265         Oz = [0.0, 0.0, -1.0]
2266         cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2267         self.assertEqual(cell_lst.getNumberOfTuples(), 0)
2268         Oz[2] = 1.0
2269         cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2270         self.assertEqual(cell_lst.getNumberOfTuples(), 1)
2271
2272     def testCellOrientation4(self):
2273         """ Non regression for NORM_QPOLYG whose linear version is self-intersecting. """
2274         mesh = MEDCouplingUMesh('merge', 2)
2275         coo = DataArrayDouble([(38.45,0),(37.8659,6.67677),(38.57,0),(38.51,0),(38.3563,2.68214),(38.4266,1.34189),(38.0758,5.35121),(38.2394,4.01912),(37.6098,7.9942),(37.1398,9.95159),(37.2558,9.98265),(38.24,5.0344),(37.1978,9.96712),(37.3876,8.97597)])
2276         mesh.setCoords(coo)
2277         c = DataArrayInt([32, 9, 8, 6, 4, 0, 2, 10, 13, 1, 7, 5, 3, 11, 12])
2278         cI = DataArrayInt([0, 15])
2279         mesh.setConnectivity(c, cI)
2280         vec = [0., 0., -1.]
2281         mesh.changeSpaceDimension(3)
2282         mesh.orientCorrectly2DCells(vec, False)
2283         mesh.changeSpaceDimension(2)
2284         cRef = [32, 9, 10, 2, 0, 4, 6, 8, 12, 11, 3, 5, 7, 1, 13]
2285         cIRef = [0, 15]
2286         self.assertEqual(mesh.getNodalConnectivity().getValues(), cRef)
2287         self.assertEqual(mesh.getNodalConnectivityIndex().getValues(), cIRef)
2288         pass
2289
2290     def testPolyhedronBarycenter(self):
2291         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];
2292         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];
2293         meshN=MEDCouplingUMesh.New();
2294         meshN.setName("ForBary");
2295         meshN.setMeshDimension(3);
2296         meshN.allocateCells(4);
2297         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2298         meshN.finishInsertingCells();
2299         myCoords=DataArrayDouble.New();
2300         myCoords.setValues(coords,9,3);
2301         meshN.setCoords(myCoords);
2302         meshN.checkConsistencyLight();
2303         #
2304         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2305         meshN.orientCorrectlyPolyhedrons();
2306         self.assertTrue(len(res1)==0);
2307         da=meshN.computeCellCenterOfMass();
2308         self.assertEqual(1,da.getNumberOfTuples());
2309         self.assertEqual(3,da.getNumberOfComponents());
2310         daPtr=da.getValues();
2311         ref=meshN.getCoords().getValues()[24:];
2312         for i in range(3):
2313             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2314             pass
2315         #
2316         center=[0.,0.,0.]
2317         vec=[0.,2.78,0.]
2318         da=meshN.computeCellCenterOfMass();
2319         daPtr=da.getValues();
2320         ref=meshN.getCoords().getValues()[24:];
2321         for i in range(3):
2322             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2323             pass
2324         #
2325         meshN.rotate(center,vec,pi/7.);
2326         meshN.translate(vec);
2327         da=meshN.computeCellCenterOfMass();
2328         daPtr=da.getValues();
2329         ref=meshN.getCoords().getValues()[24:];
2330         for i in range(3):
2331             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2332             pass
2333         #
2334         center2=[1.12,3.45,6.78]
2335         vec2=[4.5,9.3,2.8]
2336         meshN.rotate(center2,vec2,e);
2337         meshN.translate(vec2);
2338         da=meshN.computeCellCenterOfMass();
2339         daPtr=da.getValues();
2340         ref=meshN.getCoords().getValues()[24:];
2341         for i in range(3):
2342             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2343             pass
2344         pass
2345
2346     def testNormL12Integ1D(self):
2347         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2348         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2349         f1.setMesh(m1);
2350         array=DataArrayDouble.New();
2351         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]
2352         array.setValues(arr,m1.getNumberOfCells(),3);
2353         f1.setArray(array);
2354         #
2355         f3=m1.computeCellCenterOfMass();
2356         self.assertEqual(4,f3.getNumberOfTuples());
2357         self.assertEqual(1,f3.getNumberOfComponents());
2358         expected9=[0.75,5.105,0.8,5.155]
2359         ptr=f3.getValues();
2360         for i in range(4):
2361             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2362             pass
2363         #
2364         f2=m1.getMeasureField(False);
2365         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2366         self.assertEqual(1,f2.getNumberOfComponents());
2367         expected1=[0.5,0.21,-0.6,-0.31]
2368         ptr=f2.getArray().getValues();
2369         for i in range(4):
2370             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2371             pass
2372         expected2=[0.5,0.21,0.6,0.31]
2373         f2=m1.getMeasureField(True);
2374         ptr=f2.getArray().getValues();
2375         for i in range(4):
2376             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2377             pass
2378         #integral
2379         self.assertTrue(4,f1.getNumberOfTuples())
2380         res=f1.integral(False);
2381         self.assertTrue(3,len(res))
2382         expected3=[0.9866,-0.3615,0.4217]
2383         for i in range(3):
2384             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2385             pass
2386         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2387         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2388         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2389         res=f1.integral(True);
2390         expected4=[-3.4152,8.7639,-14.6879]
2391         for i in range(3):
2392             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2393             pass
2394         #normL1
2395         res=f1.normL1();
2396         self.assertTrue(3,len(res))
2397         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2398         for i in range(3):
2399             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2400             pass
2401         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2402         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2403         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2404         #normL2
2405         res=f1.normL2();
2406         self.assertTrue(3,len(res))
2407         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2408         for i in range(3):
2409             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2410             pass
2411         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2412         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2413         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2414         #buildMeasureField
2415         f4=f1.buildMeasureField(False);
2416         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2417         f4=f1.buildMeasureField(True);
2418         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2419         # Testing with 2D Curve
2420         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2421         f2=m1.getMeasureField(False);
2422         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2423         self.assertEqual(1,f2.getNumberOfComponents());
2424         ptr=f2.getArray().getValues();
2425         for i in range(4):
2426             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2427             pass
2428         f2=m1.getMeasureField(True);
2429         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2430         self.assertEqual(1,f2.getNumberOfComponents());
2431         ptr=f2.getArray().getValues();
2432         for i in range(4):
2433             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2434             pass
2435         #bary
2436         f3=m1.computeCellCenterOfMass();
2437         self.assertEqual(4,f3.getNumberOfTuples());
2438         self.assertEqual(2,f3.getNumberOfComponents());
2439         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2440         ptr=f3.getValues();
2441         for i in range(8):
2442             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2443             pass
2444         #
2445         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2446         f1.setMesh(m1);
2447         array=DataArrayDouble.New();
2448         array.setValues(arr,m1.getNumberOfCells(),3);
2449         f1.setArray(array);
2450         res=f1.integral(False);
2451         for i in range(3):
2452             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2453             pass
2454         res=f1.integral(True);
2455         for i in range(3):
2456             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2457             pass
2458         res=f1.normL1();
2459         for i in range(3):
2460             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2461             pass
2462         res=f1.normL2();
2463         for i in range(3):
2464             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2465             pass
2466         pass
2467
2468     def testAreaBary2D(self):
2469         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2470         f1=m1.getMeasureField(False);
2471         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2472         self.assertEqual(1,f1.getNumberOfComponents());
2473         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2474         ptr=f1.getArray().getValues();
2475         for i in range(10):
2476             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2477             pass
2478         f1=m1.getMeasureField(True);
2479         ptr=f1.getArray().getValues();
2480         for i in range(10):
2481             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2482             pass
2483         f2=m1.computeCellCenterOfMass();
2484         self.assertEqual(10,f2.getNumberOfTuples());
2485         self.assertEqual(2,f2.getNumberOfComponents());
2486         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]
2487         ptr=f2.getValues();
2488         for i in range(20):
2489             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2490             pass
2491         m1.changeSpaceDimension(3);
2492         f1=m1.getMeasureField(False);
2493         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2494         self.assertEqual(1,f1.getNumberOfComponents());
2495         ptr=f1.getArray().getValues();
2496         for i in range(10):
2497             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2498             pass
2499         f2=m1.computeCellCenterOfMass();
2500         self.assertEqual(10,f2.getNumberOfTuples());
2501         self.assertEqual(3,f2.getNumberOfComponents());
2502         ptr=f2.getValues();
2503         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.]
2504         for i in range(30):
2505             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2506             pass
2507         pass
2508
2509     def testAreaBary3D(self):
2510         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2511                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2512                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2513                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2514                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2515                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2516                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2517                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2518                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2519                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2520                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2521                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2522                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2523                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2524                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2525                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2526                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2527                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2528                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2529                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2530                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2531                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2532                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2533                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2534                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2535                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2536                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2537                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2538                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2539                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2540                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2541                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2542                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2543                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2544                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2545
2546         connN = [ #polyhedron 0
2547             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
2548             , 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
2549             , 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
2550             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2551             # polyhedron 1
2552             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
2553             , 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
2554             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2555             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2556             # polyhedron 2
2557             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
2558             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2559             # polyhedron 3
2560             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
2561             , 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
2562             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2563             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2564
2565         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2566                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2567                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2568                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2569         meshN=MEDCouplingUMesh.New();
2570         meshN.setName("ForBary");
2571         meshN.setMeshDimension(3);
2572         meshN.allocateCells(4);
2573         meshN.insertNextCell(NORM_POLYHED,113,connN);
2574         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2575         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2576         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2577         meshN.finishInsertingCells();
2578         myCoords=DataArrayDouble.New();
2579         myCoords.setValues(coords,69,3);
2580         meshN.setCoords(myCoords);
2581         meshN.checkConsistencyLight();
2582         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2583         meshN.orientCorrectlyPolyhedrons();
2584         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2585         self.assertTrue(len(res1)==0);
2586         #
2587         da=meshN.computeCellCenterOfMass();
2588         self.assertEqual(4,da.getNumberOfTuples());
2589         self.assertEqual(3,da.getNumberOfComponents());
2590         daPtr=da.getValues();
2591         for i in range(12):
2592             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2593             pass
2594         pass
2595
2596     def testRenumberCellsForFields(self):
2597         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2598         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2599         f.setMesh(m);
2600         arr=DataArrayDouble.New();
2601         nbOfCells=m.getNumberOfCells();
2602         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2603         arr.setValues(values1,nbOfCells,3);
2604         f.setArray(arr);
2605         renumber1=[3,1,0,4,2]
2606         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2607         for j in range(5):
2608             res=f.getValueOn(loc[2*j:2*j+2]);
2609             for i in range(3):
2610                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2611                 pass
2612             pass
2613         f.renumberCells(renumber1,False);
2614         ptr=f.getArray().getValues();
2615         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2616         for i in range(15):
2617             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2618             pass
2619         #check that fields remains the same geometrically
2620         for j in range(5):
2621             res=f.getValueOn(loc[2*j:2*(j+1)]);
2622             for i in range(3):
2623                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2624                 pass
2625             pass
2626         #On gauss
2627         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2628         f.setMesh(m);
2629         _a=0.446948490915965;
2630         _b=0.091576213509771;
2631         _p1=0.11169079483905;
2632         _p2=0.0549758718227661;
2633         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2634         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 ];
2635         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2636         _refCoo1=refCoo1[0:6];
2637         _gsCoo1=gsCoo1[0:12];
2638         _wg1=wg1[0:6];
2639         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2640         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2641         _refCoo2=refCoo2[0:8];
2642         _gsCoo1=_gsCoo1[0:4]
2643         _wg1=_wg1[0:2]
2644         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2645         arr=DataArrayDouble.New();
2646         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.]
2647         arr.setValues(values2,18,2);
2648         f.setArray(arr);
2649         f.checkConsistencyLight();
2650         fCpy=f.clone(True);
2651         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2652         f.renumberCells(renumber1,False);
2653         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2654         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.]
2655         ptr=f.getArray().getValues();
2656         for i in range(36):
2657             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2658             pass
2659         renumber2=[2,1,4,0,3]
2660         f.renumberCells(renumber2,False);
2661         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2662         #GaussNE
2663         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2664         f.setMesh(m);
2665         arr=DataArrayDouble.New();
2666         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.]
2667         arr.setValues(values3,18,2);
2668         f.setArray(arr);
2669         f.checkConsistencyLight();
2670         fCpy=f.clone(True);
2671         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2672         f.renumberCells(renumber1,False);
2673         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2674         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.]
2675         ptr=f.getArray().getValues();
2676         for i in range(36):
2677             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2678             pass
2679         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2680         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2681         #
2682         pass
2683
2684     def testRenumberNodesForFields(self):
2685         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2686         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2687         f.setMesh(m);
2688         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2689         arr=DataArrayDouble.New();
2690         nbOfNodes=m.getNumberOfNodes();
2691         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.]
2692         arr.setValues(values1,nbOfNodes,3);
2693         f.setArray(arr);
2694         f.checkConsistencyLight();
2695         renumber1=[0,4,1,3,5,2,6,7,8]
2696         loc=[0.5432,-0.2432, 0.5478,0.1528]
2697         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2698         for j in range(2):
2699             res=f.getValueOn(loc[2*j:2*j+2]);
2700             for i in range(3):
2701                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2702                 pass
2703             pass
2704         fCpy=f.clone(True);
2705         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2706         f.renumberNodes(renumber1);
2707         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2708         for j in range(2):
2709             res=f.getValueOn(loc[2*j:2*j+2]);
2710             for i in range(3):
2711                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2712                 pass
2713             pass
2714         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.]
2715         for i in range(27):
2716             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2717             pass
2718         renumber2=[0,2,5,3,1,4,6,7,8]
2719         f.renumberNodes(renumber2);
2720         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2721         pass
2722
2723     def testConvertQuadraticCellsToLinear(self):
2724         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2725         mesh.checkConsistencyLight();
2726         types=mesh.getAllGeoTypes();
2727         types.sort()
2728         self.assertEqual(5,len(types));
2729         expected1 = [NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2730         expected1.sort()
2731         self.assertEqual(expected1,types);
2732         self.assertTrue(mesh.isPresenceOfQuadratic());
2733         self.assertEqual(62,mesh.getNodalConnectivityArrayLen());
2734         f1=mesh.getMeasureField(False);
2735         #
2736         mesh.convertQuadraticCellsToLinear();
2737         self.assertTrue(not mesh.isPresenceOfQuadratic());
2738         #
2739         mesh.checkConsistencyLight();
2740         f2=mesh.getMeasureField(False);
2741         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2742         self.assertEqual(48,mesh.getNodalConnectivityArrayLen());
2743         types2=mesh.getAllGeoTypes();
2744         types2.sort()
2745         self.assertEqual(3,len(types2));
2746         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2747         expected2.sort()
2748         self.assertEqual(expected2,types2);
2749         pass
2750
2751     def testCheckGeoEquivalWith(self):
2752         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2753         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2754         #First test mesh1
2755         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2756         self.assertTrue(cellCor==None);
2757         self.assertTrue(nodeCor==None);
2758         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2759         self.assertTrue(cellCor==None);
2760         self.assertTrue(nodeCor==None);
2761         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2762         self.assertTrue(cellCor==None);
2763         self.assertTrue(nodeCor==None);
2764         #Second test mesh1 and mesh2 are 2 different meshes instance
2765         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2766         self.assertTrue(cellCor==None);
2767         self.assertTrue(nodeCor==None);
2768         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2769         self.assertTrue(cellCor==None);
2770         self.assertTrue(nodeCor==None);
2771         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2772         self.assertTrue(cellCor==None);
2773         self.assertTrue(nodeCor==None);
2774         #Third test : cell permutation by keeping the first the middle and the last as it is.
2775         renum=[0,2,1,3,4,5,6,8,7,9]
2776         mesh2.renumberCells(renum,False);
2777         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2778         self.assertTrue(cellCor==None);
2779         self.assertTrue(nodeCor==None);
2780         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2781         self.assertTrue(cellCor==None);
2782         self.assertTrue(nodeCor==None);
2783         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2784         self.assertTrue(cellCor);
2785         self.assertEqual(10,cellCor.getNumberOfTuples());
2786         self.assertEqual(1,cellCor.getNumberOfComponents());
2787         self.assertEqual(renum,list(cellCor.getValues()))
2788         self.assertTrue(nodeCor==None);
2789         cellCor=0;
2790         self.assertTrue(nodeCor==None);
2791         a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2792         self.assertEqual(renum,list(a.getValues()))
2793         self.assertTrue(b==None);
2794         mesh2.setCoords(mesh1.getCoords())
2795         a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2796         self.assertEqual(renum,list(a.getValues()))
2797         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2798         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2799         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2800         mesh2.renumberCells(renum,False);
2801         mesh2.renumberNodes(renum2,11);
2802         cellCor=None
2803         nodeCor=None
2804         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2805         self.assertTrue(cellCor==None);
2806         self.assertTrue(nodeCor==None);
2807         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2808         self.assertTrue(cellCor==None);
2809         self.assertTrue(nodeCor==None);
2810         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2811         self.assertTrue(cellCor);
2812         self.assertEqual(10,cellCor.getNumberOfTuples());
2813         self.assertEqual(1,cellCor.getNumberOfComponents());
2814         self.assertEqual(renum,list(cellCor.getValues()))
2815         self.assertTrue(nodeCor);
2816         self.assertEqual(11,nodeCor.getNumberOfTuples());
2817         self.assertEqual(1,nodeCor.getNumberOfComponents());
2818         self.assertEqual(renum2,list(nodeCor.getValues()))
2819         cellCor=0;
2820         nodeCor=0;
2821         #5th test : modification of the last cell to check fastCheck detection.
2822         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2823         renum3=[0,2,1,3,4,5,6,8,9,7]
2824         mesh2.renumberCells(renum3,False);
2825         mesh2.renumberNodes(renum2,11);
2826         cellCor=None
2827         nodeCor=None
2828         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2829         self.assertTrue(cellCor==None);
2830         self.assertTrue(nodeCor==None);
2831         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2832         self.assertTrue(cellCor==None);
2833         self.assertTrue(nodeCor==None);
2834         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2835         self.assertTrue(cellCor!=None);
2836         self.assertEqual(10,cellCor.getNumberOfTuples());
2837         self.assertEqual(1,cellCor.getNumberOfComponents());
2838         self.assertEqual(renum3,list(cellCor.getValues()))
2839         self.assertTrue(nodeCor!=None);
2840         self.assertEqual(11,nodeCor.getNumberOfTuples());
2841         self.assertEqual(1,nodeCor.getNumberOfComponents());
2842         self.assertEqual(renum2,list(nodeCor.getValues()));
2843         pass
2844
2845     def testCheckGeoEquivalWith2(self):
2846         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2847         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2848         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2849         self.assertEqual(None,cellCor);
2850         self.assertNotEqual(None,nodeCor);
2851         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2852         for i in range(9):
2853             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2854             pass
2855         pass
2856
2857     def testSwig2CheckDeepEquivalWith1(self):
2858         eps = 1.0e-8
2859         mcart = MEDCouplingCMesh()
2860         mcart.setCoordsAt(0, DataArrayDouble([0.0,1.5,2.0]))
2861         mcart.setCoordsAt(1, DataArrayDouble([1.0,2.5,3.0,4.0]))
2862         m = mcart.buildUnstructured()
2863         m2 = m[1:m.getNumberOfCells()]
2864         self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 0, eps)
2865         self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 1, eps)
2866         self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 2, eps)
2867         pass
2868
2869     def testSwig2CheckDeepEquivalWith2(self):
2870         eps = 1.0e-8
2871         m = MEDCouplingUMesh("tst", 2)
2872         m.setCoords(DataArrayDouble([], 0,2))
2873         m.setConnectivity(DataArrayInt([]), DataArrayInt([0]))
2874         m2 = m.deepCopy()
2875         m.checkDeepEquivalWith(m2, 0, eps)  # Should not raise!
2876         pass
2877
2878     def testCopyTinyStringsFromOnFields(self):
2879         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2880         nbOfCells=m.getNumberOfCells();
2881         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2882         f.setMesh(m);
2883         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2884         f.setName("a");
2885         f.setDescription("b");
2886         a1=DataArrayDouble.New();
2887         a1.alloc(nbOfCells,2);
2888         a1.fillWithZero();
2889         a1.setInfoOnComponent(0,"c");
2890         a1.setInfoOnComponent(1,"d");
2891         a2=a1.deepCopy();
2892         a2.setInfoOnComponent(0,"e");
2893         a2.setInfoOnComponent(1,"f");
2894         f.setArray(a1);
2895         f.setEndArray(a2);
2896         f.setEndTime(3.,3,4);
2897         m.setName("g");
2898         m.getCoords().setInfoOnComponent(0,"h");
2899         m.getCoords().setInfoOnComponent(1,"i");
2900         m.getCoords().setInfoOnComponent(2,"j");
2901         #
2902         f.checkConsistencyLight();
2903         f2=f.clone(True);
2904         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2905         f2.setName("smth");
2906         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2907         f2.copyTinyStringsFrom(f);
2908         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2909         f2.setDescription("GGG");
2910         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2911         f2.copyTinyStringsFrom(f);
2912         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2913         f2.getArray().setInfoOnComponent(0,"mmmm");
2914         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2915         f2.copyTinyStringsFrom(f);
2916         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2917         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2918         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2919         f2.copyTinyStringsFrom(f);
2920         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2921         m2=m.clone(True);
2922         self.assertTrue(m2.isEqual(m,1e-12));
2923         m2.setName("123");
2924         self.assertTrue(not m2.isEqual(m,1e-12));
2925         m2.copyTinyStringsFrom(m);
2926         self.assertTrue(m2.isEqual(m,1e-12));
2927         m2.getCoords().setInfoOnComponent(1,"eee");
2928         self.assertTrue(not m2.isEqual(m,1e-12));
2929         m2.copyTinyStringsFrom(m);
2930         self.assertTrue(m2.isEqual(m,1e-12));
2931         pass
2932
2933     def testTryToShareSameCoordsPermute(self):
2934         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2935         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2936         #self.assertTrue(m.getCoords()!=m2.getCoords());
2937         m.tryToShareSameCoordsPermute(m2,1e-12);
2938         #self.assertTrue(m.getCoords()==m2.getCoords());
2939         self.assertTrue(m2.isEqual(m,1e-12));
2940         renum1=[1,2,0,5,8,7,4,3,6]
2941         r1=DataArrayInt.New()
2942         r1.setValues(renum1,len(renum1),1)
2943         m.renumberNodes(r1,9);
2944         #self.assertTrue(m.getCoords()!=m2.getCoords());
2945         self.assertTrue(not m2.isEqual(m,1e-12));
2946         m.tryToShareSameCoordsPermute(m2,1e-12);
2947         #self.assertTrue(m.getCoords()==m2.getCoords());
2948         self.assertTrue(m2.isEqual(m,1e-12));
2949         pass
2950
2951     def testTryToShareSameCoordsPermute2(self):
2952         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2953         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2954         targetConn=[0,2,3,1]
2955         m2=MEDCouplingUMesh.New();
2956         m2.setMeshDimension(2);
2957         m2.allocateCells(1);
2958         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2959         m2.finishInsertingCells();
2960         myCoords=DataArrayDouble.New();
2961         myCoords.setValues(targetCoords,4,2);
2962         m2.setCoords(myCoords);
2963         m2.checkConsistencyLight();
2964         m1.checkConsistencyLight();
2965         #
2966         expected1=[0.25,0.125,0.125,0.25,0.25]
2967         f1=m1.getMeasureField(False);
2968         f2=m2.getMeasureField(False);
2969         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2970         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2971         for i in range(5):
2972             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2973             pass
2974         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2975         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2976         # Let's go for deeper test of tryToShareSameCoordsPermute
2977         m2.tryToShareSameCoordsPermute(m1,1e-12);
2978         f1=m1.getMeasureField(False);
2979         f2=m2.getMeasureField(False);
2980         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2981         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2982         for i in range(5):
2983             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2984             pass
2985         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2986         pass
2987
2988     def testChangeUnderlyingMesh1(self):
2989         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2990         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2991         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2992         f1.setMesh(mesh1);
2993         array=DataArrayDouble.New();
2994         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2995         array.setValues(arr,mesh1.getNumberOfCells(),2);
2996         f1.setArray(array);
2997         #
2998         renum=[0,2,1,3,4,5,6,8,7,9]
2999         mesh2.renumberCells(renum,False);
3000         #self.assertTrue(f1.getMesh()==mesh1);
3001         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
3002         #self.assertTrue(f1.getMesh()==mesh1);
3003         f1.changeUnderlyingMesh(mesh2,10,1e-12);
3004         #self.assertTrue(f1.getMesh()==mesh2);
3005         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
3006         for i in range(20):
3007             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
3008             pass
3009         #
3010         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3011         f1.setMesh(mesh1);
3012         array=DataArrayDouble.New();
3013         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
3014         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3015         f1.setArray(array);
3016         #
3017         renum2=[0,2,10,3,4,5,6,8,7,9,1]
3018         mesh2.renumberNodes(renum2,11);
3019         #self.assertTrue(f1.getMesh()==mesh1);
3020         f1.changeUnderlyingMesh(mesh2,10,1e-12);
3021         #self.assertTrue(f1.getMesh()==mesh2);
3022         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
3023         for i in range(22):
3024             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
3025             pass
3026         pass
3027
3028     def testGetMaxValue1(self):
3029         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3030         nbOfCells=m.getNumberOfCells();
3031         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3032         f.setMesh(m);
3033         a1=DataArrayDouble.New();
3034         val1=[3.,4.,5.,6.,7.]
3035         a1.setValues(val1,nbOfCells,1);
3036         a2=DataArrayDouble.New();
3037         val2=[0.,1.,2.,8.,7.]
3038         a2.setValues(val2,nbOfCells,1);
3039         f.setArray(a1);
3040         f.setEndArray(a2);
3041         f.setEndTime(3.,3,4);
3042         f.checkConsistencyLight();
3043         #
3044         self.assertAlmostEqual(8.,f.getMaxValue(),14);
3045         self.assertAlmostEqual(0.,f.getMinValue(),14);
3046         self.assertAlmostEqual(5.,f.getAverageValue(),14);
3047         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
3048         a1.setIJ(0,2,9.5);
3049         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3050         self.assertAlmostEqual(0.,f.getMinValue(),14);
3051         a2.setIJ(0,0,9.);
3052         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3053         self.assertAlmostEqual(1.,f.getMinValue(),14);
3054         pass
3055
3056     def testSubstractInPlaceDM1(self):
3057         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3058         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3059         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3060         f1.setMesh(mesh1);
3061         array=DataArrayDouble.New();
3062         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3063         array.setValues(arr,mesh1.getNumberOfCells(),2);
3064         f1.setArray(array);
3065         #
3066         self.assertEqual(10,f1.getNumberOfTuples());
3067         self.assertEqual(2,f1.getNumberOfComponents());
3068         self.assertEqual(20,f1.getNumberOfValues());
3069         #
3070         renum=[0,2,3,1,4,5,6,8,7,9]
3071         mesh2.renumberCells(renum,False);
3072         #
3073         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3074         f2.setMesh(mesh2);
3075         array=DataArrayDouble.New();
3076         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]
3077         array.setValues(arr2,mesh2.getNumberOfCells(),2);
3078         f2.setArray(array);
3079         #
3080         f1.substractInPlaceDM(f2,10,1e-12);
3081         f1.applyFunc(1,"abs(x+y+0.2)");
3082         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
3083         pass
3084
3085     def testDotCrossProduct1(self):
3086         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3087         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3088         f1.setTime(2.3,5,6);
3089         f1.setMesh(mesh1);
3090         array=DataArrayDouble.New();
3091         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.]
3092         array.setValues(arr1,mesh1.getNumberOfCells(),3);
3093         f1.setArray(array);
3094         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3095         f2.setTime(7.8,4,5);
3096         f2.setMesh(mesh1);
3097         array=DataArrayDouble.New();
3098         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.]
3099         array.setValues(arr2,mesh1.getNumberOfCells(),3);
3100         f2.setArray(array);
3101         #
3102         f3=f1.dot(f2);
3103         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
3104         for i in range(10):
3105             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
3106             pass
3107         #
3108         f4=f1.crossProduct(f2);
3109         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.]
3110         for i in range(30):
3111             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3112             pass
3113         pass
3114
3115     pass
3116
3117 if __name__ == '__main__':
3118     unittest.main()