src/MEDCoupling_Swig/MEDCouplingBasicsTest2.py

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