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 range(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 range(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 range(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 range(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 range(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.assertEqual(5,da.getNbOfElems());
 106         expected1=[2,3,5,7,9]
 107         self.assertEqual(expected1,list(da.getValues()));
 108         da=f1.findIdsInRange(8.,12.);
 109         self.assertEqual(4,da.getNbOfElems());
 110         expected2=[1,4,6,8]
 111         self.assertEqual(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.assertEqual(3,f2.getNumberOfTuples());
 129         self.assertEqual(2,f2.getNumberOfComponents());
 130         expected1=[5.,105.,4.,104.,7.,107.]
 131         for i in range(6):
 132             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
 133             pass
 134         self.assertEqual(3,f2.getMesh().getNumberOfCells());
 135         self.assertEqual(6,f2.getMesh().getNumberOfNodes());
 136         self.assertEqual(2,f2.getMesh().getSpaceDimension());
 137         self.assertEqual(2,f2.getMesh().getMeshDimension());
 138         m2C=f2.getMesh();
 139         self.assertEqual(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 range(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.assertEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
 146         expected4=[0,4,8,13]
 147         self.assertEqual(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.assertEqual(4,f2.getNumberOfTuples());
 159         self.assertEqual(2,f2.getNumberOfComponents());
 160         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
 161         for i in range(8):
 162             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
 163             pass
 164         self.assertEqual(2,f2.getMesh().getNumberOfCells());
 165         self.assertEqual(4,f2.getMesh().getNumberOfNodes());
 166         self.assertEqual(2,f2.getMesh().getSpaceDimension());
 167         self.assertEqual(2,f2.getMesh().getMeshDimension());
 168         m2C=f2.getMesh();
 169         self.assertEqual(8,m2C.getNodalConnectivityArrayLen());
 170         for i in range(8):  # 8 is not an error
 171             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
 172             pass
 173         self.assertEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
 174         self.assertEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
 175         self.assertEqual(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.assertEqual(4,f2.getNumberOfTuples());
 182         self.assertEqual(2,f2.getNumberOfComponents());
 183         for i in range(8):
 184             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
 185             pass
 186         self.assertEqual(2,f2.getMesh().getNumberOfCells());
 187         self.assertEqual(4,f2.getMesh().getNumberOfNodes());
 188         self.assertEqual(2,f2.getMesh().getSpaceDimension());
 189         self.assertEqual(2,f2.getMesh().getMeshDimension());
 190         m2C=f2.getMesh();
 191         self.assertEqual(8,m2C.getNodalConnectivityArrayLen());
 192         for i in range(8):  # 8 is not an error
 193             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
 194             pass
 195         self.assertEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
 196         self.assertEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
 197         self.assertEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
 198         #
 199         part4=[1,2,4]
 200         f2=f1.buildSubPart(part4);
 201         self.assertEqual(6,f2.getNumberOfTuples());
 202         self.assertEqual(2,f2.getNumberOfComponents());
 203         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
 204         for i in range(12):
 205             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
 206             pass
 207         self.assertEqual(3,f2.getMesh().getNumberOfCells());
 208         self.assertEqual(6,f2.getMesh().getNumberOfNodes());
 209         self.assertEqual(2,f2.getMesh().getSpaceDimension());
 210         self.assertEqual(2,f2.getMesh().getMeshDimension());
 211         m2C=f2.getMesh();
 212         self.assertEqual(13,m2C.getNodalConnectivityArrayLen());
 213         for i in range(12):
 214             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
 215             pass
 216         self.assertEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
 217         self.assertEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
 218         self.assertEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
 219         self.assertEqual(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(6):
1443             self.assertEqual(expected1[i],da2.getIJ(i,0));
1444             pass
1445         da3=da2.invertArrayN2O2O2N(6);
1446         for i in range(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 range(6):
1458             self.assertEqual(expected2[i],da2.getIJ(i,0));
1459             pass
1460         da3=da2.invertArrayN2O2O2N(10);
1461         for i in range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(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 range(4):
1986             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
1987             pass
1988         pass
1989
1990     def testConvertDegeneratedCellsAndRemoveFlatOnes1(self):
1991           coo = DataArrayDouble([0.0]*10) # Just to have some. Values do not matter.
1992           mesh = MEDCouplingUMesh("m", 2)
1993           mesh.setCoords(coo)
1994
1995           # Linear
1996           c = [NORM_QUAD4, 0,1,0,2, NORM_TRI3, 0,1,1, NORM_TRI3, 0,1,2, NORM_QUAD4, 1,0,2,1, NORM_POLYGON, 1,0,1,1]
1997           cI = [0, 5, 9, 13, 18, 23]
1998           mesh.setConnectivity(DataArrayInt(c),DataArrayInt(cI))
1999           mesh2 = mesh.deepCopy(); mesh3 = mesh.deepCopy();
2000           mesh.convertDegeneratedCells()
2001           c, cI = mesh.getNodalConnectivity().getValues(), mesh.getNodalConnectivityIndex().getValues()
2002           self.assertEqual(c, [NORM_QUAD4, 0,1,0,2, NORM_POLYGON, 0,1, NORM_TRI3, 0,1,2, NORM_TRI3, 1,0,2, NORM_POLYGON, 1,0])
2003           self.assertEqual(cI, [0, 5, 8, 12, 16, 19])
2004
2005           res = mesh2.convertDegeneratedCellsAndRemoveFlatOnes()
2006           c, cI = mesh2.getNodalConnectivity().getValues(), mesh2.getNodalConnectivityIndex().getValues()
2007           self.assertEqual(c, [NORM_QUAD4, 0,1,0,2, NORM_TRI3, 0,1,2, NORM_TRI3, 1,0,2])
2008           self.assertEqual(cI, [0, 5, 9, 13])
2009           self.assertEqual(res.getValues(), [1,4])
2010
2011           # Quadratics now:
2012           c = [NORM_TRI6, 0,1,0, 2,3,0, NORM_QUAD8, 0,1,1,3,  4,1,6,7, NORM_QPOLYG, 0,1, NORM_QPOLYG, 0,1,2,2, NORM_TRI6, 0,1,2,  3,4,5]
2013           cI = [0, 7, 16, 19, 24, 31]
2014           mesh3.setConnectivity(DataArrayInt(c),DataArrayInt(cI))
2015
2016           mesh3.convertDegeneratedCells()
2017           c, cI = mesh3.getNodalConnectivity().getValues(), mesh3.getNodalConnectivityIndex().getValues()
2018           self.assertEqual(c, [NORM_QPOLYG, 0,1, 2,3, NORM_TRI6, 0,1,3,  4,6,7, NORM_QPOLYG, 0,1, NORM_QPOLYG, 0,1,2,2, NORM_TRI6, 0,1,2,  3,4,5])
2019           self.assertEqual(cI, [0, 5, 12, 15, 20, 27])
2020           mesh4 = mesh3.deepCopy()
2021
2022           res = mesh4.convertDegeneratedCellsAndRemoveFlatOnes()
2023           c, cI = mesh4.getNodalConnectivity().getValues(), mesh4.getNodalConnectivityIndex().getValues()
2024           self.assertEqual(c, [NORM_QPOLYG, 0,1, 2,3, NORM_TRI6, 0,1,3,  4,6,7, NORM_TRI6, 0,1,2,  3,4,5])
2025           self.assertEqual(cI, [0, 5, 12, 19])
2026           self.assertEqual(res.getValues(), [2,3])
2027
2028           pass
2029
2030     def testGetNodeIdsNearPoints1(self):
2031         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
2032         coords=mesh.getCoords();
2033         tmp=DataArrayDouble.New();
2034         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
2035         tmp.setValues(vals,3,2);
2036         tmp2=DataArrayDouble.Aggregate(coords,tmp);
2037         mesh.setCoords(tmp2);
2038         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
2039         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
2040         self.assertEqual([4,9,11],c.getValues());
2041         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
2042         self.assertEqual([0,3,3,4],cI.getValues());
2043         self.assertEqual([4,9,11,6],c.getValues());
2044         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
2045         self.assertEqual([0,3,3,4],cI.getValues());
2046         self.assertEqual([4,9,11,6],c.getValues());
2047         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
2048         self.assertEqual([0,3,3,4],cI.getValues());
2049         self.assertEqual([4,9,11,6],c.getValues());
2050         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
2051         pass
2052
2053     def testFieldCopyTinyAttrFrom1(self):
2054         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2055         f1.setName("f1");
2056         f1.setTimeTolerance(1.e-5);
2057         f1.setDescription("f1Desc");
2058         f1.setTime(1.23,4,5);
2059         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2060         f2.setName("f2");
2061         f2.setDescription("f2Desc");
2062         f2.setTime(6.78,9,10);
2063         f2.setTimeTolerance(4.556e-12);
2064         #
2065         f1.copyTinyAttrFrom(f2);
2066         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2067         t,dt,it=f1.getTime()
2068         self.assertAlmostEqual(6.78,t,12);
2069         self.assertEqual(9,dt);
2070         self.assertEqual(10,it);
2071         self.assertTrue(f1.getName()=="f1");#name unchanged
2072         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2073         #
2074         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2075         f1.setName("f1");
2076         f1.setTimeTolerance(1.e-5);
2077         f1.setDescription("f1Desc");
2078         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2079         f2.setName("f2");
2080         f2.setDescription("f2Desc");
2081         f2.setTimeTolerance(4.556e-12);
2082         #
2083         f1.copyTinyAttrFrom(f2);
2084         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2085         self.assertTrue(f1.getName()=="f1");#name unchanged
2086         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2087         #
2088         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
2089         f1.setName("f1");
2090         f1.setTimeTolerance(1.e-5);
2091         f1.setDescription("f1Desc");
2092         f1.setTime(1.23,4,5);
2093         f1.setEndTime(5.43,2,1);
2094         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
2095         f2.setName("f2");
2096         f2.setDescription("f2Desc");
2097         f2.setTimeTolerance(4.556e-12);
2098         f2.setTime(6.78,9,10);
2099         f2.setEndTime(10.98,7,6);
2100         #
2101         f1.copyTinyAttrFrom(f2);
2102         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2103         self.assertTrue(f1.getName()=="f1");#name unchanged
2104         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2105         t,dt,it=f1.getTime()
2106         self.assertAlmostEqual(6.78,t,12);
2107         self.assertEqual(9,dt);
2108         self.assertEqual(10,it);
2109         t,dt,it=f1.getEndTime()
2110         self.assertAlmostEqual(10.98,t,12);
2111         self.assertEqual(7,dt);
2112         self.assertEqual(6,it);
2113         #
2114         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2115         f1.setName("f1");
2116         f1.setTimeTolerance(1.e-5);
2117         f1.setDescription("f1Desc");
2118         f1.setTime(1.23,4,5);
2119         f1.setEndTime(5.43,2,1);
2120         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2121         f2.setName("f2");
2122         f2.setDescription("f2Desc");
2123         f2.setTimeTolerance(4.556e-12);
2124         f2.setTime(6.78,9,10);
2125         f2.setEndTime(10.98,7,6);
2126         #
2127         f1.copyTinyAttrFrom(f2);
2128         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
2129         self.assertTrue(f1.getName()=="f1");#name unchanged
2130         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
2131         t,dt,it=f1.getTime()
2132         self.assertAlmostEqual(6.78,t,12);
2133         self.assertEqual(9,dt);
2134         self.assertEqual(10,it);
2135         t,dt,it=f1.getEndTime()
2136         self.assertAlmostEqual(10.98,t,12);
2137         self.assertEqual(7,dt);
2138         self.assertEqual(6,it);
2139         pass
2140
2141     def testExtrudedMesh5(self):
2142         coo1=[0.,1.,2.,3.5]
2143         a=DataArrayDouble.New();
2144         a.setValues(coo1,4,1);
2145         b=MEDCouplingCMesh.New();
2146         b.setCoordsAt(0,a);
2147         c=b.buildUnstructured();
2148         self.assertEqual(1,c.getSpaceDimension());
2149         c.changeSpaceDimension(2);
2150         #
2151         d=DataArrayDouble.New();
2152         d.alloc(13,1);
2153         d.iota();
2154         e=MEDCouplingCMesh.New();
2155         e.setCoordsAt(0,d);
2156         f=e.buildUnstructured();
2157         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
2158         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 !
2159         h=g.fromPolarToCart();
2160         f.setCoords(h);
2161         i=c.buildExtrudedMesh(f,1);
2162         self.assertEqual(52,i.getNumberOfNodes());
2163         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
2164         self.assertTrue(tmp2);
2165         self.assertEqual(37,tmp3);
2166         i.convertDegeneratedCells();
2167         i.checkConsistencyLight();
2168         self.assertEqual(36,i.getNumberOfCells());
2169         self.assertEqual(37,i.getNumberOfNodes());
2170         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
2171         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
2172         expected1=[0.25,0.75,2.0625]
2173         j=i.getMeasureField(True);
2174         for ii in range(12):
2175             for k in range(3):
2176                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
2177                 pass
2178             pass
2179         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]
2180         m=i.computeCellCenterOfMass();
2181         for i in range(72):
2182             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
2183             pass
2184         #
2185         pass
2186
2187     def testExtrudedMesh6(self):
2188         coo1=[0.,1.,2.,3.5]
2189         a=DataArrayDouble.New();
2190         a.setValues(coo1,4,1);
2191         b=MEDCouplingCMesh.New();
2192         b.setCoordsAt(0,a);
2193         c=b.buildUnstructured();
2194         self.assertEqual(1,c.getSpaceDimension());
2195         c.changeSpaceDimension(2);
2196         #
2197         d=DataArrayDouble.New();
2198         d.alloc(5);
2199         d.iota();
2200         e=MEDCouplingCMesh.New();
2201         e.setCoordsAt(0,d);
2202         f=e.buildUnstructured();
2203         d2=f.getCoords().applyFunc("x*x/2");
2204         f.setCoords(d2);
2205         f.changeSpaceDimension(2);
2206         #
2207         center=[0.,0.]
2208         f.rotate(center,None,pi/3);
2209         g=c.buildExtrudedMesh(f,0);
2210         g.checkConsistencyLight();
2211         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 ]
2212         f1=g.getMeasureField(True);
2213         for i in range(12):
2214             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
2215             pass
2216         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]
2217         f2=g.computeCellCenterOfMass();
2218         for i in range(24):
2219             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
2220             pass
2221         pass
2222
2223     def testExtrudedMesh7(self):
2224         coo1=[0.,1.,2.,3.5]
2225         a=DataArrayDouble.New();
2226         a.setValues(coo1,4,1);
2227         b=MEDCouplingCMesh.New();
2228         b.setCoordsAt(0,a);
2229         c=b.buildUnstructured();
2230         self.assertEqual(1,c.getSpaceDimension());
2231         c.changeSpaceDimension(2);
2232         #
2233         d=DataArrayDouble.New();
2234         d.alloc(13,1);
2235         d.iota();
2236         e=MEDCouplingCMesh.New();
2237         e.setCoordsAt(0,d);
2238         f=e.buildUnstructured();
2239         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
2240         h=g.fromPolarToCart();
2241         f.setCoords(h);
2242         i=c.buildExtrudedMesh(f,1);
2243         self.assertEqual(52,i.getNumberOfNodes());
2244         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
2245         self.assertTrue(tmp2);
2246         self.assertEqual(37,tmp3);
2247         i.convertDegeneratedCells();
2248         vec1=[10.,0]
2249         i.translate(vec1);
2250         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
2251         f.setCoords(g2);
2252         i.changeSpaceDimension(3);
2253         i3=i.buildExtrudedMesh(f,1);
2254         f2=i3.getMeasureField(True);
2255         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
2256         self.assertTrue(tmp2);
2257         self.assertEqual(444,tmp3);
2258         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]
2259         for ii in range(12):
2260             for jj in range(36):
2261                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
2262                 pass
2263         #
2264         pass
2265
2266     def testSimplexize1(self):
2267         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2268         m.convertToPolyTypes([3]);
2269         da=m.simplexize(0);
2270         self.assertEqual(7,da.getNumberOfTuples());
2271         self.assertEqual(1,da.getNumberOfComponents());
2272         expected2=[0,0,1,2,3,4,4]
2273         for i in range(7):
2274             self.assertEqual(expected2[i],da.getIJ(i,0));
2275             pass
2276         m.checkConsistencyLight();
2277         self.assertEqual(7,m.getNumberOfCells());
2278         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
2279         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2280         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
2281         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2282         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
2283         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
2284         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
2285         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
2286         f=m.getMeasureField(False);
2287         for i in range(7):
2288             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
2289             pass
2290         types=m.getAllGeoTypes();
2291         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
2292         #
2293         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2294         m.convertToPolyTypes([3]);
2295         da=m.simplexize(1);
2296         self.assertEqual(7,da.getNumberOfTuples());
2297         self.assertEqual(1,da.getNumberOfComponents());
2298         for i in range(7):
2299             self.assertEqual(expected2[i],da.getIJ(i,0));
2300             pass
2301         m.checkConsistencyLight();
2302         types=m.getAllGeoTypes();
2303         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
2304         self.assertEqual(7,m.getNumberOfCells());
2305         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
2306         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2307         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
2308         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2309         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
2310         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
2311         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
2312         f=m.getMeasureField(False);
2313         for i in range(7):
2314             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
2315             pass
2316         pass
2317
2318     def testSimplexize2(self):
2319         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2320         m.convertToPolyTypes([3]);
2321         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2322         f1.setMesh(m);
2323         arr=DataArrayDouble.New();
2324         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
2325         arr.setValues(arr1,5,2);
2326         f1.setArray(arr);
2327         #
2328         f1.checkConsistencyLight();
2329         self.assertTrue(f1.simplexize(0));
2330         f1.checkConsistencyLight();
2331         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
2332         for i in range(14):
2333             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
2334             pass
2335         self.assertTrue(not f1.simplexize(0));
2336         for i in range(14):
2337             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
2338             pass
2339         #
2340         pass
2341
2342     def testDAMeld1(self):
2343         da1=DataArrayDouble.New();
2344         da1.alloc(7,2);
2345         da2=DataArrayDouble.New();
2346         da2.alloc(7,1);
2347         #
2348         da1.fillWithValue(7.);
2349         da2.iota(0.);
2350         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
2351         #
2352         da1.setInfoOnComponent(0,"c0da1");
2353         da1.setInfoOnComponent(1,"c1da1");
2354         da3.setInfoOnComponent(0,"c0da3");
2355         da3.setInfoOnComponent(1,"c1da3");
2356         da3.setInfoOnComponent(2,"c2da3");
2357         #
2358         da1C=da1.deepCopy();
2359         da1.meldWith(da3);
2360         self.assertEqual(5,da1.getNumberOfComponents());
2361         self.assertEqual(7,da1.getNumberOfTuples());
2362         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
2363         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
2364         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
2365         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
2366         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
2367         #
2368         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.]
2369         for i in range(35):
2370             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
2371             pass
2372         #
2373         dai1=da1C.convertToIntArr();
2374         dai3=da3.convertToIntArr();
2375         dai1.meldWith(dai3);
2376         self.assertEqual(5,dai1.getNumberOfComponents());
2377         self.assertEqual(7,dai1.getNumberOfTuples());
2378         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
2379         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
2380         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
2381         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
2382         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
2383         for i in range(35):
2384             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
2385             pass
2386         # test of static method DataArrayDouble::meld
2387         da4=DataArrayDouble.Meld(da1C,da3);
2388         tmp=DataArrayDouble.Meld([da1C,da3]);
2389         self.assertTrue(da4.isEqual(tmp,1e-10))
2390         self.assertEqual(5,da4.getNumberOfComponents());
2391         self.assertEqual(7,da4.getNumberOfTuples());
2392         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
2393         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
2394         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
2395         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
2396         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
2397         for i in range(35):
2398             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
2399             pass
2400         # test of static method DataArrayInt::meld
2401         dai1=da1C.convertToIntArr();
2402         dai4=DataArrayInt.Meld(dai1,dai3);
2403         tmp=DataArrayInt.Meld([dai1,dai3]);
2404         self.assertTrue(dai4.isEqual(tmp))
2405         self.assertEqual(5,dai4.getNumberOfComponents());
2406         self.assertEqual(7,dai4.getNumberOfTuples());
2407         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
2408         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
2409         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
2410         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
2411         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
2412         for i in range(35):
2413             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
2414             pass
2415         pass
2416
2417     def testFieldMeld1(self):
2418         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2419         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2420         f1.setMesh(m);
2421         da1=DataArrayDouble.New();
2422         arr1=[12.,23.,34.,45.,56.]
2423         da1.setValues(arr1,5,1);
2424         da1.setInfoOnComponent(0,"aaa");
2425         f1.setArray(da1);
2426         f1.setTime(3.4,2,1);
2427         f1.checkConsistencyLight();
2428         #
2429         f2=f1.deepCopy();
2430         f2.setMesh(f1.getMesh());
2431         f2.checkConsistencyLight();
2432         f2.changeNbOfComponents(2,5.);
2433         f2.assign(5.);
2434         f2.getArray().setInfoOnComponent(0,"bbb");
2435         f2.getArray().setInfoOnComponent(1,"ccc");
2436         f2.checkConsistencyLight();
2437         #
2438         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
2439         f3.checkConsistencyLight();
2440         self.assertEqual(5,f3.getNumberOfTuples());
2441         self.assertEqual(3,f3.getNumberOfComponents());
2442         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
2443         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
2444         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
2445         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
2446         for i in range(15):
2447             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
2448             pass
2449         time,dt,it=f3.getTime();
2450         self.assertAlmostEqual(3.4,time,14);
2451         self.assertEqual(2,dt);
2452         self.assertEqual(1,it);
2453         #
2454         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
2455         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
2456         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
2457         f6.checkConsistencyLight();
2458         self.assertEqual(5,f6.getNumberOfTuples());
2459         self.assertEqual(3,f6.getNumberOfComponents());
2460         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
2461         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
2462         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
2463         for i in range(15):
2464             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
2465             pass
2466         #
2467         pass
2468
2469     def testMergeNodes2(self):
2470         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2471         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2472         vec=[0.002,0.]
2473         m2.translate(vec);
2474         #
2475         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
2476         da,b,newNbOfNodes=m3.mergeNodesCenter(0.01);
2477         self.assertEqual(9,m3.getNumberOfNodes());
2478         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]
2479         for i in range(18):
2480             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
2481             pass
2482         #
2483         pass
2484
2485     def testMergeField2(self):
2486         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2487         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2488         f1.setMesh(m);
2489         arr=DataArrayDouble.New();
2490         arr.alloc(5,2);
2491         arr.fillWithValue(2.);
2492         f1.setArray(arr);
2493         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2494         f2.setMesh(m);
2495         arr=DataArrayDouble.New();
2496         arr.alloc(5,2);
2497         arr.fillWithValue(5.);
2498         f2.setArray(arr);
2499         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2500         f3.setMesh(m);
2501         arr=DataArrayDouble.New();
2502         arr.alloc(5,2);
2503         arr.fillWithValue(7.);
2504         f3.setArray(arr);
2505         #
2506         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
2507         self.assertEqual(15,f4.getMesh().getNumberOfCells());
2508         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.]
2509         for i in range(30):
2510             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
2511             pass
2512         #
2513         pass
2514
2515     def testDAIBuildComplement1(self):
2516         a=DataArrayInt.New();
2517         tab=[3,1,7,8]
2518         a.setValues(tab,4,1);
2519         b=a.buildComplement(12);
2520         self.assertEqual(8,b.getNumberOfTuples());
2521         self.assertEqual(1,b.getNumberOfComponents());
2522         expected1=[0,2,4,5,6,9,10,11]
2523         for i in range(8):
2524             self.assertEqual(expected1[i],b.getIJ(0,i));
2525             pass
2526         pass
2527
2528     def testDAIBuildUnion1(self):
2529         a=DataArrayInt.New();
2530         tab1=[3,1,7,8]
2531         a.setValues(tab1,4,1);
2532         c=DataArrayInt.New();
2533         tab2=[5,3,0,18,8]
2534         c.setValues(tab2,5,1);
2535         b=a.buildUnion(c);
2536         self.assertEqual(7,b.getNumberOfTuples());
2537         self.assertEqual(1,b.getNumberOfComponents());
2538         expected1=[0,1,3,5,7,8,18]
2539         for i in range(7):
2540             self.assertEqual(expected1[i],b.getIJ(0,i));
2541             pass
2542         b=DataArrayInt.BuildUnion([a,c]);
2543         self.assertEqual(7,b.getNumberOfTuples());
2544         self.assertEqual(1,b.getNumberOfComponents());
2545         expected1=[0,1,3,5,7,8,18]
2546         for i in range(7):
2547             self.assertEqual(expected1[i],b.getIJ(0,i));
2548             pass
2549         pass
2550
2551     def testDAIBuildIntersection1(self):
2552         a=DataArrayInt.New();
2553         tab1=[3,1,7,8]
2554         a.setValues(tab1,4,1);
2555         c=DataArrayInt.New();
2556         tab2=[5,3,0,18,8]
2557         c.setValues(tab2,5,1);
2558         b=a.buildIntersection(c);
2559         self.assertEqual(2,b.getNumberOfTuples());
2560         self.assertEqual(1,b.getNumberOfComponents());
2561         expected1=[3,8]
2562         for i in range(2):
2563             self.assertEqual(expected1[i],b.getIJ(0,i));
2564             pass
2565         b=DataArrayInt.BuildIntersection([a,c]);
2566         self.assertEqual(2,b.getNumberOfTuples());
2567         self.assertEqual(1,b.getNumberOfComponents());
2568         expected1=[3,8]
2569         for i in range(2):
2570             self.assertEqual(expected1[i],b.getIJ(0,i));
2571             pass
2572         pass
2573
2574     def testDAIDeltaShiftIndex1(self):
2575         a=DataArrayInt.New();
2576         tab=[1,3,6,7,7,9,15]
2577         a.setValues(tab,7,1);
2578         b=a.deltaShiftIndex();
2579         self.assertEqual(6,b.getNumberOfTuples());
2580         self.assertEqual(1,b.getNumberOfComponents());
2581         expected1=[2,3,1,0,2,6]
2582         for i in range(6):
2583             self.assertEqual(expected1[i],b.getIJ(0,i));
2584             pass
2585         pass
2586
2587     def testDaDoubleSelectByTupleIdSafe1(self):
2588         a=DataArrayDouble.New();
2589         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]
2590         a.setValues(arr1,7,2);
2591         a.setInfoOnComponent(0,"toto");
2592         a.setInfoOnComponent(1,"tata");
2593         #
2594         arr2=[4,2,0,6,5]
2595         b=a.selectByTupleIdSafe(arr2);
2596         self.assertEqual(5,b.getNumberOfTuples());
2597         self.assertEqual(2,b.getNumberOfComponents());
2598         self.assertTrue(b.getInfoOnComponent(0)=="toto");
2599         self.assertTrue(b.getInfoOnComponent(1)=="tata");
2600         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
2601         for i in range(10):
2602             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
2603             pass
2604         arr4=[4,-1,0,6,5]
2605         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
2606         arr5=[4,2,0,6,7]
2607         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
2608         #
2609         c=DataArrayInt.New();
2610         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
2611         c.setValues(arr3,7,2);
2612         c.setInfoOnComponent(0,"toto");
2613         c.setInfoOnComponent(1,"tata");
2614         d=c.selectByTupleIdSafe(arr2);
2615         self.assertEqual(5,d.getNumberOfTuples());
2616         self.assertEqual(2,d.getNumberOfComponents());
2617         self.assertTrue(d.getInfoOnComponent(0)=="toto");
2618         self.assertTrue(d.getInfoOnComponent(1)=="tata");
2619         expected2=[5,15,3,13,1,11,7,17,6,16]
2620         for i in range(10):
2621             self.assertEqual(expected2[i],d.getIJ(0,i));
2622             pass
2623         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
2624         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
2625         pass
2626
2627     def testAreCellsIncludedIn1(self):
2628         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2629         pt=[1,3]
2630         m2=m.buildPartOfMySelf(pt,True);
2631         ret,tmp=m.areCellsIncludedIn(m2,0)
2632         self.assertTrue(ret);
2633         self.assertEqual(2,tmp.getNumberOfTuples());
2634         self.assertEqual(1,tmp.getNumberOfComponents());
2635         self.assertEqual(pt[0],tmp.getIJ(0,0));
2636         self.assertEqual(pt[1],tmp.getIJ(0,1));
2637         ret,tmp=m2.areCellsIncludedIn(m,0)
2638         self.assertTrue(not ret);
2639         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
2640         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
2641         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
2642         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
2643         pass
2644
2645     def testSwigErrorProtection1(self):
2646         m=MEDCouplingDataForTest.build3DTargetMesh_1();
2647         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
2648         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
2649         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
2650         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
2651         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
2652         m2=m.buildPartOfMySelf([2,5],True)
2653         m3=m.buildPartOfMySelf((2,5),True)
2654         self.assertTrue(m2.isEqual(m3,1e-12))
2655         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
2656         da1=m.getCoords().keepSelectedComponents([1])
2657         da2=m.getCoords().keepSelectedComponents((1,))
2658         self.assertTrue(da1.isEqual(da2,1e-12))
2659         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
2660         pass
2661
2662     def testDAIBuildSubstraction1(self):
2663         a=DataArrayInt.New()
2664         aa=[2,3,6,8,9]
2665         a.setValues(aa,5,1)
2666         b=DataArrayInt.New()
2667         bb=[1,3,5,9,11]
2668         b.setValues(bb,5,1)
2669         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
2670         pass
2671
2672     def testBuildOrthogonalField2(self):
2673         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2674         d1=DataArrayInt.New();
2675         d2=DataArrayInt.New();
2676         d3=DataArrayInt.New();
2677         d4=DataArrayInt.New();
2678         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
2679         #
2680         f1=m1.buildOrthogonalField();
2681         da1=f1.getArray();
2682         self.assertEqual(2,da1.getNumberOfComponents());
2683         self.assertEqual(13,da1.getNumberOfTuples());
2684         #
2685         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.];
2686         for i in range(26):
2687             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
2688             pass
2689         pass
2690
2691     def testSwigErrorProtection2(self):
2692         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2693         coo=m.getCoords()
2694         c=m.getNodalConnectivity()
2695         ci=m.getNodalConnectivityIndex()
2696         del m
2697         self.assertEqual(2,coo.getNumberOfComponents());
2698         self.assertEqual(6,ci.getNumberOfTuples());
2699         self.assertEqual(23,c.getNumberOfTuples());
2700         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2701         f=m.getMeasureField(True)
2702         c=f.getArray()
2703         del f
2704         self.assertEqual(1,c.getNumberOfComponents());
2705         m=MEDCouplingCMesh.New()
2706         x=DataArrayDouble.New()
2707         x.setValues([1.,2.,4.],3,1)
2708         m.setCoordsAt(0,x)
2709         del x
2710         xx=m.getCoordsAt(0)
2711         del m
2712         self.assertEqual(3,xx.getNumberOfTuples());
2713         #
2714         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2715         f=m.getMeasureField(True)
2716         m2=f.getMesh()
2717         del m
2718         del f
2719         self.assertEqual(5,m2.getNumberOfCells());
2720         pass
2721
2722     def testUMInsertNextCell1(self):
2723         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 ]
2724         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
2725         targetMesh=MEDCouplingUMesh.New();
2726         targetMesh.allocateCells(5);
2727         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
2728         targetMesh.setMeshDimension(2);
2729         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
2730         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
2731         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
2732         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
2733         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
2734         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
2735         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
2736         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
2737         targetMesh.finishInsertingCells();
2738         myCoords=DataArrayDouble.New();
2739         myCoords.setValues(targetCoords,9,2);
2740         targetMesh.setCoords(myCoords);
2741         targetMesh.checkConsistencyLight();
2742         pass
2743
2744     def testFieldOperatorDivDiffComp1(self):
2745         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2746         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
2747         #
2748         f1=m1.buildOrthogonalField();
2749         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
2750         arr=DataArrayDouble.New();
2751         arr.setValues(arr1,13,1);
2752         f2=MEDCouplingFieldDouble.New(ON_CELLS);
2753         f2.setArray(arr);
2754         f2.setMesh(m1);
2755         f2.checkConsistencyLight();
2756         #
2757         f3=f1/f2;
2758         self.assertRaises(InterpKernelException,f2.__div__,f1)
2759         f3.checkConsistencyLight();
2760         f1/=f2;
2761         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
2762         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
2763         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]
2764         for i in range(26):
2765             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
2766             pass
2767         pass
2768
2769     def testDARearrange1(self):
2770         da1=DataArrayInt.New();
2771         da1.alloc(12,1);
2772         da1.iota(0);
2773         #
2774         self.assertEqual(12,da1.getNbOfElems());
2775         self.assertEqual(1,da1.getNumberOfComponents());
2776         self.assertEqual(12,da1.getNumberOfTuples());
2777         da1.rearrange(4);
2778         self.assertEqual(12,da1.getNbOfElems());
2779         self.assertEqual(4,da1.getNumberOfComponents());
2780         self.assertEqual(3,da1.getNumberOfTuples());
2781         for i in range(12):
2782             self.assertEqual(i,da1.getIJ(0,i));
2783         #
2784         da1.rearrange(6);
2785         self.assertEqual(12,da1.getNbOfElems());
2786         self.assertEqual(6,da1.getNumberOfComponents());
2787         self.assertEqual(2,da1.getNumberOfTuples());
2788         for i in range(12):
2789             self.assertEqual(i,da1.getIJ(0,i));
2790         #
2791         self.assertRaises(InterpKernelException,da1.rearrange,7);
2792         #
2793         da1.rearrange(12);
2794         self.assertEqual(12,da1.getNbOfElems());
2795         self.assertEqual(12,da1.getNumberOfComponents());
2796         self.assertEqual(1,da1.getNumberOfTuples());
2797         for i in range(12):
2798             self.assertEqual(i,da1.getIJ(0,i));
2799         #
2800         da1.rearrange(3);
2801         self.assertEqual(12,da1.getNbOfElems());
2802         self.assertEqual(3,da1.getNumberOfComponents());
2803         self.assertEqual(4,da1.getNumberOfTuples());
2804         for i in range(12):
2805             self.assertEqual(i,da1.getIJ(0,i));
2806         #double
2807         da2=da1.convertToDblArr();
2808         st=da2.getHiddenCppPointer()
2809         #
2810         self.assertEqual(12,da2.getNbOfElems());
2811         self.assertEqual(3,da2.getNumberOfComponents());
2812         self.assertEqual(4,da2.getNumberOfTuples());
2813         da2.rearrange(4);
2814         self.assertEqual(12,da2.getNbOfElems());
2815         self.assertEqual(4,da2.getNumberOfComponents());
2816         self.assertEqual(3,da2.getNumberOfTuples());
2817         for i in range(12):
2818             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2819         #
2820         da2.rearrange(6);
2821         self.assertEqual(12,da2.getNbOfElems());
2822         self.assertEqual(6,da2.getNumberOfComponents());
2823         self.assertEqual(2,da2.getNumberOfTuples());
2824         for i in range(12):
2825             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2826         #
2827         self.assertRaises(InterpKernelException,da2.rearrange,7);
2828         #
2829         da2.rearrange(1);
2830         self.assertEqual(st,da2.getHiddenCppPointer())
2831         self.assertEqual(12,da2.getNbOfElems());
2832         self.assertEqual(1,da2.getNumberOfComponents());
2833         self.assertEqual(12,da2.getNumberOfTuples());
2834         for i in range(12):
2835             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2836         #
2837         da2.rearrange(3);
2838         self.assertEqual(12,da2.getNbOfElems());
2839         self.assertEqual(3,da2.getNumberOfComponents());
2840         self.assertEqual(4,da2.getNumberOfTuples());
2841         for i in range(12):
2842             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
2843         pass
2844
2845     def testDARearrange2(self):
2846         da1=DataArrayInt.New();
2847         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
2848         da1.setValues(arr,4,3);
2849         s=da1.getDifferentValues();
2850         expected1=DataArrayInt([1,2,3,5])
2851         self.assertTrue(expected1.isEqual(s));
2852         pass
2853
2854     def testSwigErrorProtection3(self):
2855         da=DataArrayInt.New()
2856         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
2857         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
2858         self.assertEqual(3,da.getNumberOfComponents());
2859         self.assertEqual(4,da.getNumberOfTuples());
2860         da=DataArrayInt.New()
2861         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
2862         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
2863         self.assertEqual(3,da.getNumberOfComponents());
2864         self.assertEqual(4,da.getNumberOfTuples());
2865         da.setValues((10*[1]+290*[2])[:12],4,3)
2866         self.assertEqual(10*[1]+[2,2],da.getValues())
2867         self.assertEqual(3,da.getNumberOfComponents());
2868         self.assertEqual(4,da.getNumberOfTuples());
2869         #
2870         da=DataArrayDouble.New()
2871         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
2872         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
2873         self.assertEqual(3,da.getNumberOfComponents());
2874         self.assertEqual(4,da.getNumberOfTuples());
2875         da=DataArrayDouble.New()
2876         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
2877         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
2878         self.assertEqual(3,da.getNumberOfComponents());
2879         self.assertEqual(4,da.getNumberOfTuples());
2880         da.setValues((10*[1]+290*[2])[:12],4,3)
2881         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
2882         self.assertEqual(3,da.getNumberOfComponents());
2883         self.assertEqual(4,da.getNumberOfTuples());
2884         pass
2885
2886     def testDAIBuildPermutationArr1(self):
2887         a=DataArrayInt.New()
2888         a.setValues([4,5,6,7,8],5,1)
2889         b=DataArrayInt.New()
2890         b.setValues([5,4,8,6,7],5,1)
2891         c=a.buildPermutationArr(b)
2892         self.assertEqual([1,0,4,2,3],c.getValues())
2893         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
2894         b.setIJ(0,0,9)
2895         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
2896         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
2897         a.setIJ(3,0,4)
2898         b.setIJ(0,0,5)
2899         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
2900         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
2901         c=a.buildPermutationArr(b)
2902         self.assertEqual([1,3,4,2,3],c.getValues())
2903         d=b.convertToDblArr()
2904         expect3=[4,4,5,6,8]
2905         b.sort()
2906         self.assertEqual(expect3,b.getValues())
2907         d.sort()
2908         self.assertEqual(5,d.getNumberOfTuples());
2909         self.assertEqual(1,d.getNumberOfComponents());
2910         for i in range(5):
2911             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
2912             pass
2913         pass
2914
2915     def testAreCellsIncludedIn2(self):
2916         myName="Vitoo";
2917         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2918         m2=m.buildPartOfMySelf([],True);
2919         self.assertEqual(0,m2.getNumberOfCells());
2920         self.assertEqual(3,m2.getSpaceDimension());
2921         self.assertEqual(2,m2.getMeshDimension());
2922         m2.setName(myName);
2923         test,tmp=m.areCellsIncludedIn(m2,0)
2924         self.assertTrue(test);
2925         self.assertEqual(myName,tmp.getName());
2926         self.assertEqual(0,tmp.getNumberOfTuples())
2927         self.assertEqual(1,tmp.getNumberOfComponents())
2928         pass
2929
2930     def testUMeshGetPartBarycenterAndOwner1(self):
2931         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2932         part1=[1,0,4];
2933         part=DataArrayInt.New();
2934         part.setValues(part1,3,1);
2935         b=m1.getPartBarycenterAndOwner(part);
2936         self.assertEqual(2,b.getNumberOfComponents());
2937         self.assertEqual(3,b.getNumberOfTuples());
2938         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
2939         for i in range(6):
2940             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
2941             pass
2942         pass
2943
2944     def testUMeshGetPartMeasureField1(self):
2945         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2946         part1=[1,0,4];
2947         part=DataArrayInt.New();
2948         part.setValues(part1,3,1);
2949         b=m1.getPartMeasureField(True,part);
2950         self.assertEqual(1,b.getNumberOfComponents());
2951         self.assertEqual(3,b.getNumberOfTuples());
2952         expected1=[0.125,0.25,0.25];
2953         for i in range(3):
2954             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
2955             pass
2956         pass
2957
2958     def testUMeshBuildPartOrthogonalField1(self):
2959         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2960         m1.changeSpaceDimension(3);
2961         part1=[1,0,4];
2962         part=DataArrayInt.New();
2963         part.setValues(part1,3,1);
2964         b=m1.buildPartOrthogonalField(part);
2965         self.assertEqual(3,b.getArray().getNumberOfComponents());
2966         self.assertEqual(3,b.getArray().getNumberOfTuples());
2967         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
2968         for i in range(9):
2969             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
2970             pass
2971         pass
2972
2973     def testUMeshGetTypesOfPart1(self):
2974         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2975         part1=[0,3,4];
2976         p1=DataArrayInt.New()
2977         p1.setValues(part1,3,1)
2978         s=m1.getTypesOfPart(p1);
2979         self.assertEqual([NORM_QUAD4],s);
2980         part2=[2,2,2,1];
2981         p2=DataArrayInt.New()
2982         p2.setValues(part2,4,1)
2983         s=m1.getTypesOfPart(p2);
2984         self.assertEqual([NORM_TRI3],s);
2985         part3=[3,2,1];
2986         p3=DataArrayInt.New()
2987         p3.setValues(part3,3,1)
2988         s=m1.getTypesOfPart(p3);
2989         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
2990         pass
2991
2992     def testUMeshKeepCellIdsByType1(self):
2993         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2994         part1=[0,3,4]
2995         p1=DataArrayInt.New()
2996         p1.setValues(part1,3,1)
2997         p1.setName("p1")
2998         a=m1.keepCellIdsByType(NORM_TRI3,p1);
2999         self.assertEqual("p1",a.getName())
3000         self.assertEqual(1,a.getNumberOfComponents());
3001         self.assertEqual(0,a.getNumberOfTuples());
3002         #
3003         part2=[3,2,0,2,4]
3004         p2=DataArrayInt.New()
3005         p2.setValues(part2,5,1)
3006         p2.setName("p2")
3007         a=m1.keepCellIdsByType(NORM_TRI3,p2);
3008         self.assertEqual("p2",a.getName())
3009         self.assertEqual(1,a.getNumberOfComponents());
3010         self.assertEqual(2,a.getNumberOfTuples());
3011         self.assertEqual(2,a.getIJ(0,0));
3012         self.assertEqual(2,a.getIJ(1,0));
3013         #
3014         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
3015         self.assertEqual("p2",a.getName())
3016         self.assertEqual(1,a.getNumberOfComponents());
3017         self.assertEqual(3,a.getNumberOfTuples());
3018         self.assertEqual(3,a.getIJ(0,0));
3019         self.assertEqual(0,a.getIJ(1,0));
3020         self.assertEqual(4,a.getIJ(2,0));
3021         pass
3022
3023     def testSwigErrorDaIntSelectByTupleId1(self):
3024         a=DataArrayInt.New();
3025         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
3026         a.setValues(arr1,7,2);
3027         a.setInfoOnComponent(0,"toto");
3028         a.setInfoOnComponent(1,"tata");
3029         #
3030         arr2=[4,2,0,6,5]
3031         b=a.selectByTupleId(arr2);
3032         self.assertEqual(5,b.getNumberOfTuples());
3033         self.assertEqual(2,b.getNumberOfComponents());
3034         self.assertTrue(b.getInfoOnComponent(0)=="toto");
3035         self.assertTrue(b.getInfoOnComponent(1)=="tata");
3036         expected1=[5,15,3,13,1,11,7,17,6,16]
3037         self.assertEqual(expected1,b.getValues())
3038         #
3039         a2=DataArrayInt.New()
3040         a2.setValues(arr2,5,1)
3041         b=a.selectByTupleId(a2);
3042         self.assertEqual(5,b.getNumberOfTuples());
3043         self.assertEqual(2,b.getNumberOfComponents());
3044         self.assertTrue(b.getInfoOnComponent(0)=="toto");
3045         self.assertTrue(b.getInfoOnComponent(1)=="tata");
3046         expected1=[5,15,3,13,1,11,7,17,6,16]
3047         self.assertEqual(expected1,b.getValues())
3048         pass
3049
3050     def testSwigErrorRenum(self):
3051         da=DataArrayDouble.New()
3052         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
3053         d=DataArrayInt.New()
3054         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
3055         da.renumberInPlace(d)
3056         da.renumber(d)
3057         pass
3058
3059     pass
3060
3061 if __name__ == '__main__':
3062     unittest.main()