src/MEDCoupling_Swig/MEDCouplingBasicsTest2.py

   1 #  -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2016  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 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 testDAHasUniqueValues1(self):
1875         da=DataArrayInt([1,2,3,4,5])
1876         self.assertTrue(da.hasUniqueValues())
1877         da[1,0] = 5
1878         self.assertFalse(da.hasUniqueValues())
1879         da=DataArrayInt([])
1880         self.assertTrue(da.hasUniqueValues())
1881         da=DataArrayInt([(1,2), (2,3)]) # wrong num of compo
1882         self.assertRaises(InterpKernelException, da.hasUniqueValues)
1883         da=DataArrayInt()  # non allocated array
1884         self.assertRaises(InterpKernelException, da.hasUniqueValues)
1885         pass
1886
1887     def testDADFromPolarToCart1(self):
1888         tab1=[2.,0.2,2.5,0.7]
1889         da=DataArrayDouble.New();
1890         da.setValues(tab1,2,2);
1891         da2=da.fromPolarToCart();
1892         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
1893         for i in xrange(4):
1894             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
1895             pass
1896         pass
1897
1898     def testDADFromCylToCart1(self):
1899         tab1=[2.,0.2,4.,2.5,0.7,9.]
1900         da=DataArrayDouble.New();
1901         da.setValues(tab1,2,3);
1902         da2=da.fromCylToCart();
1903         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
1904         for i in xrange(6):
1905             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
1906             pass
1907         pass
1908
1909     def testDADFromSpherToCart1(self):
1910         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
1911         da=DataArrayDouble.New();
1912         da.setValues(tab1,2,3);
1913         da2=da.fromSpherToCart();
1914         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
1915         for i in xrange(6):
1916             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
1917             pass
1918         pass
1919
1920     def testUnPolyze1(self):
1921         elts=[0,1,2,3,4,5,6,7]
1922         eltsV=elts;
1923         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1924         mesh.convertToPolyTypes(eltsV);
1925         mesh.unPolyze();
1926         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
1927         mesh.checkConsistencyLight();
1928         self.assertTrue(mesh.isEqual(mesh2,1e-12));
1929         mesh.convertToPolyTypes(eltsV);
1930         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
1931         mesh.getNodalConnectivity().setIJ(0,6,10);
1932         mesh.getNodalConnectivity().setIJ(0,7,9);
1933         mesh.getNodalConnectivity().setIJ(0,8,12);
1934         mesh.getNodalConnectivity().setIJ(0,9,13);
1935         mesh.unPolyze();
1936         self.assertTrue(mesh.isEqual(mesh2,1e-12));
1937         mesh.convertToPolyTypes(eltsV);
1938         mesh.getNodalConnectivity().setIJ(0,6,12);
1939         mesh.getNodalConnectivity().setIJ(0,7,13);
1940         mesh.getNodalConnectivity().setIJ(0,8,10);
1941         mesh.getNodalConnectivity().setIJ(0,9,9);
1942         mesh.unPolyze();
1943         self.assertTrue(mesh.isEqual(mesh2,1e-12));
1944         mesh.convertToPolyTypes(eltsV);
1945         mesh.getNodalConnectivity().setIJ(0,6,12);
1946         mesh.getNodalConnectivity().setIJ(0,7,10);
1947         mesh.getNodalConnectivity().setIJ(0,8,13);
1948         mesh.getNodalConnectivity().setIJ(0,9,9);
1949         mesh.unPolyze();
1950         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
1951         # Test for 2D mesh
1952         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1953         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
1954         eltsV=eltsV[:5];
1955         mesh.convertToPolyTypes(eltsV);
1956         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
1957         mesh.unPolyze();
1958         self.assertTrue(mesh.isEqual(mesh2,1e-12));
1959         pass
1960
1961     def testConvertDegeneratedCells1(self):
1962         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1963         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]
1964         mesh.allocateCells(4);
1965         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
1966         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
1967         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
1968         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
1969         mesh.finishInsertingCells();
1970         mesh.checkConsistencyLight();
1971         self.assertEqual(4,mesh.getNumberOfCells());
1972         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
1973         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
1974         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
1975         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
1976         f1=mesh.getMeasureField(True);
1977         mesh.convertDegeneratedCells();
1978         mesh.checkConsistencyLight();
1979         f2=mesh.getMeasureField(True);
1980         self.assertEqual(4,mesh.getNumberOfCells());
1981         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
1982         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
1983         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
1984         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
1985         for i in xrange(4):
1986             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
1987             pass
1988         pass
1989
1990     def testGetNodeIdsNearPoints1(self):
1991         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1992         coords=mesh.getCoords();
1993         tmp=DataArrayDouble.New();
1994         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
1995         tmp.setValues(vals,3,2);
1996         tmp2=DataArrayDouble.Aggregate(coords,tmp);
1997         mesh.setCoords(tmp2);
1998         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
1999         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
2000         self.assertEqual([4,9,11],c.getValues());
2001         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
2002         self.assertEqual([0,3,3,4],cI.getValues());
2003         self.assertEqual([4,9,11,6],c.getValues());
2004         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
2005         self.assertEqual([0,3,3,4],cI.getValues());
2006         self.assertEqual([4,9,11,6],c.getValues());
2007         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
2008         self.assertEqual([0,3,3,4],cI.getValues());
2009         self.assertEqual([4,9,11,6],c.getValues());
2010         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
2011         pass
2012
2013     def testFieldCopyTinyAttrFrom1(self):
2014         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2015         f1.setName("f1");
2016         f1.setTimeTolerance(1.e-5);
2017         f1.setDescription("f1Desc");
2018         f1.setTime(1.23,4,5);
2019         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2020         f2.setName("f2");
2021         f2.setDescription("f2Desc");
2022         f2.setTime(6.78,9,10);
2023         f2.setTimeTolerance(4.556e-12);
2024         #
2025         f1.copyTinyAttrFrom(f2);
2026         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2027         t,dt,it=f1.getTime()
2028         self.assertAlmostEqual(6.78,t,12);
2029         self.assertEqual(9,dt);
2030         self.assertEqual(10,it);
2031         self.assertTrue(f1.getName()=="f1");#name unchanged
2032         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2033         #
2034         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2035         f1.setName("f1");
2036         f1.setTimeTolerance(1.e-5);
2037         f1.setDescription("f1Desc");
2038         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2039         f2.setName("f2");
2040         f2.setDescription("f2Desc");
2041         f2.setTimeTolerance(4.556e-12);
2042         #
2043         f1.copyTinyAttrFrom(f2);
2044         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2045         self.assertTrue(f1.getName()=="f1");#name unchanged
2046         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2047         #
2048         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
2049         f1.setName("f1");
2050         f1.setTimeTolerance(1.e-5);
2051         f1.setDescription("f1Desc");
2052         f1.setTime(1.23,4,5);
2053         f1.setEndTime(5.43,2,1);
2054         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
2055         f2.setName("f2");
2056         f2.setDescription("f2Desc");
2057         f2.setTimeTolerance(4.556e-12);
2058         f2.setTime(6.78,9,10);
2059         f2.setEndTime(10.98,7,6);
2060         #
2061         f1.copyTinyAttrFrom(f2);
2062         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2063         self.assertTrue(f1.getName()=="f1");#name unchanged
2064         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2065         t,dt,it=f1.getTime()
2066         self.assertAlmostEqual(6.78,t,12);
2067         self.assertEqual(9,dt);
2068         self.assertEqual(10,it);
2069         t,dt,it=f1.getEndTime()
2070         self.assertAlmostEqual(10.98,t,12);
2071         self.assertEqual(7,dt);
2072         self.assertEqual(6,it);
2073         #
2074         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2075         f1.setName("f1");
2076         f1.setTimeTolerance(1.e-5);
2077         f1.setDescription("f1Desc");
2078         f1.setTime(1.23,4,5);
2079         f1.setEndTime(5.43,2,1);
2080         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2081         f2.setName("f2");
2082         f2.setDescription("f2Desc");
2083         f2.setTimeTolerance(4.556e-12);
2084         f2.setTime(6.78,9,10);
2085         f2.setEndTime(10.98,7,6);
2086         #
2087         f1.copyTinyAttrFrom(f2);
2088         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2089         self.assertTrue(f1.getName()=="f1");#name unchanged
2090         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2091         t,dt,it=f1.getTime()
2092         self.assertAlmostEqual(6.78,t,12);
2093         self.assertEqual(9,dt);
2094         self.assertEqual(10,it);
2095         t,dt,it=f1.getEndTime()
2096         self.assertAlmostEqual(10.98,t,12);
2097         self.assertEqual(7,dt);
2098         self.assertEqual(6,it);
2099         pass
2100
2101     def testExtrudedMesh5(self):
2102         coo1=[0.,1.,2.,3.5]
2103         a=DataArrayDouble.New();
2104         a.setValues(coo1,4,1);
2105         b=MEDCouplingCMesh.New();
2106         b.setCoordsAt(0,a);
2107         c=b.buildUnstructured();
2108         self.assertEqual(1,c.getSpaceDimension());
2109         c.changeSpaceDimension(2);
2110         #
2111         d=DataArrayDouble.New();
2112         d.alloc(13,1);
2113         d.iota();
2114         e=MEDCouplingCMesh.New();
2115         e.setCoordsAt(0,d);
2116         f=e.buildUnstructured();
2117         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
2118         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 !
2119         h=g.fromPolarToCart();
2120         f.setCoords(h);
2121         i=c.buildExtrudedMesh(f,1);
2122         self.assertEqual(52,i.getNumberOfNodes());
2123         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
2124         self.assertTrue(tmp2);
2125         self.assertEqual(37,tmp3);
2126         i.convertDegeneratedCells();
2127         i.checkConsistencyLight();
2128         self.assertEqual(36,i.getNumberOfCells());
2129         self.assertEqual(37,i.getNumberOfNodes());
2130         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
2131         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
2132         expected1=[0.25,0.75,2.0625]
2133         j=i.getMeasureField(True);
2134         for ii in xrange(12):
2135             for k in xrange(3):
2136                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
2137                 pass
2138             pass
2139         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]
2140         m=i.computeCellCenterOfMass();
2141         for i in xrange(72):
2142             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
2143             pass
2144         #
2145         pass
2146
2147     def testExtrudedMesh6(self):
2148         coo1=[0.,1.,2.,3.5]
2149         a=DataArrayDouble.New();
2150         a.setValues(coo1,4,1);
2151         b=MEDCouplingCMesh.New();
2152         b.setCoordsAt(0,a);
2153         c=b.buildUnstructured();
2154         self.assertEqual(1,c.getSpaceDimension());
2155         c.changeSpaceDimension(2);
2156         #
2157         d=DataArrayDouble.New();
2158         d.alloc(5);
2159         d.iota();
2160         e=MEDCouplingCMesh.New();
2161         e.setCoordsAt(0,d);
2162         f=e.buildUnstructured();
2163         d2=f.getCoords().applyFunc("x*x/2");
2164         f.setCoords(d2);
2165         f.changeSpaceDimension(2);
2166         #
2167         center=[0.,0.]
2168         f.rotate(center,None,pi/3);
2169         g=c.buildExtrudedMesh(f,0);
2170         g.checkConsistencyLight();
2171         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 ]
2172         f1=g.getMeasureField(True);
2173         for i in xrange(12):
2174             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
2175             pass
2176         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]
2177         f2=g.computeCellCenterOfMass();
2178         for i in xrange(24):
2179             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
2180             pass
2181         pass
2182
2183     def testExtrudedMesh7(self):
2184         coo1=[0.,1.,2.,3.5]
2185         a=DataArrayDouble.New();
2186         a.setValues(coo1,4,1);
2187         b=MEDCouplingCMesh.New();
2188         b.setCoordsAt(0,a);
2189         c=b.buildUnstructured();
2190         self.assertEqual(1,c.getSpaceDimension());
2191         c.changeSpaceDimension(2);
2192         #
2193         d=DataArrayDouble.New();
2194         d.alloc(13,1);
2195         d.iota();
2196         e=MEDCouplingCMesh.New();
2197         e.setCoordsAt(0,d);
2198         f=e.buildUnstructured();
2199         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
2200         h=g.fromPolarToCart();
2201         f.setCoords(h);
2202         i=c.buildExtrudedMesh(f,1);
2203         self.assertEqual(52,i.getNumberOfNodes());
2204         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
2205         self.assertTrue(tmp2);
2206         self.assertEqual(37,tmp3);
2207         i.convertDegeneratedCells();
2208         vec1=[10.,0]
2209         i.translate(vec1);
2210         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
2211         f.setCoords(g2);
2212         i.changeSpaceDimension(3);
2213         i3=i.buildExtrudedMesh(f,1);
2214         f2=i3.getMeasureField(True);
2215         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
2216         self.assertTrue(tmp2);
2217         self.assertEqual(444,tmp3);
2218         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]
2219         for ii in xrange(12):
2220             for jj in xrange(36):
2221                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
2222                 pass
2223         #
2224         pass
2225
2226     def testSimplexize1(self):
2227         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2228         m.convertToPolyTypes([3]);
2229         da=m.simplexize(0);
2230         self.assertEqual(7,da.getNumberOfTuples());
2231         self.assertEqual(1,da.getNumberOfComponents());
2232         expected2=[0,0,1,2,3,4,4]
2233         for i in xrange(7):
2234             self.assertEqual(expected2[i],da.getIJ(i,0));
2235             pass
2236         m.checkConsistencyLight();
2237         self.assertEqual(7,m.getNumberOfCells());
2238         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
2239         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2240         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
2241         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2242         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
2243         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
2244         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
2245         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
2246         f=m.getMeasureField(False);
2247         for i in xrange(7):
2248             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
2249             pass
2250         types=m.getAllGeoTypes();
2251         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
2252         #
2253         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2254         m.convertToPolyTypes([3]);
2255         da=m.simplexize(1);
2256         self.assertEqual(7,da.getNumberOfTuples());
2257         self.assertEqual(1,da.getNumberOfComponents());
2258         for i in xrange(7):
2259             self.assertEqual(expected2[i],da.getIJ(i,0));
2260             pass
2261         m.checkConsistencyLight();
2262         types=m.getAllGeoTypes();
2263         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
2264         self.assertEqual(7,m.getNumberOfCells());
2265         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
2266         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2267         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
2268         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2269         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
2270         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
2271         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
2272         f=m.getMeasureField(False);
2273         for i in xrange(7):
2274             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
2275             pass
2276         pass
2277
2278     def testSimplexize2(self):
2279         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2280         m.convertToPolyTypes([3]);
2281         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2282         f1.setMesh(m);
2283         arr=DataArrayDouble.New();
2284         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
2285         arr.setValues(arr1,5,2);
2286         f1.setArray(arr);
2287         #
2288         f1.checkConsistencyLight();
2289         self.assertTrue(f1.simplexize(0));
2290         f1.checkConsistencyLight();
2291         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
2292         for i in xrange(14):
2293             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
2294             pass
2295         self.assertTrue(not f1.simplexize(0));
2296         for i in xrange(14):
2297             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
2298             pass
2299         #
2300         pass
2301
2302     def testDAMeld1(self):
2303         da1=DataArrayDouble.New();
2304         da1.alloc(7,2);
2305         da2=DataArrayDouble.New();
2306         da2.alloc(7,1);
2307         #
2308         da1.fillWithValue(7.);
2309         da2.iota(0.);
2310         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
2311         #
2312         da1.setInfoOnComponent(0,"c0da1");
2313         da1.setInfoOnComponent(1,"c1da1");
2314         da3.setInfoOnComponent(0,"c0da3");
2315         da3.setInfoOnComponent(1,"c1da3");
2316         da3.setInfoOnComponent(2,"c2da3");
2317         #
2318         da1C=da1.deepCopy();
2319         da1.meldWith(da3);
2320         self.assertEqual(5,da1.getNumberOfComponents());
2321         self.assertEqual(7,da1.getNumberOfTuples());
2322         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
2323         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
2324         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
2325         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
2326         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
2327         #
2328         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.]
2329         for i in xrange(35):
2330             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
2331             pass
2332         #
2333         dai1=da1C.convertToIntArr();
2334         dai3=da3.convertToIntArr();
2335         dai1.meldWith(dai3);
2336         self.assertEqual(5,dai1.getNumberOfComponents());
2337         self.assertEqual(7,dai1.getNumberOfTuples());
2338         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
2339         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
2340         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
2341         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
2342         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
2343         for i in xrange(35):
2344             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
2345             pass
2346         # test of static method DataArrayDouble::meld
2347         da4=DataArrayDouble.Meld(da1C,da3);
2348         tmp=DataArrayDouble.Meld([da1C,da3]);
2349         self.assertTrue(da4.isEqual(tmp,1e-10))
2350         self.assertEqual(5,da4.getNumberOfComponents());
2351         self.assertEqual(7,da4.getNumberOfTuples());
2352         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
2353         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
2354         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
2355         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
2356         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
2357         for i in xrange(35):
2358             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
2359             pass
2360         # test of static method DataArrayInt::meld
2361         dai1=da1C.convertToIntArr();
2362         dai4=DataArrayInt.Meld(dai1,dai3);
2363         tmp=DataArrayInt.Meld([dai1,dai3]);
2364         self.assertTrue(dai4.isEqual(tmp))
2365         self.assertEqual(5,dai4.getNumberOfComponents());
2366         self.assertEqual(7,dai4.getNumberOfTuples());
2367         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
2368         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
2369         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
2370         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
2371         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
2372         for i in xrange(35):
2373             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
2374             pass
2375         pass
2376
2377     def testFieldMeld1(self):
2378         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2379         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2380         f1.setMesh(m);
2381         da1=DataArrayDouble.New();
2382         arr1=[12.,23.,34.,45.,56.]
2383         da1.setValues(arr1,5,1);
2384         da1.setInfoOnComponent(0,"aaa");
2385         f1.setArray(da1);
2386         f1.setTime(3.4,2,1);
2387         f1.checkConsistencyLight();
2388         #
2389         f2=f1.deepCopy();
2390         f2.setMesh(f1.getMesh());
2391         f2.checkConsistencyLight();
2392         f2.changeNbOfComponents(2,5.);
2393         f2.assign(5.);
2394         f2.getArray().setInfoOnComponent(0,"bbb");
2395         f2.getArray().setInfoOnComponent(1,"ccc");
2396         f2.checkConsistencyLight();
2397         #
2398         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
2399         f3.checkConsistencyLight();
2400         self.assertEqual(5,f3.getNumberOfTuples());
2401         self.assertEqual(3,f3.getNumberOfComponents());
2402         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
2403         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
2404         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
2405         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
2406         for i in xrange(15):
2407             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
2408             pass
2409         time,dt,it=f3.getTime();
2410         self.assertAlmostEqual(3.4,time,14);
2411         self.assertEqual(2,dt);
2412         self.assertEqual(1,it);
2413         #
2414         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
2415         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
2416         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
2417         f6.checkConsistencyLight();
2418         self.assertEqual(5,f6.getNumberOfTuples());
2419         self.assertEqual(3,f6.getNumberOfComponents());
2420         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
2421         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
2422         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
2423         for i in xrange(15):
2424             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
2425             pass
2426         #
2427         pass
2428
2429     def testMergeNodes2(self):
2430         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2431         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2432         vec=[0.002,0.]
2433         m2.translate(vec);
2434         #
2435         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
2436         da,b,newNbOfNodes=m3.mergeNodesCenter(0.01);
2437         self.assertEqual(9,m3.getNumberOfNodes());
2438         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]
2439         for i in xrange(18):
2440             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
2441             pass
2442         #
2443         pass
2444
2445     def testMergeField2(self):
2446         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2447         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2448         f1.setMesh(m);
2449         arr=DataArrayDouble.New();
2450         arr.alloc(5,2);
2451         arr.fillWithValue(2.);
2452         f1.setArray(arr);
2453         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2454         f2.setMesh(m);
2455         arr=DataArrayDouble.New();
2456         arr.alloc(5,2);
2457         arr.fillWithValue(5.);
2458         f2.setArray(arr);
2459         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2460         f3.setMesh(m);
2461         arr=DataArrayDouble.New();
2462         arr.alloc(5,2);
2463         arr.fillWithValue(7.);
2464         f3.setArray(arr);
2465         #
2466         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
2467         self.assertEqual(15,f4.getMesh().getNumberOfCells());
2468         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.]
2469         for i in xrange(30):
2470             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
2471             pass
2472         #
2473         pass
2474
2475     def testDAIBuildComplement1(self):
2476         a=DataArrayInt.New();
2477         tab=[3,1,7,8]
2478         a.setValues(tab,4,1);
2479         b=a.buildComplement(12);
2480         self.assertEqual(8,b.getNumberOfTuples());
2481         self.assertEqual(1,b.getNumberOfComponents());
2482         expected1=[0,2,4,5,6,9,10,11]
2483         for i in xrange(8):
2484             self.assertEqual(expected1[i],b.getIJ(0,i));
2485             pass
2486         pass
2487
2488     def testDAIBuildUnion1(self):
2489         a=DataArrayInt.New();
2490         tab1=[3,1,7,8]
2491         a.setValues(tab1,4,1);
2492         c=DataArrayInt.New();
2493         tab2=[5,3,0,18,8]
2494         c.setValues(tab2,5,1);
2495         b=a.buildUnion(c);
2496         self.assertEqual(7,b.getNumberOfTuples());
2497         self.assertEqual(1,b.getNumberOfComponents());
2498         expected1=[0,1,3,5,7,8,18]
2499         for i in xrange(7):
2500             self.assertEqual(expected1[i],b.getIJ(0,i));
2501             pass
2502         b=DataArrayInt.BuildUnion([a,c]);
2503         self.assertEqual(7,b.getNumberOfTuples());
2504         self.assertEqual(1,b.getNumberOfComponents());
2505         expected1=[0,1,3,5,7,8,18]
2506         for i in xrange(7):
2507             self.assertEqual(expected1[i],b.getIJ(0,i));
2508             pass
2509         pass
2510
2511     def testDAIBuildIntersection1(self):
2512         a=DataArrayInt.New();
2513         tab1=[3,1,7,8]
2514         a.setValues(tab1,4,1);
2515         c=DataArrayInt.New();
2516         tab2=[5,3,0,18,8]
2517         c.setValues(tab2,5,1);
2518         b=a.buildIntersection(c);
2519         self.assertEqual(2,b.getNumberOfTuples());
2520         self.assertEqual(1,b.getNumberOfComponents());
2521         expected1=[3,8]
2522         for i in xrange(2):
2523             self.assertEqual(expected1[i],b.getIJ(0,i));
2524             pass
2525         b=DataArrayInt.BuildIntersection([a,c]);
2526         self.assertEqual(2,b.getNumberOfTuples());
2527         self.assertEqual(1,b.getNumberOfComponents());
2528         expected1=[3,8]
2529         for i in xrange(2):
2530             self.assertEqual(expected1[i],b.getIJ(0,i));
2531             pass
2532         pass
2533
2534     def testDAIDeltaShiftIndex1(self):
2535         a=DataArrayInt.New();
2536         tab=[1,3,6,7,7,9,15]
2537         a.setValues(tab,7,1);
2538         b=a.deltaShiftIndex();
2539         self.assertEqual(6,b.getNumberOfTuples());
2540         self.assertEqual(1,b.getNumberOfComponents());
2541         expected1=[2,3,1,0,2,6]
2542         for i in xrange(6):
2543             self.assertEqual(expected1[i],b.getIJ(0,i));
2544             pass
2545         pass
2546
2547     def testDaDoubleSelectByTupleIdSafe1(self):
2548         a=DataArrayDouble.New();
2549         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]
2550         a.setValues(arr1,7,2);
2551         a.setInfoOnComponent(0,"toto");
2552         a.setInfoOnComponent(1,"tata");
2553         #
2554         arr2=[4,2,0,6,5]
2555         b=a.selectByTupleIdSafe(arr2);
2556         self.assertEqual(5,b.getNumberOfTuples());
2557         self.assertEqual(2,b.getNumberOfComponents());
2558         self.assertTrue(b.getInfoOnComponent(0)=="toto");
2559         self.assertTrue(b.getInfoOnComponent(1)=="tata");
2560         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
2561         for i in xrange(10):
2562             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
2563             pass
2564         arr4=[4,-1,0,6,5]
2565         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
2566         arr5=[4,2,0,6,7]
2567         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
2568         #
2569         c=DataArrayInt.New();
2570         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
2571         c.setValues(arr3,7,2);
2572         c.setInfoOnComponent(0,"toto");
2573         c.setInfoOnComponent(1,"tata");
2574         d=c.selectByTupleIdSafe(arr2);
2575         self.assertEqual(5,d.getNumberOfTuples());
2576         self.assertEqual(2,d.getNumberOfComponents());
2577         self.assertTrue(d.getInfoOnComponent(0)=="toto");
2578         self.assertTrue(d.getInfoOnComponent(1)=="tata");
2579         expected2=[5,15,3,13,1,11,7,17,6,16]
2580         for i in xrange(10):
2581             self.assertEqual(expected2[i],d.getIJ(0,i));
2582             pass
2583         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
2584         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
2585         pass
2586
2587     def testAreCellsIncludedIn1(self):
2588         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2589         pt=[1,3]
2590         m2=m.buildPartOfMySelf(pt,True);
2591         ret,tmp=m.areCellsIncludedIn(m2,0)
2592         self.assertTrue(ret);
2593         self.assertEqual(2,tmp.getNumberOfTuples());
2594         self.assertEqual(1,tmp.getNumberOfComponents());
2595         self.assertEqual(pt[0],tmp.getIJ(0,0));
2596         self.assertEqual(pt[1],tmp.getIJ(0,1));
2597         ret,tmp=m2.areCellsIncludedIn(m,0)
2598         self.assertTrue(not ret);
2599         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
2600         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
2601         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
2602         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
2603         pass
2604
2605     def testSwigErrorProtection1(self):
2606         m=MEDCouplingDataForTest.build3DTargetMesh_1();
2607         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
2608         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
2609         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
2610         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
2611         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
2612         m2=m.buildPartOfMySelf([2,5],True)
2613         m3=m.buildPartOfMySelf((2,5),True)
2614         self.assertTrue(m2.isEqual(m3,1e-12))
2615         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
2616         da1=m.getCoords().keepSelectedComponents([1])
2617         da2=m.getCoords().keepSelectedComponents((1,))
2618         self.assertTrue(da1.isEqual(da2,1e-12))
2619         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
2620         pass
2621
2622     def testDAIBuildSubstraction1(self):
2623         a=DataArrayInt.New()
2624         aa=[2,3,6,8,9]
2625         a.setValues(aa,5,1)
2626         b=DataArrayInt.New()
2627         bb=[1,3,5,9,11]
2628         b.setValues(bb,5,1)
2629         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
2630         pass
2631
2632     def testBuildOrthogonalField2(self):
2633         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2634         d1=DataArrayInt.New();
2635         d2=DataArrayInt.New();
2636         d3=DataArrayInt.New();
2637         d4=DataArrayInt.New();
2638         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
2639         #
2640         f1=m1.buildOrthogonalField();
2641         da1=f1.getArray();
2642         self.assertEqual(2,da1.getNumberOfComponents());
2643         self.assertEqual(13,da1.getNumberOfTuples());
2644         #
2645         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.];
2646         for i in xrange(26):
2647             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
2648             pass
2649         pass
2650
2651     def testSwigErrorProtection2(self):
2652         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2653         coo=m.getCoords()
2654         c=m.getNodalConnectivity()
2655         ci=m.getNodalConnectivityIndex()
2656         del m
2657         self.assertEqual(2,coo.getNumberOfComponents());
2658         self.assertEqual(6,ci.getNumberOfTuples());
2659         self.assertEqual(23,c.getNumberOfTuples());
2660         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2661         f=m.getMeasureField(True)
2662         c=f.getArray()
2663         del f
2664         self.assertEqual(1,c.getNumberOfComponents());
2665         m=MEDCouplingCMesh.New()
2666         x=DataArrayDouble.New()
2667         x.setValues([1.,2.,4.],3,1)
2668         m.setCoordsAt(0,x)
2669         del x
2670         xx=m.getCoordsAt(0)
2671         del m
2672         self.assertEqual(3,xx.getNumberOfTuples());
2673         #
2674         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2675         f=m.getMeasureField(True)
2676         m2=f.getMesh()
2677         del m
2678         del f
2679         self.assertEqual(5,m2.getNumberOfCells());
2680         pass
2681
2682     def testUMInsertNextCell1(self):
2683         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 ]
2684         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
2685         targetMesh=MEDCouplingUMesh.New();
2686         targetMesh.allocateCells(5);
2687         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
2688         targetMesh.setMeshDimension(2);
2689         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
2690         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
2691         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
2692         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
2693         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
2694         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
2695         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
2696         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
2697         targetMesh.finishInsertingCells();
2698         myCoords=DataArrayDouble.New();
2699         myCoords.setValues(targetCoords,9,2);
2700         targetMesh.setCoords(myCoords);
2701         targetMesh.checkConsistencyLight();
2702         pass
2703
2704     def testFieldOperatorDivDiffComp1(self):
2705         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2706         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
2707         #
2708         f1=m1.buildOrthogonalField();
2709         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
2710         arr=DataArrayDouble.New();
2711         arr.setValues(arr1,13,1);
2712         f2=MEDCouplingFieldDouble.New(ON_CELLS);
2713         f2.setArray(arr);
2714         f2.setMesh(m1);
2715         f2.checkConsistencyLight();
2716         #
2717         f3=f1/f2;
2718         self.assertRaises(InterpKernelException,f2.__div__,f1)
2719         f3.checkConsistencyLight();
2720         f1/=f2;
2721         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
2722         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
2723         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]
2724         for i in xrange(26):
2725             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
2726             pass
2727         pass
2728
2729     def testDARearrange1(self):
2730         da1=DataArrayInt.New();
2731         da1.alloc(12,1);
2732         da1.iota(0);
2733         #
2734         self.assertEqual(12,da1.getNbOfElems());
2735         self.assertEqual(1,da1.getNumberOfComponents());
2736         self.assertEqual(12,da1.getNumberOfTuples());
2737         da1.rearrange(4);
2738         self.assertEqual(12,da1.getNbOfElems());
2739         self.assertEqual(4,da1.getNumberOfComponents());
2740         self.assertEqual(3,da1.getNumberOfTuples());
2741         for i in xrange(12):
2742             self.assertEqual(i,da1.getIJ(0,i));
2743         #
2744         da1.rearrange(6);
2745         self.assertEqual(12,da1.getNbOfElems());
2746         self.assertEqual(6,da1.getNumberOfComponents());
2747         self.assertEqual(2,da1.getNumberOfTuples());
2748         for i in xrange(12):
2749             self.assertEqual(i,da1.getIJ(0,i));
2750         #
2751         self.assertRaises(InterpKernelException,da1.rearrange,7);
2752         #
2753         da1.rearrange(12);
2754         self.assertEqual(12,da1.getNbOfElems());
2755         self.assertEqual(12,da1.getNumberOfComponents());
2756         self.assertEqual(1,da1.getNumberOfTuples());
2757         for i in xrange(12):
2758             self.assertEqual(i,da1.getIJ(0,i));
2759         #
2760         da1.rearrange(3);
2761         self.assertEqual(12,da1.getNbOfElems());
2762         self.assertEqual(3,da1.getNumberOfComponents());
2763         self.assertEqual(4,da1.getNumberOfTuples());
2764         for i in xrange(12):
2765             self.assertEqual(i,da1.getIJ(0,i));
2766         #double
2767         da2=da1.convertToDblArr();
2768         st=da2.getHiddenCppPointer()
2769         #
2770         self.assertEqual(12,da2.getNbOfElems());
2771         self.assertEqual(3,da2.getNumberOfComponents());
2772         self.assertEqual(4,da2.getNumberOfTuples());
2773         da2.rearrange(4);
2774         self.assertEqual(12,da2.getNbOfElems());
2775         self.assertEqual(4,da2.getNumberOfComponents());
2776         self.assertEqual(3,da2.getNumberOfTuples());
2777         for i in xrange(12):
2778             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2779         #
2780         da2.rearrange(6);
2781         self.assertEqual(12,da2.getNbOfElems());
2782         self.assertEqual(6,da2.getNumberOfComponents());
2783         self.assertEqual(2,da2.getNumberOfTuples());
2784         for i in xrange(12):
2785             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2786         #
2787         self.assertRaises(InterpKernelException,da2.rearrange,7);
2788         #
2789         da2.rearrange(1);
2790         self.assertEqual(st,da2.getHiddenCppPointer())
2791         self.assertEqual(12,da2.getNbOfElems());
2792         self.assertEqual(1,da2.getNumberOfComponents());
2793         self.assertEqual(12,da2.getNumberOfTuples());
2794         for i in xrange(12):
2795             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2796         #
2797         da2.rearrange(3);
2798         self.assertEqual(12,da2.getNbOfElems());
2799         self.assertEqual(3,da2.getNumberOfComponents());
2800         self.assertEqual(4,da2.getNumberOfTuples());
2801         for i in xrange(12):
2802             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2803         pass
2804
2805     def testDARearrange2(self):
2806         da1=DataArrayInt.New();
2807         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
2808         da1.setValues(arr,4,3);
2809         s=da1.getDifferentValues();
2810         expected1=DataArrayInt([1,2,3,5])
2811         self.assertTrue(expected1.isEqual(s));
2812         pass
2813
2814     def testSwigErrorProtection3(self):
2815         da=DataArrayInt.New()
2816         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
2817         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
2818         self.assertEqual(3,da.getNumberOfComponents());
2819         self.assertEqual(4,da.getNumberOfTuples());
2820         da=DataArrayInt.New()
2821         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
2822         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
2823         self.assertEqual(3,da.getNumberOfComponents());
2824         self.assertEqual(4,da.getNumberOfTuples());
2825         da.setValues((10*[1]+290*[2])[:12],4,3)
2826         self.assertEqual(10*[1]+[2,2],da.getValues())
2827         self.assertEqual(3,da.getNumberOfComponents());
2828         self.assertEqual(4,da.getNumberOfTuples());
2829         #
2830         da=DataArrayDouble.New()
2831         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
2832         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
2833         self.assertEqual(3,da.getNumberOfComponents());
2834         self.assertEqual(4,da.getNumberOfTuples());
2835         da=DataArrayDouble.New()
2836         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
2837         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
2838         self.assertEqual(3,da.getNumberOfComponents());
2839         self.assertEqual(4,da.getNumberOfTuples());
2840         da.setValues((10*[1]+290*[2])[:12],4,3)
2841         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
2842         self.assertEqual(3,da.getNumberOfComponents());
2843         self.assertEqual(4,da.getNumberOfTuples());
2844         pass
2845
2846     def testDAIBuildPermutationArr1(self):
2847         a=DataArrayInt.New()
2848         a.setValues([4,5,6,7,8],5,1)
2849         b=DataArrayInt.New()
2850         b.setValues([5,4,8,6,7],5,1)
2851         c=a.buildPermutationArr(b)
2852         self.assertEqual([1,0,4,2,3],c.getValues())
2853         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
2854         b.setIJ(0,0,9)
2855         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
2856         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
2857         a.setIJ(3,0,4)
2858         b.setIJ(0,0,5)
2859         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
2860         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
2861         c=a.buildPermutationArr(b)
2862         self.assertEqual([1,3,4,2,3],c.getValues())
2863         d=b.convertToDblArr()
2864         expect3=[4,4,5,6,8]
2865         b.sort()
2866         self.assertEqual(expect3,b.getValues())
2867         d.sort()
2868         self.assertEqual(5,d.getNumberOfTuples());
2869         self.assertEqual(1,d.getNumberOfComponents());
2870         for i in xrange(5):
2871             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
2872             pass
2873         pass
2874
2875     def testAreCellsIncludedIn2(self):
2876         myName="Vitoo";
2877         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2878         m2=m.buildPartOfMySelf([],True);
2879         self.assertEqual(0,m2.getNumberOfCells());
2880         self.assertEqual(3,m2.getSpaceDimension());
2881         self.assertEqual(2,m2.getMeshDimension());
2882         m2.setName(myName);
2883         test,tmp=m.areCellsIncludedIn(m2,0)
2884         self.assertTrue(test);
2885         self.assertEqual(myName,tmp.getName());
2886         self.assertEqual(0,tmp.getNumberOfTuples())
2887         self.assertEqual(1,tmp.getNumberOfComponents())
2888         pass
2889
2890     def testUMeshGetPartBarycenterAndOwner1(self):
2891         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2892         part1=[1,0,4];
2893         part=DataArrayInt.New();
2894         part.setValues(part1,3,1);
2895         b=m1.getPartBarycenterAndOwner(part);
2896         self.assertEqual(2,b.getNumberOfComponents());
2897         self.assertEqual(3,b.getNumberOfTuples());
2898         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
2899         for i in xrange(6):
2900             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
2901             pass
2902         pass
2903
2904     def testUMeshGetPartMeasureField1(self):
2905         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2906         part1=[1,0,4];
2907         part=DataArrayInt.New();
2908         part.setValues(part1,3,1);
2909         b=m1.getPartMeasureField(True,part);
2910         self.assertEqual(1,b.getNumberOfComponents());
2911         self.assertEqual(3,b.getNumberOfTuples());
2912         expected1=[0.125,0.25,0.25];
2913         for i in xrange(3):
2914             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
2915             pass
2916         pass
2917
2918     def testUMeshBuildPartOrthogonalField1(self):
2919         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2920         m1.changeSpaceDimension(3);
2921         part1=[1,0,4];
2922         part=DataArrayInt.New();
2923         part.setValues(part1,3,1);
2924         b=m1.buildPartOrthogonalField(part);
2925         self.assertEqual(3,b.getArray().getNumberOfComponents());
2926         self.assertEqual(3,b.getArray().getNumberOfTuples());
2927         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
2928         for i in xrange(9):
2929             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
2930             pass
2931         pass
2932
2933     def testUMeshGetTypesOfPart1(self):
2934         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2935         part1=[0,3,4];
2936         p1=DataArrayInt.New()
2937         p1.setValues(part1,3,1)
2938         s=m1.getTypesOfPart(p1);
2939         self.assertEqual([NORM_QUAD4],s);
2940         part2=[2,2,2,1];
2941         p2=DataArrayInt.New()
2942         p2.setValues(part2,4,1)
2943         s=m1.getTypesOfPart(p2);
2944         self.assertEqual([NORM_TRI3],s);
2945         part3=[3,2,1];
2946         p3=DataArrayInt.New()
2947         p3.setValues(part3,3,1)
2948         s=m1.getTypesOfPart(p3);
2949         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
2950         pass
2951
2952     def testUMeshKeepCellIdsByType1(self):
2953         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2954         part1=[0,3,4]
2955         p1=DataArrayInt.New()
2956         p1.setValues(part1,3,1)
2957         p1.setName("p1")
2958         a=m1.keepCellIdsByType(NORM_TRI3,p1);
2959         self.assertEqual("p1",a.getName())
2960         self.assertEqual(1,a.getNumberOfComponents());
2961         self.assertEqual(0,a.getNumberOfTuples());
2962         #
2963         part2=[3,2,0,2,4]
2964         p2=DataArrayInt.New()
2965         p2.setValues(part2,5,1)
2966         p2.setName("p2")
2967         a=m1.keepCellIdsByType(NORM_TRI3,p2);
2968         self.assertEqual("p2",a.getName())
2969         self.assertEqual(1,a.getNumberOfComponents());
2970         self.assertEqual(2,a.getNumberOfTuples());
2971         self.assertEqual(2,a.getIJ(0,0));
2972         self.assertEqual(2,a.getIJ(1,0));
2973         #
2974         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
2975         self.assertEqual("p2",a.getName())
2976         self.assertEqual(1,a.getNumberOfComponents());
2977         self.assertEqual(3,a.getNumberOfTuples());
2978         self.assertEqual(3,a.getIJ(0,0));
2979         self.assertEqual(0,a.getIJ(1,0));
2980         self.assertEqual(4,a.getIJ(2,0));
2981         pass
2982
2983     def testSwigErrorDaIntSelectByTupleId1(self):
2984         a=DataArrayInt.New();
2985         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
2986         a.setValues(arr1,7,2);
2987         a.setInfoOnComponent(0,"toto");
2988         a.setInfoOnComponent(1,"tata");
2989         #
2990         arr2=[4,2,0,6,5]
2991         b=a.selectByTupleId(arr2);
2992         self.assertEqual(5,b.getNumberOfTuples());
2993         self.assertEqual(2,b.getNumberOfComponents());
2994         self.assertTrue(b.getInfoOnComponent(0)=="toto");
2995         self.assertTrue(b.getInfoOnComponent(1)=="tata");
2996         expected1=[5,15,3,13,1,11,7,17,6,16]
2997         self.assertEqual(expected1,b.getValues())
2998         #
2999         a2=DataArrayInt.New()
3000         a2.setValues(arr2,5,1)
3001         b=a.selectByTupleId(a2);
3002         self.assertEqual(5,b.getNumberOfTuples());
3003         self.assertEqual(2,b.getNumberOfComponents());
3004         self.assertTrue(b.getInfoOnComponent(0)=="toto");
3005         self.assertTrue(b.getInfoOnComponent(1)=="tata");
3006         expected1=[5,15,3,13,1,11,7,17,6,16]
3007         self.assertEqual(expected1,b.getValues())
3008         pass
3009
3010     def testSwigErrorRenum(self):
3011         da=DataArrayDouble.New()
3012         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
3013         d=DataArrayInt.New()
3014         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
3015         da.renumberInPlace(d)
3016         da.renumber(d)
3017         pass
3018
3019     pass
3020
3021 if __name__ == '__main__':
3022     unittest.main()