src/MEDCoupling_Swig/MEDCouplingBasicsTest2.py

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