src/MEDCoupling_Swig/MEDCouplingBasicsTest2.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 MEDCouplingBasicsTest2(unittest.TestCase):
  29     def testMinMaxFields1(self):
  30         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
  31         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
  32         f1.setTime(2.3,5,6);
  33         f1.setMesh(mesh1);
  34         array=DataArrayDouble.New();
  35         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.]
  36         array.setValues(arr1,mesh1.getNumberOfCells(),3);
  37         f1.setArray(array);
  38         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
  39         f2.setTime(7.8,4,5);
  40         f2.setMesh(mesh1);
  41         array=DataArrayDouble.New();
  42         arr2=[6.,108.,206.,9.,107.,209.,8.,110.,208.,11.,109.,211.,10.,112.,210.,13.,111.,213.,12.,114.,212.,15.,113.,215.,14.,116.,214.,17.,115.,217.]
  43         array.setValues(arr2,mesh1.getNumberOfCells(),3);
  44         f2.setArray(array);
  45         #
  46         f3=f1.max(f2);
  47         expected1=[7.,108.,207.,9.,108.,209.,9.,110.,209.,11.,110.,211.,11.,112.,211.,13.,112.,213.,13.,114.,213.,15.,114.,215.,15.,116.,215.,17.,116.,217.]
  48         for i in xrange(30):
  49             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
  50             pass
  51         #
  52         f4=f1.min(f2);
  53         expected2=[6.,107.,206.,8.,107.,208.,8.,109.,208.,10.,109.,210.,10.,111.,210.,12.,111.,212.,12.,113.,212.,14.,113.,214.,14.,115.,214.,16.,115.,216.]
  54         for i in xrange(30):
  55             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
  56             pass
  57         #
  58         pass
  59
  60     def testApplyLin1(self):
  61         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
  62         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
  63         f1.setMesh(mesh1);
  64         array=DataArrayDouble.New();
  65         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
  66         array.setValues(arr,mesh1.getNumberOfCells(),2);
  67         f1.setArray(array);
  68         #
  69         f1.applyLin(2.,3.,0);
  70         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
  71         for i in xrange(20):
  72             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
  73             pass
  74         #
  75         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
  76         array=DataArrayDouble.New();
  77         array.setValues(arr2,mesh1.getNumberOfCells(),2);
  78         f1.setEndArray(array);
  79         #
  80         f1.applyLin(4.,5.,1);
  81         #
  82         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
  83         for i in xrange(20):
  84             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
  85             pass
  86         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
  87         for i in xrange(20):
  88             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
  89             pass
  90         #
  91         pass
  92
  93     def testGetIdsInRange1(self):
  94         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
  95         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
  96         f1.setTime(2.3,5,6);
  97         f1.setMesh(mesh1);
  98         array=DataArrayDouble.New();
  99         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
 100         array.setValues(arr1,mesh1.getNumberOfCells(),1);
 101         f1.setArray(array);
 102         #
 103         f1.checkConsistencyLight();
 104         da=f1.findIdsInRange(2.9,7.1);
 105         self.failUnlessEqual(5,da.getNbOfElems());
 106         expected1=[2,3,5,7,9]
 107         self.failUnlessEqual(expected1,list(da.getValues()));
 108         da=f1.findIdsInRange(8.,12.);
 109         self.failUnlessEqual(4,da.getNbOfElems());
 110         expected2=[1,4,6,8]
 111         self.failUnlessEqual(expected2,list(da.getValues()));
 112         #
 113         pass
 114
 115     def testBuildSubPart1(self):
 116         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 117         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 118         f1.setTime(2.3,5,6);
 119         f1.setMesh(mesh1);
 120         array=DataArrayDouble.New();
 121         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
 122         array.setValues(arr1,mesh1.getNumberOfCells(),2);
 123         f1.setArray(array);
 124         #
 125         part1=[2,1,4]
 126         f2=f1[part1];
 127         f2.zipCoords()
 128         self.failUnlessEqual(3,f2.getNumberOfTuples());
 129         self.failUnlessEqual(2,f2.getNumberOfComponents());
 130         expected1=[5.,105.,4.,104.,7.,107.]
 131         for i in xrange(6):
 132             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
 133             pass
 134         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
 135         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
 136         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
 137         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
 138         m2C=f2.getMesh();
 139         self.failUnlessEqual(13,m2C.getNodalConnectivityArrayLen());
 140         expected2=[0.2, -0.3, 0.7, -0.3, 0.2, 0.2, 0.7, 0.2, 0.2, 0.7, 0.7, 0.7]
 141         for i in xrange(12):
 142             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
 143             pass
 144         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
 145         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
 146         expected4=[0,4,8,13]
 147         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
 148         # Test with field on nodes.
 149         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
 150         f1.setTime(2.3,5,6);
 151         f1.setMesh(mesh1);
 152         array=DataArrayDouble.New();
 153         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
 154         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
 155         f1.setArray(array);
 156         part2=[1,2]
 157         f2=f1.buildSubPart(part2);
 158         self.failUnlessEqual(4,f2.getNumberOfTuples());
 159         self.failUnlessEqual(2,f2.getNumberOfComponents());
 160         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
 161         for i in xrange(8):
 162             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
 163             pass
 164         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
 165         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
 166         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
 167         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
 168         m2C=f2.getMesh();
 169         self.failUnlessEqual(8,m2C.getNodalConnectivityArrayLen());
 170         for i in xrange(8):#8 is not an error
 171             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
 172             pass
 173         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
 174         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
 175         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
 176         #idem previous because nodes of cell#4 are not fully present in part3
 177         part3=[1,2]
 178         arrr=DataArrayInt.New();
 179         arrr.setValues(part3,2,1);
 180         f2=f1.buildSubPart(arrr);
 181         self.failUnlessEqual(4,f2.getNumberOfTuples());
 182         self.failUnlessEqual(2,f2.getNumberOfComponents());
 183         for i in xrange(8):
 184             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
 185             pass
 186         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
 187         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
 188         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
 189         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
 190         m2C=f2.getMesh();
 191         self.failUnlessEqual(8,m2C.getNodalConnectivityArrayLen());
 192         for i in xrange(8):#8 is not an error
 193             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
 194             pass
 195         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
 196         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
 197         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
 198         #
 199         part4=[1,2,4]
 200         f2=f1.buildSubPart(part4);
 201         self.failUnlessEqual(6,f2.getNumberOfTuples());
 202         self.failUnlessEqual(2,f2.getNumberOfComponents());
 203         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
 204         for i in xrange(12):
 205             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
 206             pass
 207         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
 208         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
 209         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
 210         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
 211         m2C=f2.getMesh();
 212         self.failUnlessEqual(13,m2C.getNodalConnectivityArrayLen());
 213         for i in xrange(12):
 214             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
 215             pass
 216         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
 217         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
 218         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
 219         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
 220         pass
 221
 222     def testDoublyContractedProduct1(self):
 223         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 224         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 225         f1.setMesh(mesh1);
 226         array=DataArrayDouble.New();
 227         arr1=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
 228         array.setValues(arr1,mesh1.getNumberOfCells(),6);
 229         f1.setArray(array);
 230         f1.checkConsistencyLight();
 231         #
 232         f2=f1.doublyContractedProduct();
 233         f2.checkConsistencyLight();
 234         self.assertEqual(1,f2.getNumberOfComponents());
 235         self.assertEqual(5,f2.getNumberOfTuples());
 236         for i in xrange(5):
 237             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
 238             pass
 239         #
 240         pass
 241
 242     def testDeterminant1(self):
 243         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 244         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
 245         f1.setTime(2.3,5,6);
 246         f1.setEndTime(3.8,7,3);
 247         f1.setMesh(mesh1);
 248         array=DataArrayDouble.New();
 249         arr1=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
 250         array.setValues(arr1,mesh1.getNumberOfCells(),4);
 251         f1.setArray(array);
 252         #4 components
 253         f1.checkConsistencyLight();
 254         f2=f1.determinant();
 255         f2.checkConsistencyLight();
 256         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
 257         self.assertEqual(1,f2.getNumberOfComponents());
 258         self.assertEqual(5,f2.getNumberOfValues());
 259         for i in xrange(5):
 260             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
 261             pass
 262         #6 components multi arrays with end array not defined
 263         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
 264         f1.setTime(2.3,5,6);
 265         f1.setEndTime(3.8,7,3);
 266         f1.setMesh(mesh1);
 267         array=DataArrayDouble.New();
 268         arr2=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7,
 269               1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
 270         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
 271         f1.setArray(array);
 272         self.assertRaises(InterpKernelException,f1.checkConsistencyLight);#no end array specified !
 273         #
 274         f2=f1.determinant();
 275         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
 276         self.assertEqual(1,f2.getArray().getNumberOfComponents());
 277         self.assertEqual(9,f2.getNumberOfTuples());
 278         for i in xrange(9):
 279             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
 280             pass
 281         #6 components multi arrays with end array defined
 282         array=DataArrayDouble.New();
 283         arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5,
 284               7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
 285         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
 286         f1.setEndArray(array);
 287         f1.checkConsistencyLight();
 288         f2=f1.determinant();
 289         f2.checkConsistencyLight();
 290         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
 291         self.assertEqual(1,f2.getNumberOfComponents());
 292         self.assertEqual(9,f2.getNumberOfTuples());
 293         time2,it,order=f2.getTime()
 294         self.assertAlmostEqual(2.3,time2,12);
 295         self.assertEqual(5,it);
 296         self.assertEqual(6,order);
 297         time2,it,order=f2.getEndTime()
 298         self.assertAlmostEqual(3.8,time2,12);
 299         self.assertEqual(7,it);
 300         self.assertEqual(3,order);
 301         for i in xrange(9):
 302             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
 303             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
 304             pass
 305         #9 components
 306         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 307         f1.setTime(7.8,10,2);
 308         f1.setMesh(mesh1);
 309         array=DataArrayDouble.New();
 310         arr4=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
 311         array.setValues(arr4,mesh1.getNumberOfCells(),9);
 312         f1.setArray(array);
 313         #
 314         f1.checkConsistencyLight();
 315         f2=f1.determinant();
 316         f2.checkConsistencyLight();
 317         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
 318         self.assertEqual(1,f2.getNumberOfComponents());
 319         self.assertEqual(5,f2.getNumberOfTuples());
 320         time2,it,order=f2.getTime()
 321         self.assertAlmostEqual(7.8,time2,12);
 322         self.assertEqual(10,it);
 323         self.assertEqual(2,order);
 324         for i in xrange(5):
 325             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
 326             pass
 327         pass
 328
 329     def testEigenValues1(self):
 330         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 331         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 332         f1.setMesh(mesh1);
 333         array=DataArrayDouble.New();
 334         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
 335         array.setValues(arr1,mesh1.getNumberOfCells(),6);
 336         f1.setArray(array);
 337         f1.checkConsistencyLight();
 338         #
 339         f2=f1.eigenValues();
 340         f2.checkConsistencyLight();
 341         self.assertEqual(3,f2.getNumberOfComponents());
 342         self.assertEqual(5,f2.getNumberOfTuples());
 343         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
 344         for i in xrange(5):
 345             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
 346             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
 347             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
 348             pass
 349         pass
 350
 351     def testEigenVectors1(self):
 352         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 353         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 354         f1.setMesh(mesh1);
 355         array=DataArrayDouble.New();
 356         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
 357         array.setValues(arr1,mesh1.getNumberOfCells(),6);
 358         f1.setArray(array);
 359         f1.checkConsistencyLight();
 360         #
 361         f2=f1.eigenVectors();
 362         f2.checkConsistencyLight();
 363         self.assertEqual(9,f2.getNumberOfComponents());
 364         self.assertEqual(5,f2.getNumberOfTuples());
 365         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
 366                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
 367                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
 368                    ]
 369         for i in xrange(5):
 370             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
 371             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
 372             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
 373             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
 374             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
 375             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
 376             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
 377             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
 378             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
 379             pass
 380         #
 381         pass
 382
 383     def testInverse1(self):
 384         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 385         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 386         f1.setMesh(mesh1);
 387         array=DataArrayDouble.New();
 388         arr1=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
 389         array.setValues(arr1,mesh1.getNumberOfCells(),9);
 390         f1.setArray(array);
 391         f1.checkConsistencyLight();
 392         #
 393         f2=f1.inverse();
 394         f2.checkConsistencyLight();
 395         self.assertEqual(9,f2.getNumberOfComponents());
 396         self.assertEqual(5,f2.getNumberOfTuples());
 397         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
 398         for i in xrange(5):
 399             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
 400             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
 401             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
 402             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
 403             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
 404             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
 405             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
 406             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
 407             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
 408             pass
 409         #
 410         array=DataArrayDouble.New();
 411         arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
 412         array.setValues(arr3,mesh1.getNumberOfCells(),6);
 413         f1.setArray(array);
 414         f1.checkConsistencyLight();
 415         #
 416         f2=f1.inverse();
 417         f2.checkConsistencyLight();
 418         self.assertEqual(6,f2.getNumberOfComponents());
 419         self.assertEqual(5,f2.getNumberOfTuples());
 420         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
 421         for i in xrange(5):
 422             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
 423             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
 424             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
 425             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
 426             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
 427             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
 428             pass
 429         #
 430         array=DataArrayDouble.New();
 431         arr2=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
 432         array.setValues(arr2,mesh1.getNumberOfCells(),4);
 433         f1.setArray(array);
 434         f1.checkConsistencyLight();
 435         #
 436         f2=f1.inverse();
 437         f2.checkConsistencyLight();
 438         self.assertEqual(4,f2.getNumberOfComponents());
 439         self.assertEqual(5,f2.getNumberOfTuples());
 440         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
 441         for i in xrange(5):
 442             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
 443             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
 444             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
 445             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
 446             pass
 447         #
 448         pass
 449
 450     def testTrace1(self):
 451         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 452         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 453         f1.setMesh(mesh1);
 454         array=DataArrayDouble.New();
 455         arr1=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
 456         array.setValues(arr1,mesh1.getNumberOfCells(),9);
 457         f1.setArray(array);
 458         f1.checkConsistencyLight();
 459         #
 460         f2=f1.trace();
 461         f2.checkConsistencyLight();
 462         self.assertEqual(1,f2.getNumberOfComponents());
 463         self.assertEqual(5,f2.getNumberOfTuples());
 464         for i in xrange(5):
 465             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
 466             pass
 467         #
 468         array=DataArrayDouble.New();
 469         arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
 470         array.setValues(arr3,mesh1.getNumberOfCells(),6);
 471         f1.setArray(array);
 472         f1.checkConsistencyLight();
 473         #
 474         f2=f1.trace();
 475         f2.checkConsistencyLight();
 476         self.assertEqual(1,f2.getNumberOfComponents());
 477         self.assertEqual(5,f2.getNumberOfTuples());
 478         for i in xrange(5):
 479             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
 480             pass
 481         #
 482         array=DataArrayDouble.New();
 483         arr2=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
 484         array.setValues(arr2,mesh1.getNumberOfCells(),4);
 485         f1.setArray(array);
 486         f1.checkConsistencyLight();
 487         #
 488         f2=f1.trace();
 489         f2.checkConsistencyLight();
 490         self.assertEqual(1,f2.getNumberOfComponents());
 491         self.assertEqual(5,f2.getNumberOfTuples());
 492         for i in xrange(5):
 493             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
 494             pass
 495         #
 496         pass
 497
 498     def testDeviator1(self):
 499         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 500         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 501         f1.setMesh(mesh1);
 502         array=DataArrayDouble.New();
 503         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
 504         array.setValues(arr1,mesh1.getNumberOfCells(),6);
 505         f1.setArray(array);
 506         f1.checkConsistencyLight();
 507         #
 508         f2=f1.deviator();
 509         f2.checkConsistencyLight();
 510         self.assertEqual(6,f2.getNumberOfComponents());
 511         self.assertEqual(5,f2.getNumberOfTuples());
 512         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
 513         for i in xrange(5):
 514             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
 515             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
 516             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
 517             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
 518             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
 519             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
 520             pass
 521         #
 522         pass
 523
 524     def testMagnitude1(self):
 525         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 526         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 527         f1.setMesh(mesh1);
 528         array=DataArrayDouble.New();
 529         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6]
 530         array.setValues(arr1,mesh1.getNumberOfCells(),5);
 531         f1.setArray(array);
 532         f1.checkConsistencyLight();
 533         #
 534         f2=f1.magnitude();
 535         f2.checkConsistencyLight();
 536         self.assertEqual(1,f2.getNumberOfComponents());
 537         self.assertEqual(5,f2.getNumberOfTuples());
 538         for i in xrange(5):
 539             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
 540             pass
 541         #
 542         pass
 543
 544     def testMaxPerTuple1(self):
 545         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 546         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 547         f1.setMesh(mesh1);
 548         array=DataArrayDouble.New();
 549         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
 550         array.setValues(arr1,mesh1.getNumberOfCells(),5);
 551         f1.setArray(array);
 552         f1.checkConsistencyLight();
 553         #
 554         f2=f1.maxPerTuple();
 555         f2.checkConsistencyLight();
 556         self.assertEqual(1,f2.getNumberOfComponents());
 557         self.assertEqual(5,f2.getNumberOfTuples());
 558         for i in xrange(5):
 559             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
 560             pass
 561         #
 562         d2,d2I=array.maxPerTupleWithCompoId()
 563         self.assertEqual(1,d2.getNumberOfComponents());
 564         self.assertEqual(5,d2.getNumberOfTuples());
 565         for i in xrange(5):
 566             self.assertAlmostEqual(5.6,d2.getIJ(i,0),13);
 567             pass
 568         self.assertTrue(d2I.isEqual(DataArrayInt([4,3,2,0,1])))
 569         pass
 570
 571     def testChangeNbOfComponents(self):
 572         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 573         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 574         f1.setMesh(mesh1);
 575         array=DataArrayDouble.New();
 576         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
 577         array.setValues(arr1,mesh1.getNumberOfCells(),5);
 578         f1.setArray(array);
 579         f1.checkConsistencyLight();
 580         #
 581         f1.changeNbOfComponents(3,7.77);
 582         f1.checkConsistencyLight();
 583         self.assertEqual(3,f1.getNumberOfComponents());
 584         self.assertEqual(5,f1.getNumberOfTuples());
 585         expected1=[1.2,2.3,3.4, 1.2,3.4,4.5, 3.4,4.5,5.6, 5.6,1.2,2.3, 4.5,5.6,1.2]
 586         for i in xrange(15):
 587             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
 588             pass
 589         f1.changeNbOfComponents(4,7.77);
 590         f1.checkConsistencyLight();
 591         self.assertEqual(4,f1.getNumberOfComponents());
 592         self.assertEqual(5,f1.getNumberOfTuples());
 593         expected2=[1.2,2.3,3.4,7.77, 1.2,3.4,4.5,7.77, 3.4,4.5,5.6,7.77, 5.6,1.2,2.3,7.77, 4.5,5.6,1.2,7.77]
 594         for i in xrange(20):
 595             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
 596             pass
 597         #
 598         pass
 599
 600     def testSortPerTuple1(self):
 601         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 602         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 603         f1.setMesh(mesh1);
 604         array=DataArrayDouble.New();
 605         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
 606         array.setValues(arr1,mesh1.getNumberOfCells(),5);
 607         f1.setArray(array);
 608         f1.checkConsistencyLight();
 609         #
 610         f1.sortPerTuple(True);
 611         f1.checkConsistencyLight();
 612         self.assertEqual(5,f1.getNumberOfComponents());
 613         self.assertEqual(5,f1.getNumberOfTuples());
 614         for i in xrange(5):
 615             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
 616             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
 617             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
 618             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
 619             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
 620             pass
 621         #
 622         f1.sortPerTuple(False);
 623         f1.checkConsistencyLight();
 624         self.assertEqual(5,f1.getNumberOfComponents());
 625         self.assertEqual(5,f1.getNumberOfTuples());
 626         for i in xrange(5):
 627             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
 628             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
 629             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
 630             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
 631             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
 632             pass
 633         #
 634         pass
 635
 636     def testIsEqualWithoutConsideringStr1(self):
 637         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 638         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 639         #
 640         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 641         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 642         mesh2.setName("rr");
 643         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 644         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 645         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
 646         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
 647         mesh2.setName("");
 648         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 649         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 650         mesh2.getCoords().setInfoOnComponent(0,"tty");
 651         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 652         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 653         mesh2.getCoords().setInfoOnComponent(0,"");
 654         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 655         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 656         mesh2.getCoords().setInfoOnComponent(1,"tty");
 657         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 658         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 659         mesh2.getCoords().setInfoOnComponent(1,"");
 660         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 661         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 662         tmp=mesh2.getCoords().getIJ(0,3);
 663         mesh2.getCoords().setIJ(0,3,9999.);
 664         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 665         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 666         mesh2.getCoords().setIJ(0,3,tmp);
 667         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 668         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 669         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
 670         mesh2.getNodalConnectivity().setIJ(0,4,0);
 671         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 672         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 673         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
 674         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 675         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
 676         #
 677         f1=mesh1.getMeasureField(True);
 678         f2=mesh2.getMeasureField(True);
 679         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 680         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
 681         f2.setName("ftest");
 682         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
 683         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
 684         f1.setName("ftest");
 685         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 686         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
 687         #
 688         f2.getArray().setInfoOnComponent(0,"eee");
 689         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
 690         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
 691         f2.getArray().setInfoOnComponent(0,"");
 692         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 693         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
 694         #
 695         f2.getArray().setIJ(1,0,0.123);
 696         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
 697         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
 698         f2.getArray().setIJ(1,0,0.125);
 699         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 700         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
 701         #
 702         pass
 703
 704     def testGetNodeIdsOfCell1(self):
 705         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 706         li=mesh1.getNodeIdsOfCell(1)
 707         expected1=[1, 4, 2]
 708         self.assertEqual(expected1,list(li))
 709         li=mesh1.getCoordinatesOfNode(4)
 710         self.assertEqual(2,len(li))
 711         self.assertAlmostEqual(0.2,li[0],13);
 712         self.assertAlmostEqual(0.2,li[1],13);
 713         li=mesh1.getCoords().getValuesAsTuple()
 714         self.assertEqual(9,len(li))
 715         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
 716         self.assertEqual(6,len(li2))
 717         pass
 718
 719     def testGetEdgeRatioField1(self):
 720         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 721         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
 722         f1=m1.getEdgeRatioField();
 723         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
 724         self.assertEqual("us",f1.getTimeUnit())
 725         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
 726         self.assertEqual(5,f1.getNumberOfTuples());
 727         self.assertEqual(1,f1.getNumberOfComponents());
 728         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
 729         for i in xrange(5):
 730             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
 731             pass
 732         #
 733         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
 734         f1=m1.getEdgeRatioField();
 735         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
 736         self.assertEqual(5,f1.getNumberOfTuples());
 737         self.assertEqual(1,f1.getNumberOfComponents());
 738         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
 739         for i in xrange(5):
 740             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
 741             pass
 742         pass
 743
 744     def testFillFromAnalytic3(self):
 745         m=MEDCouplingDataForTest.build2DTargetMesh_1()
 746         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
 747         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
 748         f1.setMesh(m)
 749         f1.setName("myField");
 750         f1.fillFromAnalytic(1,"y+x");
 751         f1.checkConsistencyLight();
 752         self.assertEqual(f1.getName(),"myField");
 753         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
 754         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
 755         self.assertEqual(1,f1.getNumberOfComponents());
 756         self.assertEqual(5,f1.getNumberOfTuples());
 757         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
 758         tmp=f1.getArray().getValues();
 759         self.assertEqual(len(values1),len(tmp))
 760         for i in xrange(len(values1)):
 761             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
 762             pass
 763         #
 764         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
 765         f1.setMesh(m)
 766         f1.fillFromAnalytic(1,"y+2*x");
 767         f1.setEndTime(1.2,3,4);
 768         f1.checkConsistencyLight();
 769         self.assertEqual(f1.getTypeOfField(),ON_NODES);
 770         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
 771         self.assertEqual(1,f1.getNumberOfComponents());
 772         self.assertEqual(9,f1.getNumberOfTuples());
 773         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
 774         tmp=f1.getArray().getValues();
 775         self.assertEqual(len(values2),len(tmp))
 776         for i in xrange(len(values2)):
 777             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
 778             pass
 779         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
 780         f1.setMesh(m)
 781         f1.fillFromAnalytic(1,"2.*x+y");
 782         f1.setEndTime(1.2,3,4);
 783         f1.checkConsistencyLight();
 784         self.assertEqual(f1.getTypeOfField(),ON_NODES);
 785         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
 786         self.assertEqual(1,f1.getNumberOfComponents());
 787         self.assertEqual(9,f1.getNumberOfTuples());
 788         tmp=f1.getArray().getValues();
 789         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
 790         self.assertEqual(len(values2Bis),len(tmp))
 791         for i in xrange(len(values2Bis)):
 792             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
 793             pass
 794         tmp=f1.getEndArray().getValues();
 795         self.assertEqual(len(values2Bis),len(tmp))
 796         for i in xrange(len(values2Bis)):
 797             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
 798             pass
 799         #
 800         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
 801         f1.setMesh(m)
 802         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
 803         f1.checkConsistencyLight();
 804         self.assertEqual(f1.getTypeOfField(),ON_NODES);
 805         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
 806         self.assertEqual(2,f1.getNumberOfComponents());
 807         self.assertEqual(9,f1.getNumberOfTuples());
 808         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]
 809         tmp=f1.getArray().getValues();
 810         self.assertEqual(len(values3),len(tmp))
 811         for i in xrange(len(values3)):
 812             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
 813             pass
 814         values4=f1.accumulate();
 815         self.assertTrue(abs(3.6-values4[0])<1.e-12);
 816         self.assertTrue(abs(7.2-values4[1])<1.e-12);
 817         values4=f1.integral(True);
 818         self.assertTrue(abs(0.5-values4[0])<1.e-12);
 819         self.assertTrue(abs(1.-values4[1])<1.e-12);
 820         #
 821         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 822         f1.setMesh(m);
 823         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
 824         pass
 825
 826     def testFieldDoubleOpEqual1(self):
 827         m=MEDCouplingDataForTest.build2DTargetMesh_1();
 828         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 829         self.assertRaises(InterpKernelException,f1.assign,0.07);
 830         f1.setMesh(m);
 831         f1.assign(0.07);
 832         f1.checkConsistencyLight();
 833         self.assertEqual(1,f1.getNumberOfComponents());
 834         self.assertEqual(5,f1.getNumberOfTuples());
 835         for i in xrange(5):
 836             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
 837             pass
 838         f1.assign(0.09);
 839         f1.checkConsistencyLight();
 840         self.assertEqual(1,f1.getNumberOfComponents());
 841         self.assertEqual(5,f1.getNumberOfTuples());
 842         for i in xrange(5):
 843             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
 844             pass
 845         #
 846         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
 847         f1.setEndTime(4.5,2,3);
 848         f1.setMesh(m);
 849         f1.assign(0.08);
 850         f1.checkConsistencyLight();
 851         self.assertEqual(1,f1.getNumberOfComponents());
 852         self.assertEqual(9,f1.getNumberOfTuples());
 853         for i in xrange(9):
 854             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
 855             pass
 856         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
 857         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
 858         for i in xrange(9):
 859             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
 860             pass
 861         pass
 862
 863     def testAreaBary3D2(self):
 864         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
 865                         -9.755591679144, 23.394927935279, 5.108794294848,
 866                         14.337630157832, 61.705351002702, 160.42422501908,
 867                         -27.273893776752, 167.567731083961, 192.830034145464,
 868                         99.857193154796,264.499264735586,-8.287335493412,
 869                         144.939882761126,156.38626563134,-31.896173894226,
 870                         161.34096835726,182.4654895809,73.832387065572,
 871                         132.680430393685,255.37973247196,96.15235602819];
 872         volHexa8=3258520.29637466;
 873         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
 874
 875         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
 876                          8.461744647847,76.653979804423,165.00018874933,
 877                          -27.273893776752,167.567731083961,192.830034145464,
 878                          106.586501038965,262.629609408327,13.124533008813,
 879                          155.465082847275,197.414118382622,78.408350795821,
 880                          132.680430393685,255.37973247196,96.15235602819];
 881         volPenta6=944849.868507338;
 882         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
 883
 884         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
 885                         -27.273893776752,167.567731083961,192.830034145464,
 886                         8.461744647847,76.653979804423,165.00018874933,
 887                         155.465082847275,197.414118382622,78.408350795821,
 888                         -68.199829618726,178.938498373416,62.608505919588];
 889         volPyra5=756943.92980254;
 890         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
 891         mesh=MEDCouplingUMesh.New("Bary3D2",3);
 892         coo=DataArrayDouble.New();
 893         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
 894         coo.setValues(tmp,19,3);
 895         mesh.setCoords(coo);
 896         #
 897         tmpConn=[0,1,2,3,4,5,6,7]
 898         mesh.allocateCells(3);
 899         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
 900         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
 901         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
 902         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
 903         mesh.finishInsertingCells();
 904         mesh.checkConsistencyLight();
 905         mesh.mergeNodes(1e-7)
 906         self.assertEqual(12,mesh.getNumberOfNodes());
 907         vols=mesh.getMeasureField(True);
 908         self.assertEqual(3,vols.getNumberOfTuples());
 909         self.assertEqual(1,vols.getNumberOfComponents());
 910         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
 911         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
 912         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
 913         bary=mesh.computeCellCenterOfMass();
 914         self.assertEqual(3,bary.getNumberOfTuples());
 915         self.assertEqual(3,bary.getNumberOfComponents());
 916         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
 917         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
 918         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
 919         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
 920         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
 921         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
 922         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
 923         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
 924         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
 925         pass
 926
 927     def testGetMeasureFieldCMesh1(self):
 928         m=MEDCouplingCMesh.New();
 929         da=DataArrayDouble.New();
 930         discX=[2.3,3.4,5.8,10.2]
 931         discY=[12.3,23.4,45.8]
 932         discZ=[-0.7,1.2,1.25,2.13,2.67]
 933         da.setValues(discX,4,1);
 934         m.setCoordsAt(0,da);
 935         m.checkConsistencyLight();
 936         self.assertEqual(4,m.getNumberOfNodes());
 937         self.assertEqual(3,m.getNumberOfCells());
 938         self.assertEqual(1,m.getSpaceDimension());
 939         f=m.getMeasureField(True);
 940         self.assertEqual(3,f.getNumberOfTuples());
 941         self.assertEqual(1,f.getNumberOfComponents());
 942         expected1=[1.1,2.4,4.4]
 943         for i in xrange(3):
 944             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
 945             pass
 946         coords=m.getCoordinatesAndOwner();
 947         self.assertEqual(4,coords.getNumberOfTuples());
 948         self.assertEqual(1,coords.getNumberOfComponents());
 949         for i in xrange(4):
 950             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
 951             pass
 952         coords=m.computeCellCenterOfMass();
 953         self.assertEqual(3,coords.getNumberOfTuples());
 954         self.assertEqual(1,coords.getNumberOfComponents());
 955         expected1_3=[2.85,4.6,8.]
 956         for i in xrange(3):
 957             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
 958             pass
 959         #
 960         da=DataArrayDouble.New();
 961         da.setValues(discY,3,1);
 962         m.setCoordsAt(1,da);
 963         m.checkConsistencyLight();
 964         self.assertEqual(12,m.getNumberOfNodes());
 965         self.assertEqual(6,m.getNumberOfCells());
 966         self.assertEqual(2,m.getSpaceDimension());
 967         f=m.getMeasureField(True);
 968         self.assertEqual(6,f.getNumberOfTuples());
 969         self.assertEqual(1,f.getNumberOfComponents());
 970         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
 971         for i in xrange(6):
 972             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
 973             pass
 974         coords=m.getCoordinatesAndOwner();
 975         self.assertEqual(12,coords.getNumberOfTuples());
 976         self.assertEqual(2,coords.getNumberOfComponents());
 977         expected2_2=[2.3,12.3,3.4,12.3,5.8,12.3,10.2,12.3, 2.3,23.4,3.4,23.4,5.8,23.4,10.2,23.4, 2.3,45.8,3.4,45.8,5.8,45.8,10.2,45.8]
 978         for i in xrange(24):
 979             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
 980             pass
 981         coords=m.computeCellCenterOfMass();
 982         self.assertEqual(6,coords.getNumberOfTuples());
 983         self.assertEqual(2,coords.getNumberOfComponents());
 984         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
 985         for i in xrange(12):
 986             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
 987             pass
 988         #
 989         da=DataArrayDouble.New();
 990         da.setValues(discZ,5,1);
 991         m.setCoordsAt(2,da);
 992         m.checkConsistencyLight();
 993         self.assertEqual(60,m.getNumberOfNodes());
 994         self.assertEqual(24,m.getNumberOfCells());
 995         self.assertEqual(3,m.getSpaceDimension());
 996         f=m.getMeasureField(True);
 997         self.assertEqual(24,f.getNumberOfTuples());
 998         self.assertEqual(1,f.getNumberOfComponents());
 999         expected3=[23.199, 50.616, 92.796, 46.816, 102.144, 187.264, 0.6105, 1.332, 2.442, 1.232, 2.688, 4.928, 10.7448, 23.4432, 42.9792, 21.6832, 47.3088, 86.7328, 6.5934, 14.3856, 26.3736, 13.3056, 29.0304, 53.2224]
1000         for i in xrange(24):
1001             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
1002             pass
1003         coords=m.getCoordinatesAndOwner();
1004         self.assertEqual(60,coords.getNumberOfTuples());
1005         self.assertEqual(3,coords.getNumberOfComponents());
1006         expected3_2=[
1007             2.3,12.3,-0.7, 3.4,12.3,-0.7, 5.8,12.3,-0.7, 10.2,12.3,-0.7, 2.3,23.4,-0.7, 3.4,23.4,-0.7, 5.8,23.4,-0.7, 10.2,23.4,-0.7, 2.3,45.8,-0.7, 3.4,45.8,-0.7, 5.8,45.8,-0.7, 10.2,45.8,-0.7,
1008             2.3,12.3,1.2, 3.4,12.3,1.2, 5.8,12.3,1.2, 10.2,12.3,1.2, 2.3,23.4,1.2, 3.4,23.4,1.2, 5.8,23.4,1.2, 10.2,23.4,1.2, 2.3,45.8,1.2, 3.4,45.8,1.2, 5.8,45.8,1.2, 10.2,45.8,1.2,
1009             2.3,12.3,1.25, 3.4,12.3,1.25, 5.8,12.3,1.25, 10.2,12.3,1.25, 2.3,23.4,1.25, 3.4,23.4,1.25, 5.8,23.4,1.25, 10.2,23.4,1.25, 2.3,45.8,1.25, 3.4,45.8,1.25, 5.8,45.8,1.25, 10.2,45.8,1.25,
1010             2.3,12.3,2.13, 3.4,12.3,2.13, 5.8,12.3,2.13, 10.2,12.3,2.13, 2.3,23.4,2.13, 3.4,23.4,2.13, 5.8,23.4,2.13, 10.2,23.4,2.13, 2.3,45.8,2.13, 3.4,45.8,2.13, 5.8,45.8,2.13, 10.2,45.8,2.13,
1011             2.3,12.3,2.67, 3.4,12.3,2.67, 5.8,12.3,2.67, 10.2,12.3,2.67, 2.3,23.4,2.67, 3.4,23.4,2.67, 5.8,23.4,2.67, 10.2,23.4,2.67, 2.3,45.8,2.67, 3.4,45.8,2.67, 5.8,45.8,2.67, 10.2,45.8,2.67];
1012         for i in xrange(180):
1013             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
1014             pass
1015         coords=m.computeCellCenterOfMass();
1016         self.assertEqual(24,coords.getNumberOfTuples());
1017         self.assertEqual(3,coords.getNumberOfComponents());
1018         expected3_3=[
1019             2.85,17.85,0.25,4.6,17.85,0.25,8.,17.85,0.25, 2.85,34.6,0.25,4.6,34.6,0.25,8.,34.6,0.25,
1020             2.85,17.85,1.225,4.6,17.85,1.225,8.,17.85,1.225, 2.85,34.6,1.225,4.6,34.6,1.225,8.,34.6,1.225,
1021             2.85,17.85,1.69,4.6,17.85,1.69,8.,17.85,1.69, 2.85,34.6,1.69,4.6,34.6,1.69,8.,34.6,1.69,
1022             2.85,17.85,2.4,4.6,17.85,2.4,8.,17.85,2.4, 2.85,34.6,2.4,4.6,34.6,2.4,8.,34.6,2.4];
1023         for i in xrange(72):
1024             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
1025             pass
1026         pass
1027
1028     def testFieldDoubleZipCoords1(self):
1029         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
1030         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
1031         f.getArray().setInfoOnComponent(0,"titi");
1032         f.getArray().setInfoOnComponent(1,"tutu");
1033         f.checkConsistencyLight();
1034         self.assertEqual(18,f.getNumberOfTuples());
1035         self.assertEqual(2,f.getNumberOfComponents());
1036         expected1=[-0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4]
1037         for i in xrange(36):
1038             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
1039             pass
1040         self.assertTrue(f.zipCoords());
1041         f.checkConsistencyLight();
1042         expected2=[-0.6, -0.6, 1.4, 1.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4]
1043         for i in xrange(30):
1044             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
1045             pass
1046         self.assertTrue(not f.zipCoords());
1047         f.checkConsistencyLight();
1048         for i in xrange(30):
1049             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
1050             pass
1051         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
1052         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
1053         pass
1054
1055     def testFieldDoubleZipConnectivity1(self):
1056         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1057         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1058         cells1=[2,3,4]
1059         m3_1=m2.buildPartOfMySelf(cells1,True);
1060         m3=m3_1;
1061         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
1062         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
1063         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
1064         #
1065         self.assertEqual(10,m6.getNumberOfCells());
1066         self.assertEqual(22,m6.getNumberOfNodes());
1067         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
1068         self.assertEqual(9,m6.getNumberOfNodes());
1069         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
1070         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
1071         self.assertEqual(10,f.getNumberOfTuples());
1072         self.assertEqual(2,f.getNumberOfComponents());
1073         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
1074                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
1075                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
1076         for i in xrange(20):
1077             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
1078             pass
1079         f.getArray().setInfoOnComponent(0,"titi");
1080         f.getArray().setInfoOnComponent(1,"tutu");
1081         f.checkConsistencyLight();
1082         self.assertTrue(f.zipConnectivity(0));
1083         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
1084                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
1085         self.assertEqual(7,f.getNumberOfTuples());
1086         self.assertEqual(2,f.getNumberOfComponents());
1087         for i in xrange(14):
1088             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
1089             pass
1090         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
1091         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
1092         self.assertTrue(not f.zipConnectivity(0));
1093         #
1094         expected3=[-0.3, -0.3, 0.2, 0.2, 0.7, 0.7, -0.3, -0.3, 0.2, 0.2, 0.7, 0.7,
1095                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
1096         self.assertEqual(9,f2.getNumberOfTuples());
1097         self.assertEqual(2,f2.getNumberOfComponents());
1098         for i in xrange(18):
1099             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
1100             pass
1101         self.assertTrue(f2.zipConnectivity(0));
1102         self.assertEqual(9,f2.getNumberOfTuples());
1103         self.assertEqual(2,f2.getNumberOfComponents());
1104         for i in xrange(18):
1105             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
1106             pass
1107         pass
1108
1109     def testDaDoubleRenumber1(self):
1110         a=DataArrayDouble.New();
1111         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
1112         a.setValues(arr1,7,2);
1113         a.setInfoOnComponent(0,"toto");
1114         a.setInfoOnComponent(1,"tata");
1115         #
1116         arr2=[3,1,0,6,5,4,2]
1117         b=a.renumber(arr2);
1118         self.assertEqual(7,b.getNumberOfTuples());
1119         self.assertEqual(2,b.getNumberOfComponents());
1120         self.assertTrue(b.getInfoOnComponent(0)=="toto");
1121         self.assertTrue(b.getInfoOnComponent(1)=="tata");
1122         expected1=[3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1]
1123         for i in xrange(14):
1124             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
1125             pass
1126         #
1127         c=DataArrayInt.New();
1128         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
1129         c.setValues(arr3,7,2);
1130         c.setInfoOnComponent(0,"toto");
1131         c.setInfoOnComponent(1,"tata");
1132         d=c.renumber(arr2);
1133         self.assertEqual(7,d.getNumberOfTuples());
1134         self.assertEqual(2,d.getNumberOfComponents());
1135         self.assertTrue(d.getInfoOnComponent(0)=="toto");
1136         self.assertTrue(d.getInfoOnComponent(1)=="tata");
1137         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
1138         for i in xrange(14):
1139             self.assertEqual(expected2[i],d.getIJ(0,i));
1140             pass
1141         pass
1142
1143     def testDaDoubleRenumberAndReduce1(self):
1144         a=DataArrayDouble.New();
1145         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
1146         a.setValues(arr1,7,2);
1147         a.setInfoOnComponent(0,"toto");
1148         a.setInfoOnComponent(1,"tata");
1149         #
1150         arr2=[2,-1,1,-1,0,4,3]
1151         b=a.renumberAndReduce(arr2,5);
1152         self.assertEqual(5,b.getNumberOfTuples());
1153         self.assertEqual(2,b.getNumberOfComponents());
1154         self.assertTrue(b.getInfoOnComponent(0)=="toto");
1155         self.assertTrue(b.getInfoOnComponent(1)=="tata");
1156         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
1157         for i in xrange(10):
1158             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
1159             pass
1160         #
1161         c=DataArrayInt.New();
1162         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
1163         c.setValues(arr3,7,2);
1164         c.setInfoOnComponent(0,"toto");
1165         c.setInfoOnComponent(1,"tata");
1166         d=c.renumberAndReduce(arr2,5);
1167         self.assertEqual(5,d.getNumberOfTuples());
1168         self.assertEqual(2,d.getNumberOfComponents());
1169         self.assertTrue(d.getInfoOnComponent(0)=="toto");
1170         self.assertTrue(d.getInfoOnComponent(1)=="tata");
1171         expected2=[5,15,3,13,1,11,7,17,6,16]
1172         for i in xrange(10):
1173             self.assertEqual(expected2[i],d.getIJ(0,i));
1174             pass
1175         pass
1176
1177     def testDaDoubleRenumberInPlace1(self):
1178         a=DataArrayDouble.New();
1179         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
1180         a.setValues(arr1,7,2);
1181         #
1182         arr2=[3,1,0,6,5,4,2]
1183         a.renumberInPlace(arr2);
1184         self.assertEqual(7,a.getNumberOfTuples());
1185         self.assertEqual(2,a.getNumberOfComponents());
1186         expected1=[3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1]
1187         for i in xrange(14):
1188             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
1189             pass
1190         #
1191         c=DataArrayInt.New();
1192         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
1193         c.setValues(arr3,7,2);
1194         c.renumberInPlace(arr2);
1195         self.assertEqual(7,c.getNumberOfTuples());
1196         self.assertEqual(2,c.getNumberOfComponents());
1197         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
1198         for i in xrange(14):
1199             self.assertEqual(expected2[i],c.getIJ(0,i));
1200             pass
1201         pass
1202
1203     def testDaDoubleRenumberR1(self):
1204         a=DataArrayDouble.New();
1205         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
1206         a.setValues(arr1,7,2);
1207         a.setInfoOnComponent(0,"toto");
1208         a.setInfoOnComponent(1,"tata");
1209         #
1210         arr2=[3,1,0,6,5,4,2]
1211         b=a.renumberR(arr2);
1212         self.assertEqual(7,b.getNumberOfTuples());
1213         self.assertEqual(2,b.getNumberOfComponents());
1214         self.assertTrue(b.getInfoOnComponent(0)=="toto");
1215         self.assertTrue(b.getInfoOnComponent(1)=="tata");
1216         expected1=[4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1]
1217         for i in xrange(14):
1218             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
1219             pass
1220         #
1221         c=DataArrayInt.New();
1222         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
1223         c.setValues(arr3,7,2);
1224         c.setInfoOnComponent(0,"toto");
1225         c.setInfoOnComponent(1,"tata");
1226         d=c.renumberR(arr2);
1227         self.assertEqual(7,d.getNumberOfTuples());
1228         self.assertEqual(2,d.getNumberOfComponents());
1229         self.assertTrue(d.getInfoOnComponent(0)=="toto");
1230         self.assertTrue(d.getInfoOnComponent(1)=="tata");
1231         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
1232         for i in xrange(14):
1233             self.assertEqual(expected2[i],d.getIJ(0,i));
1234             pass
1235         pass
1236
1237     def testDaDoubleRenumberInPlaceR1(self):
1238         a=DataArrayDouble.New();
1239         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
1240         a.setValues(arr1,7,2);
1241         #
1242         arr2=[3,1,0,6,5,4,2]
1243         a.renumberInPlaceR(arr2);
1244         self.assertEqual(7,a.getNumberOfTuples());
1245         self.assertEqual(2,a.getNumberOfComponents());
1246         expected1=[4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1]
1247         for i in xrange(14):
1248             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
1249             pass
1250         #
1251         c=DataArrayInt.New();
1252         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
1253         c.setValues(arr3,7,2);
1254         c.renumberInPlaceR(arr2);
1255         self.assertEqual(7,c.getNumberOfTuples());
1256         self.assertEqual(2,c.getNumberOfComponents());
1257         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
1258         for i in xrange(14):
1259             self.assertEqual(expected2[i],c.getIJ(0,i));
1260             pass
1261         pass
1262
1263     def testDaDoubleSelectByTupleId1(self):
1264         a=DataArrayDouble.New();
1265         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
1266         a.setValues(arr1,7,2);
1267         a.setInfoOnComponent(0,"toto");
1268         a.setInfoOnComponent(1,"tata");
1269         #
1270         arr2=[4,2,0,6,5]
1271         b=a.selectByTupleId(arr2);
1272         self.assertEqual(5,b.getNumberOfTuples());
1273         self.assertEqual(2,b.getNumberOfComponents());
1274         self.assertTrue(b.getInfoOnComponent(0)=="toto");
1275         self.assertTrue(b.getInfoOnComponent(1)=="tata");
1276         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
1277         for i in xrange(10):
1278             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
1279             pass
1280         #
1281         c=DataArrayInt.New();
1282         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
1283         c.setValues(arr3,7,2);
1284         c.setInfoOnComponent(0,"toto");
1285         c.setInfoOnComponent(1,"tata");
1286         d=c.selectByTupleId(arr2);
1287         self.assertEqual(5,d.getNumberOfTuples());
1288         self.assertEqual(2,d.getNumberOfComponents());
1289         self.assertTrue(d.getInfoOnComponent(0)=="toto");
1290         self.assertTrue(d.getInfoOnComponent(1)=="tata");
1291         expected2=[5,15,3,13,1,11,7,17,6,16]
1292         for i in xrange(10):
1293             self.assertEqual(expected2[i],d.getIJ(0,i));
1294             pass
1295         pass
1296
1297     def testDaDoubleGetMinMaxValues1(self):
1298         a=DataArrayDouble.New();
1299         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
1300         a.setValues(arr1,9,1);
1301         m,where=a.getMaxValue();
1302         self.assertEqual(1,where);
1303         self.assertAlmostEqual(4.56,m,12);
1304         m,ws=a.getMaxValue2();
1305         self.assertAlmostEqual(4.56,m,12);
1306         self.assertEqual(3,ws.getNumberOfTuples());
1307         self.assertEqual(1,ws.getNumberOfComponents());
1308         expected1=[1,4,8]
1309         for i in xrange(3):
1310             self.assertEqual(expected1[i],ws.getIJ(i,0));
1311             pass
1312         a=DataArrayDouble.New();
1313         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
1314         a.setValues(arr2,9,1);
1315         m,where=a.getMinValue();
1316         self.assertEqual(1,where);
1317         self.assertAlmostEqual(-4.56,m,12);
1318         m,ws=a.getMinValue2();
1319         self.assertAlmostEqual(-4.56,m,12);
1320         self.assertEqual(3,ws.getNumberOfTuples());
1321         self.assertEqual(1,ws.getNumberOfComponents());
1322         for i in xrange(3):
1323             self.assertEqual(expected1[i],ws.getIJ(i,0));
1324             pass
1325         pass
1326
1327     def testFieldDoubleGetMinMaxValues2(self):
1328         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1329         self.assertEqual(18,m2.getNumberOfCells());
1330         arr1=[8.71,4.53,-12.41,8.71,-8.71,8.7099,4.55,8.71,5.55,6.77,-1e-200,4.55,8.7099,0.,1.23,0.,2.22,8.71]
1331         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
1332         a=DataArrayDouble.New();
1333         a.setValues(arr1,18,1);
1334         f.setArray(a);
1335         f.setMesh(m2);
1336         #
1337         f.checkConsistencyLight();
1338         m=f.getMaxValue();
1339         self.assertAlmostEqual(8.71,m,12);
1340         m,ws=f.getMaxValue2();
1341         self.assertAlmostEqual(8.71,m,12);
1342         self.assertEqual(4,ws.getNumberOfTuples());
1343         self.assertEqual(1,ws.getNumberOfComponents());
1344         expected1=[0,3,7,17]
1345         for i in xrange(4):
1346             self.assertEqual(expected1[i],ws.getIJ(i,0));
1347             pass
1348         #
1349         arr2=[-8.71,-4.53,12.41,-8.71,8.71,-8.7099,-4.55,-8.71,-5.55,-6.77,1e-200,-4.55,-8.7099,0.,-1.23,0.,-2.22,-8.71]
1350         a.setValues(arr2,18,1);
1351         f.checkConsistencyLight();
1352         m=f.getMinValue();
1353         self.assertAlmostEqual(-8.71,m,12);
1354         m,ws=f.getMinValue2();
1355         self.assertAlmostEqual(-8.71,m,12);
1356         self.assertEqual(4,ws.getNumberOfTuples());
1357         self.assertEqual(1,ws.getNumberOfComponents());
1358         for i in xrange(4):
1359             self.assertEqual(expected1[i],ws.getIJ(i,0));
1360             pass
1361         pass
1362
1363     def testBuildUnstructuredCMesh1(self):
1364         m=MEDCouplingCMesh.New();
1365         da=DataArrayDouble.New();
1366         discX=[2.3,3.4,5.8,10.2]
1367         discY=[12.3,23.4,45.8]
1368         discZ=[-0.7,1.2,1.25,2.13,2.67]
1369         da.setValues(discX,4,1);
1370         m.setCoordsAt(0,da);
1371         m.checkConsistencyLight();
1372         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
1373         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
1374         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
1375         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
1376         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
1377         #
1378         m2=m.buildUnstructured();
1379         m2.checkConsistencyLight();
1380         f1=m.getMeasureField(False);
1381         f2=m2.getMeasureField(False);
1382         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
1383         self.assertEqual(f1.getNumberOfTuples(),3);
1384         self.assertEqual(f2.getNumberOfTuples(),3);
1385         self.assertEqual(1,m2.getMeshDimension());
1386         self.assertEqual(1,m2.getSpaceDimension());
1387         for i in xrange(3):
1388             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
1389             pass
1390         da=DataArrayDouble.New();
1391         da.setValues(discY,3,1);
1392         m.setCoordsAt(1,da);
1393         #
1394         m2=m.buildUnstructured();
1395         m2.checkConsistencyLight();
1396         f1=m.getMeasureField(False);
1397         f2=m2.getMeasureField(False);
1398         self.assertEqual(f1.getNumberOfTuples(),6);
1399         self.assertEqual(f2.getNumberOfTuples(),6);
1400         self.assertEqual(2,m2.getMeshDimension());
1401         self.assertEqual(2,m2.getSpaceDimension());
1402         for i in xrange(6):
1403             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
1404             pass
1405         #
1406         da=DataArrayDouble.New();
1407         da.setValues(discZ,5,1);
1408         m.setCoordsAt(2,da);
1409         m2=m.buildUnstructured();
1410         m2.checkConsistencyLight();
1411         f1=m.getMeasureField(False);
1412         f2=m2.getMeasureField(False);
1413         self.assertEqual(f1.getNumberOfTuples(),24);
1414         self.assertEqual(f2.getNumberOfTuples(),24);
1415         self.assertEqual(3,m2.getMeshDimension());
1416         self.assertEqual(3,m2.getSpaceDimension());
1417         for i in xrange(24):
1418             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
1419             pass
1420         #
1421         pos1=[5.,30.,2.]
1422         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
1423         #
1424         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
1425         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
1426         #
1427         pt=[2.4,12.7,-3.4]
1428         m.scale(pt,3.7);
1429         m3=m.buildUnstructured();
1430         m2.scale(pt,3.7);
1431         self.assertTrue(m3.isEqual(m2,1e-12));
1432         pass
1433
1434     def testDataArrayIntInvertO2NNO21(self):
1435         arr1=[2,0,4,1,5,3]
1436         da=DataArrayInt.New();
1437         da.setValues(arr1,6,1);
1438         da2=da.invertArrayO2N2N2O(6);
1439         self.assertEqual(6,da2.getNumberOfTuples());
1440         self.assertEqual(1,da2.getNumberOfComponents());
1441         expected1=[1,3,0,5,2,4]
1442         for i in xrange(6):
1443             self.assertEqual(expected1[i],da2.getIJ(i,0));
1444             pass
1445         da3=da2.invertArrayN2O2O2N(6);
1446         for i in xrange(6):
1447             self.assertEqual(arr1[i],da3.getIJ(i,0));
1448             pass
1449         #
1450         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
1451         da=DataArrayInt.New();
1452         da.setValues(arr2,10,1);
1453         da2=da.invertArrayO2N2N2O(6);
1454         self.assertEqual(6,da2.getNumberOfTuples());
1455         self.assertEqual(1,da2.getNumberOfComponents());
1456         expected2=[5,7,8,0,3,2]
1457         for i in xrange(6):
1458             self.assertEqual(expected2[i],da2.getIJ(i,0));
1459             pass
1460         da3=da2.invertArrayN2O2O2N(10);
1461         for i in xrange(10):
1462             self.assertEqual(arr2[i],da3.getIJ(i,0));
1463             pass
1464         pass
1465
1466     def testKeepSetSelectedComponent1(self):
1467         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
1468         a1=DataArrayDouble.New();
1469         a1.setValues(arr1,5,4);
1470         expp=[21.,22.,23.,24.]
1471         self.assertEqual(4,len(a1.getTuple(2)));
1472         for i in xrange(4):
1473             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
1474             pass
1475         a1.setInfoOnComponent(0,"aaaa");
1476         a1.setInfoOnComponent(1,"bbbb");
1477         a1.setInfoOnComponent(2,"cccc");
1478         a1.setInfoOnComponent(3,"dddd");
1479         arr2V=[1,2,1,2,0,0]
1480         a2=a1.keepSelectedComponents(arr2V);
1481         self.assertEqual(6,a2.getNumberOfComponents());
1482         self.assertEqual(5,a2.getNumberOfTuples());
1483         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
1484         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
1485         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
1486         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
1487         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
1488         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
1489         expected1=[2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.]
1490         for i in xrange(30):
1491             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
1492             pass
1493         a3=a1.convertToIntArr();
1494         self.assertEqual([21,22,23,24],a3.getTuple(2))
1495         a4=a3.keepSelectedComponents(arr2V);
1496         self.assertEqual(6,a4.getNumberOfComponents());
1497         self.assertEqual(5,a4.getNumberOfTuples());
1498         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
1499         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
1500         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
1501         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
1502         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
1503         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
1504         for i in xrange(30):
1505             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
1506             pass
1507         # setSelectedComponents
1508         arr3V=[3,2]
1509         a5=a1.keepSelectedComponents(arr3V);
1510         a5.setInfoOnComponent(0,"eeee");
1511         a5.setInfoOnComponent(1,"ffff");
1512         arr4V=[1,2]
1513         a2.setSelectedComponents(a5,arr4V);
1514         self.assertEqual(6,a2.getNumberOfComponents());
1515         self.assertEqual(5,a2.getNumberOfTuples());
1516         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
1517         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
1518         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
1519         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
1520         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
1521         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
1522         expected2=[2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.]
1523         for i in xrange(30):
1524             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
1525             pass
1526         a6=a5.convertToIntArr();
1527         a6.setInfoOnComponent(0,"eeee");
1528         a6.setInfoOnComponent(1,"ffff");
1529         a4.setSelectedComponents(a6,arr4V);
1530         self.assertEqual(6,a4.getNumberOfComponents());
1531         self.assertEqual(5,a4.getNumberOfTuples());
1532         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
1533         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
1534         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
1535         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
1536         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
1537         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
1538         for i in xrange(30):
1539             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
1540             pass
1541         # test of throw
1542         arr5V=[2,3,6]
1543         arr6V=[2,7,5]
1544         arr7V=[2,1,4,6]
1545         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
1546         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
1547         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
1548         arr7V=arr7V[0:3]
1549         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
1550         #
1551         pass
1552
1553     def testKeepSetSelectedComponent2(self):
1554         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1555         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
1556         a1=DataArrayDouble.New();
1557         a1.setValues(arr1,5,4);
1558         a1.setInfoOnComponent(0,"aaaa");
1559         a1.setInfoOnComponent(1,"bbbb");
1560         a1.setInfoOnComponent(2,"cccc");
1561         a1.setInfoOnComponent(3,"dddd");
1562         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
1563         f1.setTime(2.3,4,5);
1564         f1.setMesh(m1);
1565         f1.setName("f1");
1566         f1.setArray(a1);
1567         f1.checkConsistencyLight();
1568         #
1569         arr2V=[1,2,1,2,0,0]
1570         f2=f1.keepSelectedComponents(arr2V);
1571         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
1572         t,dt,it=f2.getTime()
1573         self.assertAlmostEqual(2.3,t,13);
1574         self.assertEqual(4,dt);
1575         self.assertEqual(5,it);
1576         f2.checkConsistencyLight();
1577         self.assertEqual(6,f2.getNumberOfComponents());
1578         self.assertEqual(5,f2.getNumberOfTuples());
1579         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
1580         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
1581         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
1582         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
1583         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
1584         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
1585         expected1=[2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.]
1586         for i in xrange(30):
1587             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
1588             pass
1589         #setSelectedComponents
1590         arr3V=[3,2]
1591         f5=f1.keepSelectedComponents(arr3V);
1592         f5.setTime(6.7,8,9);
1593         f5.getArray().setInfoOnComponent(0,"eeee");
1594         f5.getArray().setInfoOnComponent(1,"ffff");
1595         f5.checkConsistencyLight();
1596         arr4V=[1,2]
1597         f2.setSelectedComponents(f5,arr4V);
1598         self.assertEqual(6,f2.getNumberOfComponents());
1599         self.assertEqual(5,f2.getNumberOfTuples());
1600         f2.checkConsistencyLight();
1601         t,dt,it=f2.getTime()
1602         self.assertAlmostEqual(2.3,t,13);
1603         self.assertEqual(4,dt);
1604         self.assertEqual(5,it);
1605         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
1606         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
1607         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
1608         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
1609         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
1610         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
1611         expected2=[2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.]
1612         for i in xrange(30):
1613             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
1614             pass
1615         #
1616         pass
1617
1618     def testElementaryDAThrowAndSpecialCases(self):
1619         da=DataArrayInt.New();
1620         self.assertRaises(InterpKernelException, da.checkAllocated);
1621         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
1622         self.assertRaises(InterpKernelException, da.iota, 1);
1623         da.alloc(7,1);
1624         da.fillWithValue(11); #11,11,11,11...
1625         da.iota(10); #10,11,12,13...
1626
1627         db=DataArrayInt.New();
1628         db.alloc(7,2);
1629
1630         dbl2=DataArrayDouble.New();
1631         dbl2.alloc(7,2);
1632         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
1633         self.assertRaises(InterpKernelException, dbl2.sort);
1634         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
1635
1636         dbl=DataArrayDouble.New();
1637         #DataArrayDouble not allocated yet
1638         self.assertRaises(InterpKernelException, dbl.iota, 10.);
1639         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
1640         self.assertRaises(InterpKernelException, dbl.sort);
1641         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
1642         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
1643
1644         dbl.alloc(7,1);
1645         dbl.iota(10.);
1646         self.assertTrue(not dbl.isUniform(10.,1e-15));
1647         dbl.sort();
1648         self.assertTrue(dbl.isMonotonic(True, .99));
1649         self.assertTrue(dbl.isMonotonic(True, -.99));
1650         self.assertTrue(not dbl.isMonotonic(True, 1.1));
1651         self.assertTrue(not dbl.isMonotonic(True, -1.1));
1652         dbl.reverse();
1653         self.assertTrue(dbl.isMonotonic(False, .99));
1654         self.assertTrue(not dbl.isMonotonic(False, 1.1));
1655         self.assertTrue(not dbl.isMonotonic(False, -1.1));
1656
1657         dc=DataArrayInt.New();
1658         dc.alloc(14,1);
1659
1660         dd=DataArrayDouble.New();
1661         self.assertRaises(InterpKernelException, dd.checkAllocated);
1662         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
1663         self.assertRaises(InterpKernelException, dd.iota, 1.);
1664         self.assertTrue(not ((dd.repr().find("No data"))==-1));
1665
1666         dd.alloc(0,1); #Allocated but nbOfElements==0!
1667         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
1668         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
1669         dd.fillWithValue(11); #?!...ok
1670         dd.iota(10); #?!...ok
1671         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
1672         self.assertTrue(dd.isMonotonic(False, 1.));
1673
1674         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
1675         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
1676         cIds=[2,2]
1677         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
1678         cIds[0]=1;
1679         cIds[0]=-1;
1680         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
1681
1682         info=["infoOfOneComponent"]*2;
1683         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
1684         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
1685         db.setInfoOnComponents(info);
1686
1687         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
1688         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
1689         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
1690         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
1691         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
1692         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
1693         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
1694
1695         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
1696         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
1697         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
1698         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
1699
1700         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
1701         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
1702         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
1703         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
1704
1705         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
1706         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
1707         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
1708
1709         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
1710         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
1711
1712         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
1713         db.checkNbOfElems(7*2,"theMessageInThrow");
1714
1715         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
1716         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
1717         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
1718         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
1719         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
1720
1721         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
1722         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
1723         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
1724
1725         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
1726         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
1727         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
1728
1729         self.assertRaises(InterpKernelException, dbl.selectByTupleIdSafeSlice, 0, 1, -1);
1730         self.assertRaises(InterpKernelException, dbl.subArray, -1, 1);
1731         self.assertRaises(InterpKernelException, dbl.subArray, 8, 1);
1732         self.assertRaises(InterpKernelException, dbl.subArray, 0, 8);
1733         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
1734
1735         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
1736         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
1737
1738         dbl3=DataArrayDouble.New();
1739         dbl3.alloc(6,2);
1740         dbl3.fillWithValue(11.);
1741         #bad number of components
1742         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
1743         self.assertRaises(InterpKernelException, dd.getMaxValue);
1744         self.assertRaises(InterpKernelException, dbl3.getMinValue);
1745         self.assertRaises(InterpKernelException, dd.getMinValue);
1746         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
1747         self.assertRaises(InterpKernelException, dd.getAverageValue);
1748         self.assertRaises(InterpKernelException, dd.accumulate, 100);
1749         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
1750         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
1751         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
1752         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
1753         self.assertRaises(InterpKernelException, dbl3.determinant);
1754         self.assertRaises(InterpKernelException, dbl3.eigenValues);
1755         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
1756         self.assertRaises(InterpKernelException, dbl3.inverse);
1757         self.assertRaises(InterpKernelException, dbl3.trace);
1758         self.assertRaises(InterpKernelException, dbl3.deviator);
1759
1760         dbl3.setIJ(5,1,12.);
1761         self.assertTrue(dbl3.getMaxValueInArray()==12.);
1762         self.assertTrue(dbl3.getMinValueInArray()==11.);
1763
1764         db.fillWithValue(100); #bad Ids
1765         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
1766         db.fillWithValue(-1); #bad Ids
1767         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
1768         db.fillWithValue(6); #bad Ids for dbl3
1769         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
1770
1771         dbl3.checkNoNullValues();
1772         dbl3.setIJ(5,0,0.);
1773         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
1774         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
1775         self.assertRaises(InterpKernelException, dbl2.findIdsInRange, 1., 2.);
1776         a=[]
1777         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
1778         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
1779
1780         a=[dbl2,dbl]; #Nb of components mismatch
1781         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
1782
1783         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
1784
1785         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
1786         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
1787         dbl4=DataArrayDouble.New();
1788         dbl4.alloc(6,3);
1789         dbl5=DataArrayDouble.New();
1790         dbl5.alloc(7,3);
1791         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
1792
1793         a[0]=dbl4; #Nb of tuple mismatch
1794         a[1]=dbl5; #Nb of tuple mismatch
1795         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
1796         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
1797         pass
1798
1799     def testDAIGetIdsEqual1(self):
1800         tab1=[5,-2,-4,-2,3,2,-2];
1801         da=DataArrayInt.New();
1802         da.setValues(tab1,7,1);
1803         da2=da.findIdsEqual(-2);
1804         self.assertEqual(3,da2.getNumberOfTuples());
1805         self.assertEqual(1,da2.getNumberOfComponents());
1806         expected1=[1,3,6];
1807         self.assertEqual(expected1,da2.getValues());
1808         pass
1809
1810     def testDAIGetIdsEqualList1(self):
1811         tab1=[5,-2,-4,-2,3,2,-2];
1812         da=DataArrayInt.New();
1813         da.setValues(tab1,7,1);
1814         da2=da.findIdsEqualList([3,-2,0]);
1815         self.assertEqual(4,da2.getNumberOfTuples());
1816         self.assertEqual(1,da2.getNumberOfComponents());
1817         expected1=[1,3,4,6];
1818         self.assertEqual(expected1,da2.getValues());
1819         pass
1820
1821     def testDAFromNoInterlace1(self):
1822         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
1823         da=DataArrayInt.New();
1824         da.setValues(tab1,5,3);
1825         da2=da.fromNoInterlace();
1826         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
1827         self.assertEqual(5,da2.getNumberOfTuples());
1828         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
1829         self.assertEqual(expected1,da2.getValues());
1830         da3=da.convertToDblArr();
1831         da4=da3.fromNoInterlace();
1832         self.assertEqual(5,da4.getNumberOfTuples());
1833         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
1834         for i in xrange(15):
1835             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
1836             pass
1837         pass
1838
1839     def testDAToNoInterlace1(self):
1840         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
1841         da=DataArrayInt.New();
1842         da.setValues(tab1,5,3);
1843         da2=da.toNoInterlace();
1844         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
1845         self.assertEqual(5,da2.getNumberOfTuples());
1846         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
1847         self.assertEqual(expected1,da2.getValues());
1848         da3=da.convertToDblArr();
1849         da4=da3.toNoInterlace();
1850         self.assertEqual(5,da4.getNumberOfTuples());
1851         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
1852         for i in xrange(15):
1853             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
1854             pass
1855         pass
1856
1857     def testDAIsUniform1(self):
1858         tab1=[1,1,1,1,1]
1859         da=DataArrayInt.New();
1860         da.setValues(tab1,5,1);
1861         self.assertTrue(da.isUniform(1));
1862         da.setIJ(2,0,2);
1863         self.assertTrue(not da.isUniform(1));
1864         da.setIJ(2,0,1);
1865         self.assertTrue(da.isUniform(1));
1866         da2=da.convertToDblArr();
1867         self.assertTrue(da2.isUniform(1.,1.e-12));
1868         da2.setIJ(1,0,1.+1.e-13);
1869         self.assertTrue(da2.isUniform(1.,1.e-12));
1870         da2.setIJ(1,0,1.+1.e-11);
1871         self.assertTrue(not da2.isUniform(1.,1.e-12));
1872         pass
1873
1874     def testDADFromPolarToCart1(self):
1875         tab1=[2.,0.2,2.5,0.7]
1876         da=DataArrayDouble.New();
1877         da.setValues(tab1,2,2);
1878         da2=da.fromPolarToCart();
1879         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
1880         for i in xrange(4):
1881             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
1882             pass
1883         pass
1884
1885     def testDADFromCylToCart1(self):
1886         tab1=[2.,0.2,4.,2.5,0.7,9.]
1887         da=DataArrayDouble.New();
1888         da.setValues(tab1,2,3);
1889         da2=da.fromCylToCart();
1890         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
1891         for i in xrange(6):
1892             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
1893             pass
1894         pass
1895
1896     def testDADFromSpherToCart1(self):
1897         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
1898         da=DataArrayDouble.New();
1899         da.setValues(tab1,2,3);
1900         da2=da.fromSpherToCart();
1901         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
1902         for i in xrange(6):
1903             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
1904             pass
1905         pass
1906
1907     def testUnPolyze1(self):
1908         elts=[0,1,2,3,4,5,6,7]
1909         eltsV=elts;
1910         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1911         mesh.convertToPolyTypes(eltsV);
1912         mesh.unPolyze();
1913         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
1914         mesh.checkConsistencyLight();
1915         self.assertTrue(mesh.isEqual(mesh2,1e-12));
1916         mesh.convertToPolyTypes(eltsV);
1917         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
1918         mesh.getNodalConnectivity().setIJ(0,6,10);
1919         mesh.getNodalConnectivity().setIJ(0,7,9);
1920         mesh.getNodalConnectivity().setIJ(0,8,12);
1921         mesh.getNodalConnectivity().setIJ(0,9,13);
1922         mesh.unPolyze();
1923         self.assertTrue(mesh.isEqual(mesh2,1e-12));
1924         mesh.convertToPolyTypes(eltsV);
1925         mesh.getNodalConnectivity().setIJ(0,6,12);
1926         mesh.getNodalConnectivity().setIJ(0,7,13);
1927         mesh.getNodalConnectivity().setIJ(0,8,10);
1928         mesh.getNodalConnectivity().setIJ(0,9,9);
1929         mesh.unPolyze();
1930         self.assertTrue(mesh.isEqual(mesh2,1e-12));
1931         mesh.convertToPolyTypes(eltsV);
1932         mesh.getNodalConnectivity().setIJ(0,6,12);
1933         mesh.getNodalConnectivity().setIJ(0,7,10);
1934         mesh.getNodalConnectivity().setIJ(0,8,13);
1935         mesh.getNodalConnectivity().setIJ(0,9,9);
1936         mesh.unPolyze();
1937         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
1938         # Test for 2D mesh
1939         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1940         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
1941         eltsV=eltsV[:5];
1942         mesh.convertToPolyTypes(eltsV);
1943         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
1944         mesh.unPolyze();
1945         self.assertTrue(mesh.isEqual(mesh2,1e-12));
1946         pass
1947
1948     def testConvertDegeneratedCells1(self):
1949         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1950         conn=[0,1,3,3,9,10,12,12, 0,1,3,4,9,9,9,9, 1,1,1,1,10,12,9,10, 10,11,12,9,1,1,1,1]
1951         mesh.allocateCells(4);
1952         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
1953         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
1954         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
1955         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
1956         mesh.finishInsertingCells();
1957         mesh.checkConsistencyLight();
1958         self.assertEqual(4,mesh.getNumberOfCells());
1959         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
1960         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
1961         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
1962         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
1963         f1=mesh.getMeasureField(True);
1964         mesh.convertDegeneratedCells();
1965         mesh.checkConsistencyLight();
1966         f2=mesh.getMeasureField(True);
1967         self.assertEqual(4,mesh.getNumberOfCells());
1968         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
1969         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
1970         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
1971         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
1972         for i in xrange(4):
1973             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
1974             pass
1975         pass
1976
1977     def testGetNodeIdsNearPoints1(self):
1978         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1979         coords=mesh.getCoords();
1980         tmp=DataArrayDouble.New();
1981         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
1982         tmp.setValues(vals,3,2);
1983         tmp2=DataArrayDouble.Aggregate(coords,tmp);
1984         mesh.setCoords(tmp2);
1985         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
1986         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
1987         self.assertEqual([4,9,11],c.getValues());
1988         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
1989         self.assertEqual([0,3,3,4],cI.getValues());
1990         self.assertEqual([4,9,11,6],c.getValues());
1991         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
1992         self.assertEqual([0,3,3,4],cI.getValues());
1993         self.assertEqual([4,9,11,6],c.getValues());
1994         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
1995         self.assertEqual([0,3,3,4],cI.getValues());
1996         self.assertEqual([4,9,11,6],c.getValues());
1997         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
1998         pass
1999
2000     def testFieldCopyTinyAttrFrom1(self):
2001         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2002         f1.setName("f1");
2003         f1.setTimeTolerance(1.e-5);
2004         f1.setDescription("f1Desc");
2005         f1.setTime(1.23,4,5);
2006         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2007         f2.setName("f2");
2008         f2.setDescription("f2Desc");
2009         f2.setTime(6.78,9,10);
2010         f2.setTimeTolerance(4.556e-12);
2011         #
2012         f1.copyTinyAttrFrom(f2);
2013         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2014         t,dt,it=f1.getTime()
2015         self.assertAlmostEqual(6.78,t,12);
2016         self.assertEqual(9,dt);
2017         self.assertEqual(10,it);
2018         self.assertTrue(f1.getName()=="f1");#name unchanged
2019         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2020         #
2021         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2022         f1.setName("f1");
2023         f1.setTimeTolerance(1.e-5);
2024         f1.setDescription("f1Desc");
2025         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2026         f2.setName("f2");
2027         f2.setDescription("f2Desc");
2028         f2.setTimeTolerance(4.556e-12);
2029         #
2030         f1.copyTinyAttrFrom(f2);
2031         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2032         self.assertTrue(f1.getName()=="f1");#name unchanged
2033         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2034         #
2035         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
2036         f1.setName("f1");
2037         f1.setTimeTolerance(1.e-5);
2038         f1.setDescription("f1Desc");
2039         f1.setTime(1.23,4,5);
2040         f1.setEndTime(5.43,2,1);
2041         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
2042         f2.setName("f2");
2043         f2.setDescription("f2Desc");
2044         f2.setTimeTolerance(4.556e-12);
2045         f2.setTime(6.78,9,10);
2046         f2.setEndTime(10.98,7,6);
2047         #
2048         f1.copyTinyAttrFrom(f2);
2049         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2050         self.assertTrue(f1.getName()=="f1");#name unchanged
2051         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2052         t,dt,it=f1.getTime()
2053         self.assertAlmostEqual(6.78,t,12);
2054         self.assertEqual(9,dt);
2055         self.assertEqual(10,it);
2056         t,dt,it=f1.getEndTime()
2057         self.assertAlmostEqual(10.98,t,12);
2058         self.assertEqual(7,dt);
2059         self.assertEqual(6,it);
2060         #
2061         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2062         f1.setName("f1");
2063         f1.setTimeTolerance(1.e-5);
2064         f1.setDescription("f1Desc");
2065         f1.setTime(1.23,4,5);
2066         f1.setEndTime(5.43,2,1);
2067         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2068         f2.setName("f2");
2069         f2.setDescription("f2Desc");
2070         f2.setTimeTolerance(4.556e-12);
2071         f2.setTime(6.78,9,10);
2072         f2.setEndTime(10.98,7,6);
2073         #
2074         f1.copyTinyAttrFrom(f2);
2075         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2076         self.assertTrue(f1.getName()=="f1");#name unchanged
2077         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2078         t,dt,it=f1.getTime()
2079         self.assertAlmostEqual(6.78,t,12);
2080         self.assertEqual(9,dt);
2081         self.assertEqual(10,it);
2082         t,dt,it=f1.getEndTime()
2083         self.assertAlmostEqual(10.98,t,12);
2084         self.assertEqual(7,dt);
2085         self.assertEqual(6,it);
2086         pass
2087
2088     def testExtrudedMesh5(self):
2089         coo1=[0.,1.,2.,3.5]
2090         a=DataArrayDouble.New();
2091         a.setValues(coo1,4,1);
2092         b=MEDCouplingCMesh.New();
2093         b.setCoordsAt(0,a);
2094         c=b.buildUnstructured();
2095         self.assertEqual(1,c.getSpaceDimension());
2096         c.changeSpaceDimension(2);
2097         #
2098         d=DataArrayDouble.New();
2099         d.alloc(13,1);
2100         d.iota();
2101         e=MEDCouplingCMesh.New();
2102         e.setCoordsAt(0,d);
2103         f=e.buildUnstructured();
2104         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
2105         self.assertRaises(InterpKernelException,f.getCoords().applyFunc,2,"3.5*IVec+x/6*3.14159265359*KVec"); # KVec refers to component #2 and there is only 2 components !
2106         h=g.fromPolarToCart();
2107         f.setCoords(h);
2108         i=c.buildExtrudedMesh(f,1);
2109         self.assertEqual(52,i.getNumberOfNodes());
2110         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
2111         self.assertTrue(tmp2);
2112         self.assertEqual(37,tmp3);
2113         i.convertDegeneratedCells();
2114         i.checkConsistencyLight();
2115         self.assertEqual(36,i.getNumberOfCells());
2116         self.assertEqual(37,i.getNumberOfNodes());
2117         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
2118         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
2119         expected1=[0.25,0.75,2.0625]
2120         j=i.getMeasureField(True);
2121         for ii in xrange(12):
2122             for k in xrange(3):
2123                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
2124                 pass
2125             pass
2126         expected2=[0.62200846792814113, 0.16666666666681595, 1.4513530918323276, 0.38888888888923495, 2.6293994326053212, 0.7045454545460802, 0.45534180126145435, 0.45534180126150181, 1.0624642029433926, 1.0624642029435025, 1.9248539780597826, 1.9248539780599816, 0.16666666666661334, 0.62200846792815856, 0.38888888888876294, 1.4513530918323678, 0.70454545454522521, 2.629399432605394, -0.16666666666674007, 0.62200846792812436, -0.38888888888906142, 1.4513530918322881, -0.70454545454576778, 2.6293994326052488, -0.45534180126154766, 0.45534180126140844, -1.0624642029436118, 1.0624642029432834, -1.9248539780601803, 1.9248539780595841, -0.62200846792817499, 0.1666666666665495, -1.451353091832408, 0.388888888888613, -2.6293994326054668, 0.70454545454495332, -0.62200846792810593, -0.16666666666680507, -1.451353091832247, -0.38888888888921297, -2.6293994326051746, -0.70454545454604123, -0.45534180126135926, -0.45534180126159562, -1.0624642029431723, -1.0624642029437235, -1.9248539780593836, -1.9248539780603811, -0.1666666666664828, -0.62200846792819242, -0.38888888888846079, -1.4513530918324489, -0.70454545454467987, -2.6293994326055397, 0.16666666666687083, -0.62200846792808862, 0.38888888888936374, -1.4513530918322073, 0.70454545454631357, -2.6293994326051022, 0.45534180126164348, -0.45534180126131207, 1.0624642029438327, -1.0624642029430627, 1.9248539780605791, -1.9248539780591853, 0.62200846792821063, -0.16666666666641802, 1.4513530918324888, -0.38888888888831086, 2.6293994326056125, -0.70454545454440853]
2127         m=i.computeCellCenterOfMass();
2128         for i in xrange(72):
2129             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
2130             pass
2131         #
2132         pass
2133
2134     def testExtrudedMesh6(self):
2135         coo1=[0.,1.,2.,3.5]
2136         a=DataArrayDouble.New();
2137         a.setValues(coo1,4,1);
2138         b=MEDCouplingCMesh.New();
2139         b.setCoordsAt(0,a);
2140         c=b.buildUnstructured();
2141         self.assertEqual(1,c.getSpaceDimension());
2142         c.changeSpaceDimension(2);
2143         #
2144         d=DataArrayDouble.New();
2145         d.alloc(5);
2146         d.iota();
2147         e=MEDCouplingCMesh.New();
2148         e.setCoordsAt(0,d);
2149         f=e.buildUnstructured();
2150         d2=f.getCoords().applyFunc("x*x/2");
2151         f.setCoords(d2);
2152         f.changeSpaceDimension(2);
2153         #
2154         center=[0.,0.]
2155         f.rotate(center,None,pi/3);
2156         g=c.buildExtrudedMesh(f,0);
2157         g.checkConsistencyLight();
2158         expected1=[ 0.4330127018922193, 0.4330127018922193, 0.649519052838329, 1.2990381056766578, 1.299038105676658, 1.948557158514987, 2.1650635094610955, 2.1650635094610964, 3.2475952641916446, 3.031088913245533, 3.0310889132455352, 4.546633369868303 ]
2159         f1=g.getMeasureField(True);
2160         for i in xrange(12):
2161             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
2162             pass
2163         expected2=[0.625, 0.21650635094610962, 1.625, 0.21650635094610959, 2.8750000000000004, 0.21650635094610965, 1.1250000000000002, 1.0825317547305482, 2.125, 1.0825317547305482, 3.3750000000000004, 1.0825317547305484, 2.125, 2.8145825622994254, 3.125, 2.8145825622994254, 4.375, 2.8145825622994254, 3.6250000000000009, 5.4126587736527414, 4.625, 5.4126587736527414, 5.875, 5.4126587736527414]
2164         f2=g.computeCellCenterOfMass();
2165         for i in xrange(24):
2166             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
2167             pass
2168         pass
2169
2170     def testExtrudedMesh7(self):
2171         coo1=[0.,1.,2.,3.5]
2172         a=DataArrayDouble.New();
2173         a.setValues(coo1,4,1);
2174         b=MEDCouplingCMesh.New();
2175         b.setCoordsAt(0,a);
2176         c=b.buildUnstructured();
2177         self.assertEqual(1,c.getSpaceDimension());
2178         c.changeSpaceDimension(2);
2179         #
2180         d=DataArrayDouble.New();
2181         d.alloc(13,1);
2182         d.iota();
2183         e=MEDCouplingCMesh.New();
2184         e.setCoordsAt(0,d);
2185         f=e.buildUnstructured();
2186         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
2187         h=g.fromPolarToCart();
2188         f.setCoords(h);
2189         i=c.buildExtrudedMesh(f,1);
2190         self.assertEqual(52,i.getNumberOfNodes());
2191         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
2192         self.assertTrue(tmp2);
2193         self.assertEqual(37,tmp3);
2194         i.convertDegeneratedCells();
2195         vec1=[10.,0]
2196         i.translate(vec1);
2197         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
2198         f.setCoords(g2);
2199         i.changeSpaceDimension(3);
2200         i3=i.buildExtrudedMesh(f,1);
2201         f2=i3.getMeasureField(True);
2202         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
2203         self.assertTrue(tmp2);
2204         self.assertEqual(444,tmp3);
2205         expected1=[1.327751058489274, 4.2942574094314701, 13.024068164857139, 1.3069177251569044, 4.1484240761012954, 12.297505664866796, 1.270833333332571, 3.8958333333309674, 11.039062499993179, 1.2291666666659207, 3.6041666666644425, 9.585937499993932, 1.1930822748415895, 3.3515759238941376, 8.3274943351204556, 1.1722489415082769, 3.2057425905609289, 7.6009318351210622, 1.1722489415082862, 3.2057425905609884, 7.6009318351213713, 1.1930822748416161, 3.3515759238943001, 8.3274943351212727, 1.2291666666659564, 3.6041666666646734, 9.5859374999950777, 1.2708333333326081, 3.8958333333311868, 11.039062499994293, 1.3069177251569224, 4.1484240761014384, 12.297505664867627, 1.3277510584902354, 4.2942574094346071, 13.024068164866796]
2206         for ii in xrange(12):
2207             for jj in xrange(36):
2208                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
2209                 pass
2210         #
2211         pass
2212
2213     def testSimplexize1(self):
2214         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2215         m.convertToPolyTypes([3]);
2216         da=m.simplexize(0);
2217         self.assertEqual(7,da.getNumberOfTuples());
2218         self.assertEqual(1,da.getNumberOfComponents());
2219         expected2=[0,0,1,2,3,4,4]
2220         for i in xrange(7):
2221             self.assertEqual(expected2[i],da.getIJ(i,0));
2222             pass
2223         m.checkConsistencyLight();
2224         self.assertEqual(7,m.getNumberOfCells());
2225         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
2226         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2227         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
2228         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2229         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
2230         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
2231         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
2232         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
2233         f=m.getMeasureField(False);
2234         for i in xrange(7):
2235             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
2236             pass
2237         types=m.getAllGeoTypes();
2238         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
2239         #
2240         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2241         m.convertToPolyTypes([3]);
2242         da=m.simplexize(1);
2243         self.assertEqual(7,da.getNumberOfTuples());
2244         self.assertEqual(1,da.getNumberOfComponents());
2245         for i in xrange(7):
2246             self.assertEqual(expected2[i],da.getIJ(i,0));
2247             pass
2248         m.checkConsistencyLight();
2249         types=m.getAllGeoTypes();
2250         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
2251         self.assertEqual(7,m.getNumberOfCells());
2252         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
2253         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2254         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
2255         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2256         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
2257         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
2258         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
2259         f=m.getMeasureField(False);
2260         for i in xrange(7):
2261             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
2262             pass
2263         pass
2264
2265     def testSimplexize2(self):
2266         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2267         m.convertToPolyTypes([3]);
2268         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2269         f1.setMesh(m);
2270         arr=DataArrayDouble.New();
2271         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
2272         arr.setValues(arr1,5,2);
2273         f1.setArray(arr);
2274         #
2275         f1.checkConsistencyLight();
2276         self.assertTrue(f1.simplexize(0));
2277         f1.checkConsistencyLight();
2278         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
2279         for i in xrange(14):
2280             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
2281             pass
2282         self.assertTrue(not f1.simplexize(0));
2283         for i in xrange(14):
2284             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
2285             pass
2286         #
2287         pass
2288
2289     def testDAMeld1(self):
2290         da1=DataArrayDouble.New();
2291         da1.alloc(7,2);
2292         da2=DataArrayDouble.New();
2293         da2.alloc(7,1);
2294         #
2295         da1.fillWithValue(7.);
2296         da2.iota(0.);
2297         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
2298         #
2299         da1.setInfoOnComponent(0,"c0da1");
2300         da1.setInfoOnComponent(1,"c1da1");
2301         da3.setInfoOnComponent(0,"c0da3");
2302         da3.setInfoOnComponent(1,"c1da3");
2303         da3.setInfoOnComponent(2,"c2da3");
2304         #
2305         da1C=da1.deepCopy();
2306         da1.meldWith(da3);
2307         self.assertEqual(5,da1.getNumberOfComponents());
2308         self.assertEqual(7,da1.getNumberOfTuples());
2309         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
2310         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
2311         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
2312         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
2313         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
2314         #
2315         expected1=[7.,7.,0.,0.,0., 7.,7.,10.,100.,1000., 7.,7.,20.,200.,2000., 7.,7.,30.,300.,3000., 7.,7.,40.,400.,4000.,7.,7.,50.,500.,5000.,7.,7.,60.,600.,6000.]
2316         for i in xrange(35):
2317             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
2318             pass
2319         #
2320         dai1=da1C.convertToIntArr();
2321         dai3=da3.convertToIntArr();
2322         dai1.meldWith(dai3);
2323         self.assertEqual(5,dai1.getNumberOfComponents());
2324         self.assertEqual(7,dai1.getNumberOfTuples());
2325         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
2326         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
2327         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
2328         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
2329         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
2330         for i in xrange(35):
2331             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
2332             pass
2333         # test of static method DataArrayDouble::meld
2334         da4=DataArrayDouble.Meld(da1C,da3);
2335         tmp=DataArrayDouble.Meld([da1C,da3]);
2336         self.assertTrue(da4.isEqual(tmp,1e-10))
2337         self.assertEqual(5,da4.getNumberOfComponents());
2338         self.assertEqual(7,da4.getNumberOfTuples());
2339         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
2340         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
2341         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
2342         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
2343         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
2344         for i in xrange(35):
2345             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
2346             pass
2347         # test of static method DataArrayInt::meld
2348         dai1=da1C.convertToIntArr();
2349         dai4=DataArrayInt.Meld(dai1,dai3);
2350         tmp=DataArrayInt.Meld([dai1,dai3]);
2351         self.assertTrue(dai4.isEqual(tmp))
2352         self.assertEqual(5,dai4.getNumberOfComponents());
2353         self.assertEqual(7,dai4.getNumberOfTuples());
2354         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
2355         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
2356         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
2357         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
2358         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
2359         for i in xrange(35):
2360             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
2361             pass
2362         pass
2363
2364     def testFieldMeld1(self):
2365         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2366         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2367         f1.setMesh(m);
2368         da1=DataArrayDouble.New();
2369         arr1=[12.,23.,34.,45.,56.]
2370         da1.setValues(arr1,5,1);
2371         da1.setInfoOnComponent(0,"aaa");
2372         f1.setArray(da1);
2373         f1.setTime(3.4,2,1);
2374         f1.checkConsistencyLight();
2375         #
2376         f2=f1.deepCopy();
2377         f2.setMesh(f1.getMesh());
2378         f2.checkConsistencyLight();
2379         f2.changeNbOfComponents(2,5.);
2380         f2.assign(5.);
2381         f2.getArray().setInfoOnComponent(0,"bbb");
2382         f2.getArray().setInfoOnComponent(1,"ccc");
2383         f2.checkConsistencyLight();
2384         #
2385         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
2386         f3.checkConsistencyLight();
2387         self.assertEqual(5,f3.getNumberOfTuples());
2388         self.assertEqual(3,f3.getNumberOfComponents());
2389         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
2390         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
2391         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
2392         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
2393         for i in xrange(15):
2394             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
2395             pass
2396         time,dt,it=f3.getTime();
2397         self.assertAlmostEqual(3.4,time,14);
2398         self.assertEqual(2,dt);
2399         self.assertEqual(1,it);
2400         #
2401         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
2402         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
2403         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
2404         f6.checkConsistencyLight();
2405         self.assertEqual(5,f6.getNumberOfTuples());
2406         self.assertEqual(3,f6.getNumberOfComponents());
2407         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
2408         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
2409         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
2410         for i in xrange(15):
2411             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
2412             pass
2413         #
2414         pass
2415
2416     def testMergeNodes2(self):
2417         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2418         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2419         vec=[0.002,0.]
2420         m2.translate(vec);
2421         #
2422         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
2423         da,b,newNbOfNodes=m3.mergeNodesCenter(0.01);
2424         self.assertEqual(9,m3.getNumberOfNodes());
2425         expected1=[-0.299,-0.3, 0.201,-0.3, 0.701,-0.3, -0.299,0.2, 0.201,0.2, 0.701,0.2, -0.299,0.7, 0.201,0.7, 0.701,0.7]
2426         for i in xrange(18):
2427             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
2428             pass
2429         #
2430         pass
2431
2432     def testMergeField2(self):
2433         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2434         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2435         f1.setMesh(m);
2436         arr=DataArrayDouble.New();
2437         arr.alloc(5,2);
2438         arr.fillWithValue(2.);
2439         f1.setArray(arr);
2440         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2441         f2.setMesh(m);
2442         arr=DataArrayDouble.New();
2443         arr.alloc(5,2);
2444         arr.fillWithValue(5.);
2445         f2.setArray(arr);
2446         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2447         f3.setMesh(m);
2448         arr=DataArrayDouble.New();
2449         arr.alloc(5,2);
2450         arr.fillWithValue(7.);
2451         f3.setArray(arr);
2452         #
2453         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
2454         self.assertEqual(15,f4.getMesh().getNumberOfCells());
2455         expected1=[2.,2.,2.,2.,2.,2.,2.,2.,2.,2., 5.,5.,5.,5.,5.,5.,5.,5.,5.,5., 7.,7.,7.,7.,7.,7.,7.,7.,7.,7.]
2456         for i in xrange(30):
2457             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
2458             pass
2459         #
2460         pass
2461
2462     def testDAIBuildComplement1(self):
2463         a=DataArrayInt.New();
2464         tab=[3,1,7,8]
2465         a.setValues(tab,4,1);
2466         b=a.buildComplement(12);
2467         self.assertEqual(8,b.getNumberOfTuples());
2468         self.assertEqual(1,b.getNumberOfComponents());
2469         expected1=[0,2,4,5,6,9,10,11]
2470         for i in xrange(8):
2471             self.assertEqual(expected1[i],b.getIJ(0,i));
2472             pass
2473         pass
2474
2475     def testDAIBuildUnion1(self):
2476         a=DataArrayInt.New();
2477         tab1=[3,1,7,8]
2478         a.setValues(tab1,4,1);
2479         c=DataArrayInt.New();
2480         tab2=[5,3,0,18,8]
2481         c.setValues(tab2,5,1);
2482         b=a.buildUnion(c);
2483         self.assertEqual(7,b.getNumberOfTuples());
2484         self.assertEqual(1,b.getNumberOfComponents());
2485         expected1=[0,1,3,5,7,8,18]
2486         for i in xrange(7):
2487             self.assertEqual(expected1[i],b.getIJ(0,i));
2488             pass
2489         b=DataArrayInt.BuildUnion([a,c]);
2490         self.assertEqual(7,b.getNumberOfTuples());
2491         self.assertEqual(1,b.getNumberOfComponents());
2492         expected1=[0,1,3,5,7,8,18]
2493         for i in xrange(7):
2494             self.assertEqual(expected1[i],b.getIJ(0,i));
2495             pass
2496         pass
2497
2498     def testDAIBuildIntersection1(self):
2499         a=DataArrayInt.New();
2500         tab1=[3,1,7,8]
2501         a.setValues(tab1,4,1);
2502         c=DataArrayInt.New();
2503         tab2=[5,3,0,18,8]
2504         c.setValues(tab2,5,1);
2505         b=a.buildIntersection(c);
2506         self.assertEqual(2,b.getNumberOfTuples());
2507         self.assertEqual(1,b.getNumberOfComponents());
2508         expected1=[3,8]
2509         for i in xrange(2):
2510             self.assertEqual(expected1[i],b.getIJ(0,i));
2511             pass
2512         b=DataArrayInt.BuildIntersection([a,c]);
2513         self.assertEqual(2,b.getNumberOfTuples());
2514         self.assertEqual(1,b.getNumberOfComponents());
2515         expected1=[3,8]
2516         for i in xrange(2):
2517             self.assertEqual(expected1[i],b.getIJ(0,i));
2518             pass
2519         pass
2520
2521     def testDAIDeltaShiftIndex1(self):
2522         a=DataArrayInt.New();
2523         tab=[1,3,6,7,7,9,15]
2524         a.setValues(tab,7,1);
2525         b=a.deltaShiftIndex();
2526         self.assertEqual(6,b.getNumberOfTuples());
2527         self.assertEqual(1,b.getNumberOfComponents());
2528         expected1=[2,3,1,0,2,6]
2529         for i in xrange(6):
2530             self.assertEqual(expected1[i],b.getIJ(0,i));
2531             pass
2532         pass
2533
2534     def testDaDoubleSelectByTupleIdSafe1(self):
2535         a=DataArrayDouble.New();
2536         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
2537         a.setValues(arr1,7,2);
2538         a.setInfoOnComponent(0,"toto");
2539         a.setInfoOnComponent(1,"tata");
2540         #
2541         arr2=[4,2,0,6,5]
2542         b=a.selectByTupleIdSafe(arr2);
2543         self.assertEqual(5,b.getNumberOfTuples());
2544         self.assertEqual(2,b.getNumberOfComponents());
2545         self.assertTrue(b.getInfoOnComponent(0)=="toto");
2546         self.assertTrue(b.getInfoOnComponent(1)=="tata");
2547         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
2548         for i in xrange(10):
2549             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
2550             pass
2551         arr4=[4,-1,0,6,5]
2552         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
2553         arr5=[4,2,0,6,7]
2554         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
2555         #
2556         c=DataArrayInt.New();
2557         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
2558         c.setValues(arr3,7,2);
2559         c.setInfoOnComponent(0,"toto");
2560         c.setInfoOnComponent(1,"tata");
2561         d=c.selectByTupleIdSafe(arr2);
2562         self.assertEqual(5,d.getNumberOfTuples());
2563         self.assertEqual(2,d.getNumberOfComponents());
2564         self.assertTrue(d.getInfoOnComponent(0)=="toto");
2565         self.assertTrue(d.getInfoOnComponent(1)=="tata");
2566         expected2=[5,15,3,13,1,11,7,17,6,16]
2567         for i in xrange(10):
2568             self.assertEqual(expected2[i],d.getIJ(0,i));
2569             pass
2570         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
2571         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
2572         pass
2573
2574     def testAreCellsIncludedIn1(self):
2575         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2576         pt=[1,3]
2577         m2=m.buildPartOfMySelf(pt,True);
2578         ret,tmp=m.areCellsIncludedIn(m2,0)
2579         self.assertTrue(ret);
2580         self.assertEqual(2,tmp.getNumberOfTuples());
2581         self.assertEqual(1,tmp.getNumberOfComponents());
2582         self.assertEqual(pt[0],tmp.getIJ(0,0));
2583         self.assertEqual(pt[1],tmp.getIJ(0,1));
2584         ret,tmp=m2.areCellsIncludedIn(m,0)
2585         self.assertTrue(not ret);
2586         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
2587         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
2588         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
2589         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
2590         pass
2591
2592     def testSwigErrorProtection1(self):
2593         m=MEDCouplingDataForTest.build3DTargetMesh_1();
2594         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
2595         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
2596         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
2597         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
2598         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
2599         m2=m.buildPartOfMySelf([2,5],True)
2600         m3=m.buildPartOfMySelf((2,5),True)
2601         self.assertTrue(m2.isEqual(m3,1e-12))
2602         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
2603         da1=m.getCoords().keepSelectedComponents([1])
2604         da2=m.getCoords().keepSelectedComponents((1,))
2605         self.assertTrue(da1.isEqual(da2,1e-12))
2606         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
2607         pass
2608
2609     def testDAIBuildSubstraction1(self):
2610         a=DataArrayInt.New()
2611         aa=[2,3,6,8,9]
2612         a.setValues(aa,5,1)
2613         b=DataArrayInt.New()
2614         bb=[1,3,5,9,11]
2615         b.setValues(bb,5,1)
2616         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
2617         pass
2618
2619     def testBuildOrthogonalField2(self):
2620         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2621         d1=DataArrayInt.New();
2622         d2=DataArrayInt.New();
2623         d3=DataArrayInt.New();
2624         d4=DataArrayInt.New();
2625         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
2626         #
2627         f1=m1.buildOrthogonalField();
2628         da1=f1.getArray();
2629         self.assertEqual(2,da1.getNumberOfComponents());
2630         self.assertEqual(13,da1.getNumberOfTuples());
2631         #
2632         expected1=[-1.,0.,0.,1.,1.,0.,0.,-1.,0.707106781186548,0.707106781186548,0.,-1.,0.,1.,1.,0.,0.,1.,1.,0.,-1.,0.,0.,1.,1.,0.];
2633         for i in xrange(26):
2634             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
2635             pass
2636         pass
2637
2638     def testSwigErrorProtection2(self):
2639         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2640         coo=m.getCoords()
2641         c=m.getNodalConnectivity()
2642         ci=m.getNodalConnectivityIndex()
2643         del m
2644         self.assertEqual(2,coo.getNumberOfComponents());
2645         self.assertEqual(6,ci.getNumberOfTuples());
2646         self.assertEqual(23,c.getNumberOfTuples());
2647         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2648         f=m.getMeasureField(True)
2649         c=f.getArray()
2650         del f
2651         self.assertEqual(1,c.getNumberOfComponents());
2652         m=MEDCouplingCMesh.New()
2653         x=DataArrayDouble.New()
2654         x.setValues([1.,2.,4.],3,1)
2655         m.setCoordsAt(0,x)
2656         del x
2657         xx=m.getCoordsAt(0)
2658         del m
2659         self.assertEqual(3,xx.getNumberOfTuples());
2660         #
2661         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2662         f=m.getMeasureField(True)
2663         m2=f.getMesh()
2664         del m
2665         del f
2666         self.assertEqual(5,m2.getNumberOfCells());
2667         pass
2668
2669     def testUMInsertNextCell1(self):
2670         targetCoords=[-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7 ]
2671         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
2672         targetMesh=MEDCouplingUMesh.New();
2673         targetMesh.allocateCells(5);
2674         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
2675         targetMesh.setMeshDimension(2);
2676         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
2677         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
2678         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
2679         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
2680         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
2681         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
2682         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
2683         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
2684         targetMesh.finishInsertingCells();
2685         myCoords=DataArrayDouble.New();
2686         myCoords.setValues(targetCoords,9,2);
2687         targetMesh.setCoords(myCoords);
2688         targetMesh.checkConsistencyLight();
2689         pass
2690
2691     def testFieldOperatorDivDiffComp1(self):
2692         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2693         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
2694         #
2695         f1=m1.buildOrthogonalField();
2696         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
2697         arr=DataArrayDouble.New();
2698         arr.setValues(arr1,13,1);
2699         f2=MEDCouplingFieldDouble.New(ON_CELLS);
2700         f2.setArray(arr);
2701         f2.setMesh(m1);
2702         f2.checkConsistencyLight();
2703         #
2704         f3=f1/f2;
2705         self.assertRaises(InterpKernelException,f2.__div__,f1)
2706         f3.checkConsistencyLight();
2707         f1/=f2;
2708         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
2709         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
2710         expected1=[-0.5, 0.0, 0.0, 0.33333333333333331, 0.25, 0.0, 0.0, -0.20000000000000001, 0.117851130197758, 0.117851130197758, 0.0, -0.14285714285714285, 0.0, 0.125, 0.1111111111111111, 0.0, 0.0, 0.10000000000000001, 0.090909090909090912, 0.0, -0.083333333333333329, 0.0, 0.0, 0.076923076923076927, 0.071428571428571425, 0.0]
2711         for i in xrange(26):
2712             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
2713             pass
2714         pass
2715
2716     def testDARearrange1(self):
2717         da1=DataArrayInt.New();
2718         da1.alloc(12,1);
2719         da1.iota(0);
2720         #
2721         self.assertEqual(12,da1.getNbOfElems());
2722         self.assertEqual(1,da1.getNumberOfComponents());
2723         self.assertEqual(12,da1.getNumberOfTuples());
2724         da1.rearrange(4);
2725         self.assertEqual(12,da1.getNbOfElems());
2726         self.assertEqual(4,da1.getNumberOfComponents());
2727         self.assertEqual(3,da1.getNumberOfTuples());
2728         for i in xrange(12):
2729             self.assertEqual(i,da1.getIJ(0,i));
2730         #
2731         da1.rearrange(6);
2732         self.assertEqual(12,da1.getNbOfElems());
2733         self.assertEqual(6,da1.getNumberOfComponents());
2734         self.assertEqual(2,da1.getNumberOfTuples());
2735         for i in xrange(12):
2736             self.assertEqual(i,da1.getIJ(0,i));
2737         #
2738         self.assertRaises(InterpKernelException,da1.rearrange,7);
2739         #
2740         da1.rearrange(12);
2741         self.assertEqual(12,da1.getNbOfElems());
2742         self.assertEqual(12,da1.getNumberOfComponents());
2743         self.assertEqual(1,da1.getNumberOfTuples());
2744         for i in xrange(12):
2745             self.assertEqual(i,da1.getIJ(0,i));
2746         #
2747         da1.rearrange(3);
2748         self.assertEqual(12,da1.getNbOfElems());
2749         self.assertEqual(3,da1.getNumberOfComponents());
2750         self.assertEqual(4,da1.getNumberOfTuples());
2751         for i in xrange(12):
2752             self.assertEqual(i,da1.getIJ(0,i));
2753         #double
2754         da2=da1.convertToDblArr();
2755         st=da2.getHiddenCppPointer()
2756         #
2757         self.assertEqual(12,da2.getNbOfElems());
2758         self.assertEqual(3,da2.getNumberOfComponents());
2759         self.assertEqual(4,da2.getNumberOfTuples());
2760         da2.rearrange(4);
2761         self.assertEqual(12,da2.getNbOfElems());
2762         self.assertEqual(4,da2.getNumberOfComponents());
2763         self.assertEqual(3,da2.getNumberOfTuples());
2764         for i in xrange(12):
2765             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2766         #
2767         da2.rearrange(6);
2768         self.assertEqual(12,da2.getNbOfElems());
2769         self.assertEqual(6,da2.getNumberOfComponents());
2770         self.assertEqual(2,da2.getNumberOfTuples());
2771         for i in xrange(12):
2772             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2773         #
2774         self.assertRaises(InterpKernelException,da2.rearrange,7);
2775         #
2776         da2.rearrange(1);
2777         self.assertEqual(st,da2.getHiddenCppPointer())
2778         self.assertEqual(12,da2.getNbOfElems());
2779         self.assertEqual(1,da2.getNumberOfComponents());
2780         self.assertEqual(12,da2.getNumberOfTuples());
2781         for i in xrange(12):
2782             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2783         #
2784         da2.rearrange(3);
2785         self.assertEqual(12,da2.getNbOfElems());
2786         self.assertEqual(3,da2.getNumberOfComponents());
2787         self.assertEqual(4,da2.getNumberOfTuples());
2788         for i in xrange(12):
2789             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2790         pass
2791
2792     def testDARearrange2(self):
2793         da1=DataArrayInt.New();
2794         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
2795         da1.setValues(arr,4,3);
2796         s=da1.getDifferentValues();
2797         expected1=DataArrayInt([1,2,3,5])
2798         self.assertTrue(expected1.isEqual(s));
2799         pass
2800
2801     def testSwigErrorProtection3(self):
2802         da=DataArrayInt.New()
2803         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
2804         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
2805         self.assertEqual(3,da.getNumberOfComponents());
2806         self.assertEqual(4,da.getNumberOfTuples());
2807         da=DataArrayInt.New()
2808         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
2809         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
2810         self.assertEqual(3,da.getNumberOfComponents());
2811         self.assertEqual(4,da.getNumberOfTuples());
2812         da.setValues((10*[1]+290*[2])[:12],4,3)
2813         self.assertEqual(10*[1]+[2,2],da.getValues())
2814         self.assertEqual(3,da.getNumberOfComponents());
2815         self.assertEqual(4,da.getNumberOfTuples());
2816         #
2817         da=DataArrayDouble.New()
2818         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
2819         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
2820         self.assertEqual(3,da.getNumberOfComponents());
2821         self.assertEqual(4,da.getNumberOfTuples());
2822         da=DataArrayDouble.New()
2823         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
2824         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
2825         self.assertEqual(3,da.getNumberOfComponents());
2826         self.assertEqual(4,da.getNumberOfTuples());
2827         da.setValues((10*[1]+290*[2])[:12],4,3)
2828         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
2829         self.assertEqual(3,da.getNumberOfComponents());
2830         self.assertEqual(4,da.getNumberOfTuples());
2831         pass
2832
2833     def testDAIBuildPermutationArr1(self):
2834         a=DataArrayInt.New()
2835         a.setValues([4,5,6,7,8],5,1)
2836         b=DataArrayInt.New()
2837         b.setValues([5,4,8,6,7],5,1)
2838         c=a.buildPermutationArr(b)
2839         self.assertEqual([1,0,4,2,3],c.getValues())
2840         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
2841         b.setIJ(0,0,9)
2842         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
2843         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
2844         a.setIJ(3,0,4)
2845         b.setIJ(0,0,5)
2846         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
2847         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
2848         c=a.buildPermutationArr(b)
2849         self.assertEqual([1,3,4,2,3],c.getValues())
2850         d=b.convertToDblArr()
2851         expect3=[4,4,5,6,8]
2852         b.sort()
2853         self.assertEqual(expect3,b.getValues())
2854         d.sort()
2855         self.assertEqual(5,d.getNumberOfTuples());
2856         self.assertEqual(1,d.getNumberOfComponents());
2857         for i in xrange(5):
2858             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
2859             pass
2860         pass
2861
2862     def testAreCellsIncludedIn2(self):
2863         myName="Vitoo";
2864         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2865         m2=m.buildPartOfMySelf([],True);
2866         self.assertEqual(0,m2.getNumberOfCells());
2867         self.assertEqual(3,m2.getSpaceDimension());
2868         self.assertEqual(2,m2.getMeshDimension());
2869         m2.setName(myName);
2870         test,tmp=m.areCellsIncludedIn(m2,0)
2871         self.assertTrue(test);
2872         self.assertEqual(myName,tmp.getName());
2873         self.assertEqual(0,tmp.getNumberOfTuples())
2874         self.assertEqual(1,tmp.getNumberOfComponents())
2875         pass
2876
2877     def testUMeshGetPartBarycenterAndOwner1(self):
2878         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2879         part1=[1,0,4];
2880         part=DataArrayInt.New();
2881         part.setValues(part1,3,1);
2882         b=m1.getPartBarycenterAndOwner(part);
2883         self.assertEqual(2,b.getNumberOfComponents());
2884         self.assertEqual(3,b.getNumberOfTuples());
2885         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
2886         for i in xrange(6):
2887             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
2888             pass
2889         pass
2890
2891     def testUMeshGetPartMeasureField1(self):
2892         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2893         part1=[1,0,4];
2894         part=DataArrayInt.New();
2895         part.setValues(part1,3,1);
2896         b=m1.getPartMeasureField(True,part);
2897         self.assertEqual(1,b.getNumberOfComponents());
2898         self.assertEqual(3,b.getNumberOfTuples());
2899         expected1=[0.125,0.25,0.25];
2900         for i in xrange(3):
2901             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
2902             pass
2903         pass
2904
2905     def testUMeshBuildPartOrthogonalField1(self):
2906         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2907         m1.changeSpaceDimension(3);
2908         part1=[1,0,4];
2909         part=DataArrayInt.New();
2910         part.setValues(part1,3,1);
2911         b=m1.buildPartOrthogonalField(part);
2912         self.assertEqual(3,b.getArray().getNumberOfComponents());
2913         self.assertEqual(3,b.getArray().getNumberOfTuples());
2914         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
2915         for i in xrange(9):
2916             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
2917             pass
2918         pass
2919
2920     def testUMeshGetTypesOfPart1(self):
2921         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2922         part1=[0,3,4];
2923         p1=DataArrayInt.New()
2924         p1.setValues(part1,3,1)
2925         s=m1.getTypesOfPart(p1);
2926         self.assertEqual([NORM_QUAD4],s);
2927         part2=[2,2,2,1];
2928         p2=DataArrayInt.New()
2929         p2.setValues(part2,4,1)
2930         s=m1.getTypesOfPart(p2);
2931         self.assertEqual([NORM_TRI3],s);
2932         part3=[3,2,1];
2933         p3=DataArrayInt.New()
2934         p3.setValues(part3,3,1)
2935         s=m1.getTypesOfPart(p3);
2936         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
2937         pass
2938
2939     def testUMeshKeepCellIdsByType1(self):
2940         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2941         part1=[0,3,4]
2942         p1=DataArrayInt.New()
2943         p1.setValues(part1,3,1)
2944         p1.setName("p1")
2945         a=m1.keepCellIdsByType(NORM_TRI3,p1);
2946         self.assertEqual("p1",a.getName())
2947         self.assertEqual(1,a.getNumberOfComponents());
2948         self.assertEqual(0,a.getNumberOfTuples());
2949         #
2950         part2=[3,2,0,2,4]
2951         p2=DataArrayInt.New()
2952         p2.setValues(part2,5,1)
2953         p2.setName("p2")
2954         a=m1.keepCellIdsByType(NORM_TRI3,p2);
2955         self.assertEqual("p2",a.getName())
2956         self.assertEqual(1,a.getNumberOfComponents());
2957         self.assertEqual(2,a.getNumberOfTuples());
2958         self.assertEqual(2,a.getIJ(0,0));
2959         self.assertEqual(2,a.getIJ(1,0));
2960         #
2961         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
2962         self.assertEqual("p2",a.getName())
2963         self.assertEqual(1,a.getNumberOfComponents());
2964         self.assertEqual(3,a.getNumberOfTuples());
2965         self.assertEqual(3,a.getIJ(0,0));
2966         self.assertEqual(0,a.getIJ(1,0));
2967         self.assertEqual(4,a.getIJ(2,0));
2968         pass
2969
2970     def testSwigErrorDaIntSelectByTupleId1(self):
2971         a=DataArrayInt.New();
2972         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
2973         a.setValues(arr1,7,2);
2974         a.setInfoOnComponent(0,"toto");
2975         a.setInfoOnComponent(1,"tata");
2976         #
2977         arr2=[4,2,0,6,5]
2978         b=a.selectByTupleId(arr2);
2979         self.assertEqual(5,b.getNumberOfTuples());
2980         self.assertEqual(2,b.getNumberOfComponents());
2981         self.assertTrue(b.getInfoOnComponent(0)=="toto");
2982         self.assertTrue(b.getInfoOnComponent(1)=="tata");
2983         expected1=[5,15,3,13,1,11,7,17,6,16]
2984         self.assertEqual(expected1,b.getValues())
2985         #
2986         a2=DataArrayInt.New()
2987         a2.setValues(arr2,5,1)
2988         b=a.selectByTupleId(a2);
2989         self.assertEqual(5,b.getNumberOfTuples());
2990         self.assertEqual(2,b.getNumberOfComponents());
2991         self.assertTrue(b.getInfoOnComponent(0)=="toto");
2992         self.assertTrue(b.getInfoOnComponent(1)=="tata");
2993         expected1=[5,15,3,13,1,11,7,17,6,16]
2994         self.assertEqual(expected1,b.getValues())
2995         pass
2996
2997     def testSwigErrorRenum(self):
2998         da=DataArrayDouble.New()
2999         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
3000         d=DataArrayInt.New()
3001         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
3002         da.renumberInPlace(d)
3003         da.renumber(d)
3004         pass
3005
3006     pass
3007
3008 if __name__ == '__main__':
3009     unittest.main()