src/MEDCoupling_Swig/MEDCouplingBasicsTest1.py

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