src/MEDCoupling_Swig/MEDCouplingBasicsTest7.py

   1 #  -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2023  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 MEDCouplingBasicsTest7(unittest.TestCase):
  31
  32     def testDAIGetIdsEqual1(self):
  33         tab1=[5,-2,-4,-2,3,2,-2];
  34         da=DataArrayInt64.New();
  35         da.setValues(tab1,7,1);
  36         da2=da.findIdsEqual(-2);
  37         self.assertEqual(3,da2.getNumberOfTuples());
  38         self.assertEqual(1,da2.getNumberOfComponents());
  39         expected1=[1,3,6];
  40         self.assertEqual(expected1,da2.getValues());
  41         pass
  42
  43     def testDAIGetIdsEqualList1(self):
  44         tab1=[5,-2,-4,-2,3,2,-2];
  45         da=DataArrayInt64.New();
  46         da.setValues(tab1,7,1);
  47         da2=da.findIdsEqualList([3,-2,0]);
  48         self.assertEqual(4,da2.getNumberOfTuples());
  49         self.assertEqual(1,da2.getNumberOfComponents());
  50         expected1=[1,3,4,6];
  51         self.assertEqual(expected1,da2.getValues());
  52         pass
  53
  54     def testDAIsUniform1(self):
  55         tab1=[1,1,1,1,1]
  56         da=DataArrayInt64.New();
  57         da.setValues(tab1,5,1);
  58         self.assertTrue(da.isUniform(1));
  59         da.setIJ(2,0,2);
  60         self.assertTrue(not da.isUniform(1));
  61         da.setIJ(2,0,1);
  62         self.assertTrue(da.isUniform(1));
  63         da2=da.convertToDblArr();
  64         self.assertTrue(da2.isUniform(1.,1.e-12));
  65         da2.setIJ(1,0,1.+1.e-13);
  66         self.assertTrue(da2.isUniform(1.,1.e-12));
  67         da2.setIJ(1,0,1.+1.e-11);
  68         self.assertTrue(not da2.isUniform(1.,1.e-12));
  69         pass
  70
  71     def testDAIBuildComplement1(self):
  72         a=DataArrayInt64.New();
  73         tab=[3,1,7,8]
  74         a.setValues(tab,4,1);
  75         b=a.buildComplement(12);
  76         self.assertEqual(8,b.getNumberOfTuples());
  77         self.assertEqual(1,b.getNumberOfComponents());
  78         expected1=[0,2,4,5,6,9,10,11]
  79         for i in range(8):
  80             self.assertEqual(expected1[i],b.getIJ(0,i));
  81             pass
  82         pass
  83
  84     def testDAIBuildUnion1(self):
  85         a=DataArrayInt64.New();
  86         tab1=[3,1,7,8]
  87         a.setValues(tab1,4,1);
  88         c=DataArrayInt64.New();
  89         tab2=[5,3,0,18,8]
  90         c.setValues(tab2,5,1);
  91         b=a.buildUnion(c);
  92         self.assertEqual(7,b.getNumberOfTuples());
  93         self.assertEqual(1,b.getNumberOfComponents());
  94         expected1=[0,1,3,5,7,8,18]
  95         for i in range(7):
  96             self.assertEqual(expected1[i],b.getIJ(0,i));
  97             pass
  98         b=DataArrayInt64.BuildUnion([a,c]);
  99         self.assertEqual(7,b.getNumberOfTuples());
 100         self.assertEqual(1,b.getNumberOfComponents());
 101         expected1=[0,1,3,5,7,8,18]
 102         for i in range(7):
 103             self.assertEqual(expected1[i],b.getIJ(0,i));
 104             pass
 105         pass
 106
 107     def testDAIBuildIntersection1(self):
 108         a=DataArrayInt64.New();
 109         tab1=[3,1,7,8]
 110         a.setValues(tab1,4,1);
 111         c=DataArrayInt64.New();
 112         tab2=[5,3,0,18,8]
 113         c.setValues(tab2,5,1);
 114         b=a.buildIntersection(c);
 115         self.assertEqual(2,b.getNumberOfTuples());
 116         self.assertEqual(1,b.getNumberOfComponents());
 117         expected1=[3,8]
 118         for i in range(2):
 119             self.assertEqual(expected1[i],b.getIJ(0,i));
 120             pass
 121         b=DataArrayInt64.BuildIntersection([a,c]);
 122         self.assertEqual(2,b.getNumberOfTuples());
 123         self.assertEqual(1,b.getNumberOfComponents());
 124         expected1=[3,8]
 125         for i in range(2):
 126             self.assertEqual(expected1[i],b.getIJ(0,i));
 127             pass
 128         pass
 129
 130     def testDAIDeltaShiftIndex1(self):
 131         a=DataArrayInt64.New();
 132         tab=[1,3,6,7,7,9,15]
 133         a.setValues(tab,7,1);
 134         b=a.deltaShiftIndex();
 135         self.assertEqual(6,b.getNumberOfTuples());
 136         self.assertEqual(1,b.getNumberOfComponents());
 137         expected1=[2,3,1,0,2,6]
 138         for i in range(6):
 139             self.assertEqual(expected1[i],b.getIJ(0,i));
 140             pass
 141         pass
 142
 143     def testDAIBuildSubstraction1(self):
 144         a=DataArrayInt64.New()
 145         aa=[2,3,6,8,9]
 146         a.setValues(aa,5,1)
 147         b=DataArrayInt64.New()
 148         bb=[1,3,5,9,11]
 149         b.setValues(bb,5,1)
 150         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
 151         pass
 152
 153     def testDAIBuildPermutationArr1(self):
 154         a=DataArrayInt64.New()
 155         a.setValues([4,5,6,7,8],5,1)
 156         b=DataArrayInt64.New()
 157         b.setValues([5,4,8,6,7],5,1)
 158         c=a.buildPermutationArr(b)
 159         self.assertEqual([1,0,4,2,3],c.getValues())
 160         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
 161         b.setIJ(0,0,9)
 162         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
 163         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
 164         a.setIJ(3,0,4)
 165         b.setIJ(0,0,5)
 166         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
 167         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
 168         c=a.buildPermutationArr(b)
 169         self.assertEqual([1,3,4,2,3],c.getValues())
 170         d=b.convertToDblArr()
 171         expect3=[4,4,5,6,8]
 172         b.sort()
 173         self.assertEqual(expect3,b.getValues())
 174         d.sort()
 175         self.assertEqual(5,d.getNumberOfTuples());
 176         self.assertEqual(1,d.getNumberOfComponents());
 177         for i in range(5):
 178             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
 179             pass
 180         pass
 181
 182     def testDAIAggregateMulti1(self):
 183         a=DataArrayInt64.New()
 184         a.setValues(list(range(4)),2, 2)
 185         a.setName("aa")
 186         b=DataArrayInt64.New()
 187         b.setValues(list(range(6)), 3, 2)
 188         c=DataArrayInt64.Aggregate([a,b])
 189         self.assertEqual(list(range(4)) + list(range(6)), c.getValues())
 190         self.assertEqual("aa",c.getName())
 191         self.assertEqual(5,c.getNumberOfTuples())
 192         self.assertEqual(2,c.getNumberOfComponents())
 193         pass
 194
 195     def testDAICheckAndPreparePermutation1(self):
 196         vals1=[9,10,0,6,4,11,3,7];
 197         expect1=[5,6,0,3,2,7,1,4];
 198         vals2=[9,10,0,6,10,11,3,7];
 199         da=DataArrayInt64.New();
 200         da.setValues(vals1,8,1);
 201         da2=da.checkAndPreparePermutation();
 202         self.assertEqual(8,da2.getNumberOfTuples());
 203         self.assertEqual(1,da2.getNumberOfComponents());
 204         for i in range(8):
 205             self.assertEqual(expect1[i],da2.getIJ(i,0));
 206             pass
 207         #
 208         da=DataArrayInt64.New();
 209         da.alloc(8,1);
 210         da.iota(0);
 211         da2=da.checkAndPreparePermutation();
 212         self.assertEqual(1,da2.getNumberOfComponents());
 213         self.assertTrue(da2.isIota(8));
 214         #
 215         da=DataArrayInt64.New();
 216         da.alloc(8,1);
 217         da.setValues(vals2,8,1);
 218         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
 219         pass
 220
 221     def testDAIChangeSurjectiveFormat1(self):
 222         vals1=[0,3,2,3,2,2,1,2]
 223         expected1=[0,1,2,6,8]
 224         expected2=[0,  6,  2,4,5,7,  1,3]
 225         da=DataArrayInt64.New();
 226         da.setValues(vals1,8,1);
 227         #
 228         da2,da2I=da.changeSurjectiveFormat(4);
 229         self.assertEqual(5,da2I.getNumberOfTuples());
 230         self.assertEqual(8,da2.getNumberOfTuples());
 231         self.assertEqual(expected1,da2I.getValues());
 232         self.assertEqual(expected2,da2.getValues());
 233         #
 234         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
 235         #
 236         pass
 237
 238     def testDAIGetIdsNotEqual1(self):
 239         d=DataArrayInt64.New();
 240         vals1=[2,3,5,6,8,5,5,6,1,-5]
 241         d.setValues(vals1,10,1);
 242         d2=d.findIdsNotEqual(5);
 243         self.assertEqual(7,d2.getNumberOfTuples());
 244         self.assertEqual(1,d2.getNumberOfComponents());
 245         expected1=[0,1,3,4,7,8,9]
 246         for i in range(7):
 247             self.assertEqual(expected1[i],d2.getIJ(0,i));
 248             pass
 249         d.rearrange(2);
 250         self.assertRaises(InterpKernelException,d.findIdsNotEqual,5);
 251         vals2=[-4,5,6]
 252         vals3=vals2;
 253         d.rearrange(1);
 254         d3=d.findIdsNotEqualList(vals3);
 255         self.assertEqual(5,d3.getNumberOfTuples());
 256         self.assertEqual(1,d3.getNumberOfComponents());
 257         expected2=[0,1,4,8,9]
 258         for i in range(5):
 259             self.assertEqual(expected2[i],d3.getIJ(0,i));
 260             pass
 261         pass
 262
 263     def testDAIComputeOffsets1(self):
 264         d=DataArrayInt64.New();
 265         vals1=[3,5,1,2,0,8]
 266         expected1=[0,3,8,9,11,11]
 267         d.setValues(vals1,6,1);
 268         d.computeOffsets();
 269         self.assertEqual(6,d.getNumberOfTuples());
 270         self.assertEqual(1,d.getNumberOfComponents());
 271         for i in range(6):
 272             self.assertEqual(expected1[i],d.getIJ(0,i));
 273             pass
 274         pass
 275
 276     def testDAITransformWithIndArr1(self):
 277         if not MEDCouplingUse64BitIDs():
 278             return
 279         tab1=[17,18,22,19]
 280         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
 281         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
 282         d=DataArrayInt64.New();
 283         d.setValues(tab1,4,1);
 284         d1=DataArrayInt64.New();
 285         d1.setValues(tab2,12,1);
 286         d2=d1[:]
 287         #
 288         d1.transformWithIndArr(d);
 289         self.assertEqual(12,d1.getNumberOfTuples());
 290         self.assertEqual(1,d1.getNumberOfComponents());
 291         for i in range(12):
 292             self.assertEqual(expected[i],d1.getIJ(i,0));
 293             pass
 294         #
 295         d1=d2
 296         d1.transformWithIndArr(tab1)
 297         self.assertEqual(12,d1.getNumberOfTuples());
 298         self.assertEqual(1,d1.getNumberOfComponents());
 299         for i in range(12):
 300             self.assertEqual(expected[i],d1.getIJ(i,0));
 301             pass
 302         pass
 303
 304     def testDAIBuildPermArrPerLevel1(self):
 305         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
 306         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
 307         da=DataArrayInt64.New();
 308         da.setValues(arr,12,1);
 309         da2=da.buildPermArrPerLevel();
 310         self.assertEqual(12,da2.getNumberOfTuples());
 311         self.assertEqual(1,da2.getNumberOfComponents());
 312         for i in range(12):
 313             self.assertEqual(expected1[i],da2.getIJ(i,0));
 314             pass
 315         pass
 316
 317     def testDAIOperations1(self):
 318         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
 319         da=DataArrayInt64.New();
 320         da.setValues(arr1,4,3);
 321         da1=DataArrayInt64.New();
 322         da1.alloc(12,1);
 323         da1.iota(2);
 324         self.assertRaises(InterpKernelException,DataArrayInt64.Add,da,da1);#not same number of tuples/Components
 325         da1.rearrange(3);
 326         da2=DataArrayInt64.Add(da,da1);
 327         self.assertEqual(4,da2.getNumberOfTuples());
 328         self.assertEqual(3,da2.getNumberOfComponents());
 329         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
 330         for i in range(12):
 331             self.assertEqual(expected1[i],da2.getIJ(0,i));
 332             pass
 333         da1.substractEqual(da);
 334         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
 335         for i in range(12):
 336             self.assertEqual(expected2[i],da1.getIJ(0,i));
 337             pass
 338         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
 339         da1.addEqual(da);
 340         for i in range(12):
 341             self.assertEqual(expected1[i],da1.getIJ(0,i));
 342             pass
 343         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
 344         da2=DataArrayInt64.Multiply(da,da1);
 345         self.assertEqual(4,da2.getNumberOfTuples());
 346         self.assertEqual(3,da2.getNumberOfComponents());
 347         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
 348         for i in range(12):
 349             self.assertEqual(expected3[i],da2.getIJ(0,i));
 350             pass
 351         da.divideEqual(da1);
 352         self.assertEqual(4,da.getNumberOfTuples());
 353         self.assertEqual(3,da.getNumberOfComponents());
 354         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
 355         for i in range(12):
 356             self.assertEqual(expected4[i],da.getIJ(0,i));
 357             pass
 358         da.setValues(arr1,4,3);
 359         da1.multiplyEqual(da);
 360         self.assertEqual(4,da1.getNumberOfTuples());
 361         self.assertEqual(3,da1.getNumberOfComponents());
 362         for i in range(12):
 363             self.assertEqual(expected3[i],da1.getIJ(0,i));
 364             pass
 365         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
 366         da2=DataArrayInt64.Divide(da,da1);
 367         self.assertEqual(4,da2.getNumberOfTuples());
 368         self.assertEqual(3,da2.getNumberOfComponents());
 369         for i in range(12):
 370             self.assertEqual(expected4[i],da2.getIJ(0,i));
 371             pass
 372         da1.applyInv(321);
 373         self.assertEqual(4,da1.getNumberOfTuples());
 374         self.assertEqual(3,da1.getNumberOfComponents());
 375         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
 376         for i in range(12):
 377             self.assertEqual(expected5[i],da1.getIJ(0,i));
 378             pass
 379         da1.applyDivideBy(2);
 380         self.assertEqual(4,da1.getNumberOfTuples());
 381         self.assertEqual(3,da1.getNumberOfComponents());
 382         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
 383         for i in range(12):
 384             self.assertEqual(expected6[i],da1.getIJ(0,i));
 385             pass
 386         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
 387         da1.applyModulus(7);
 388         for i in range(12):
 389             self.assertEqual(expected7[i],da1.getIJ(0,i));
 390             pass
 391         da1.applyLin(1,1);
 392         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
 393         da1.applyRModulus(3);
 394         for i in range(12):
 395             self.assertEqual(expected8[i],da1.getIJ(0,i));
 396             pass
 397         pass
 398
 399     def testDAITransformWithIndArrR1(self):
 400         tab1=[2,4,5,3,6,7]
 401         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
 402         expected=[0,3,1,2,4,5]
 403         d=DataArrayInt64.New();
 404         d.setValues(tab1,6,1);
 405         d1=DataArrayInt64.New();
 406         d1.setValues(tab2,12,1);
 407         d2=d1[:]
 408         #
 409         d3=d.transformWithIndArrR(d1);
 410         self.assertEqual(6,d3.getNumberOfTuples());
 411         self.assertEqual(1,d3.getNumberOfComponents());
 412         for i in range(6):
 413             self.assertEqual(expected[i],d3.getIJ(i,0));
 414             pass
 415         #
 416         d1=d2
 417         d3=d.transformWithIndArrR(tab2)
 418         self.assertEqual(6,d3.getNumberOfTuples());
 419         self.assertEqual(1,d3.getNumberOfComponents());
 420         for i in range(6):
 421             self.assertEqual(expected[i],d3.getIJ(i,0));
 422             pass
 423         pass
 424
 425     def testDAISplitByValueRange1(self):
 426         val1=[6,5,0,3,2,7,8,1,4]
 427         val2=[0,4,9]
 428         d=DataArrayInt64.New();
 429         d.setValues(val1,9,1);
 430         e,f,g=d.splitByValueRange(val2);
 431         self.assertEqual(9,e.getNumberOfTuples());
 432         self.assertEqual(1,e.getNumberOfComponents());
 433         self.assertEqual(9,f.getNumberOfTuples());
 434         self.assertEqual(1,f.getNumberOfComponents());
 435         self.assertEqual(2,g.getNumberOfTuples());
 436         self.assertEqual(1,g.getNumberOfComponents());
 437         #
 438         expected1=[1,1,0,0,0,1,1,0,1]
 439         expected2=[2,1,0,3,2,3,4,1,0]
 440         for i in range(9):
 441             self.assertEqual(expected1[i],e.getIJ(i,0));
 442             self.assertEqual(expected2[i],f.getIJ(i,0));
 443             pass
 444         self.assertEqual(0,g.getIJ(0,0));
 445         self.assertEqual(1,g.getIJ(1,0));
 446         #
 447         d.setIJ(6,0,9);
 448         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
 449         # non regression test in python wrapping
 450         rg=DataArrayInt64([0,10,29,56,75,102,121,148,167,194,213,240,259,286,305,332,351,378,397,424,443,470,489,516])
 451         a,b,c=DataArrayInt64([75]).splitByValueRange(rg)
 452         self.assertTrue(a.isEqual(DataArrayInt64([4])))
 453         self.assertTrue(b.isEqual(DataArrayInt64([0])))
 454         self.assertTrue(c.isEqual(DataArrayInt64([4])))
 455         pass
 456
 457     def testDAIBuildExplicitArrByRanges1(self):
 458         d=DataArrayInt64.New();
 459         vals1=[0,2,3]
 460         d.setValues(vals1,3,1);
 461         e=DataArrayInt64.New();
 462         vals2=[0,3,6,10,14,20]
 463         e.setValues(vals2,6,1);
 464         #
 465         f=d.buildExplicitArrByRanges(e);
 466         self.assertEqual(11,f.getNumberOfTuples());
 467         self.assertEqual(1,f.getNumberOfComponents());
 468         expected1=[0,1,2,6,7,8,9,10,11,12,13]
 469         for i in range(11):
 470             self.assertEqual(expected1[i],f.getIJ(i,0));
 471             pass
 472         pass
 473
 474     def testDAIComputeOffsets2(self):
 475         d=DataArrayInt64.New();
 476         vals1=[3,5,1,2,0,8]
 477         expected1=[0,3,8,9,11,11,19]
 478         d.setValues(vals1,6,1);
 479         d.computeOffsetsFull();
 480         self.assertEqual(7,d.getNumberOfTuples());
 481         self.assertEqual(1,d.getNumberOfComponents());
 482         for i in range(7):
 483             self.assertEqual(expected1[i],d.getIJ(0,i));
 484             pass
 485         pass
 486
 487     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
 488         arr=[0,3, 5,7,9]
 489         arrI=[0,2,5]
 490         a=DataArrayInt.New();
 491         a.setValues(arr,5,1);
 492         b=DataArrayInt.New();
 493         b.setValues(arrI,3,1);
 494         ret,newNbTuple=DataArrayInt64.ConvertIndexArrayToO2N(10,a,b);
 495         expected=[0,1,2,0,3,4,5,4,6,4]
 496         self.assertEqual(10,ret.getNbOfElems());
 497         self.assertEqual(7,newNbTuple);
 498         self.assertEqual(1,ret.getNumberOfComponents());
 499         self.assertEqual(expected,ret.getValues());
 500         self.assertRaises(InterpKernelException,DataArrayInt64.ConvertIndexArrayToO2N,9,a,b);
 501         pass
 502
 503     def testDAIBuildUnique1(self):
 504         d=DataArrayInt64([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
 505         e=d.buildUnique()
 506         self.assertTrue(e.isEqual(DataArrayInt64([1,2,3,4,5,7,19])))
 507         pass
 508
 509     def testDAIPartitionByDifferentValues1(self):
 510         d=DataArrayInt64([1,0,1,2,0,2,2,-3,2])
 511         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
 512         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
 513             self.assertEqual(expected[i][0],elt[1])
 514             self.assertEqual(expected[i][1],elt[0].getValues())
 515             pass
 516         pass
 517
 518     def testDAICheckMonotonic1(self):
 519         data1=[-1,0,2,2,4,5]
 520         data2=[6,2,0,-8,-9,-56]
 521         data3=[-1,0,3,2,4,6]
 522         data4=[7,5,2,3,0,-6]
 523         d=DataArrayInt64.New(data1);
 524         self.assertTrue(d.isMonotonic(True));
 525         self.assertTrue(not d.isMonotonic(False));
 526         d.checkMonotonic(True);
 527         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
 528         d=DataArrayInt64.New(data2);
 529         self.assertTrue(d.isMonotonic(False));
 530         self.assertTrue(not d.isMonotonic(True));
 531         d.checkMonotonic(False);
 532         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
 533         d=DataArrayInt64.New(data3);
 534         self.assertTrue(not d.isMonotonic(False));
 535         self.assertTrue(not d.isMonotonic(True));
 536         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
 537         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
 538         d=DataArrayInt64.New(data4);
 539         self.assertTrue(not d.isMonotonic(False));
 540         self.assertTrue(not d.isMonotonic(True));
 541         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
 542         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
 543         d=DataArrayInt64.New(0,1)
 544         self.assertTrue(d.isMonotonic(True));
 545         self.assertTrue(d.isMonotonic(False));
 546         d.checkMonotonic(True);
 547         d.checkMonotonic(False);
 548         d=DataArrayInt64.New(data4,3,2);#throw because nbComp!=1
 549         self.assertRaises(InterpKernelException,d.isMonotonic,True)
 550         self.assertRaises(InterpKernelException,d.isMonotonic,False)
 551         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
 552         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
 553         pass
 554
 555     def testDAIBuildSubstractionOptimized1(self):
 556         da1=DataArrayInt64.New([1,3,5,6,7,9,13])
 557         da2=DataArrayInt64.New([3,5,9])
 558         da3=DataArrayInt64.New([1,3,5])
 559         da4=DataArrayInt64.New([1,3,5,6,7,9,13])
 560         #
 561         a=da1.buildSubstractionOptimized(da2);
 562         self.assertTrue(a.isEqual(DataArrayInt64([1,6,7,13])));
 563         #
 564         a=da1.buildSubstractionOptimized(da3);
 565         self.assertTrue(a.isEqual(DataArrayInt64([6,7,9,13])));
 566         #
 567         a=da1.buildSubstractionOptimized(da4);
 568         self.assertTrue(a.isEqual(DataArrayInt64([])));
 569         pass
 570
 571     def testDAIIsStrictlyMonotonic1(self):
 572         da1=DataArrayInt64.New([1,3,5,6,7,9,13])
 573         self.assertTrue(da1.isStrictlyMonotonic(True));
 574         da1.checkStrictlyMonotonic(True);
 575         self.assertTrue(da1.isMonotonic(True));
 576         da1.checkMonotonic(True);
 577         self.assertTrue(not da1.isStrictlyMonotonic(False));
 578         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
 579         self.assertTrue(not da1.isMonotonic(False));
 580         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
 581         #
 582         da1=DataArrayInt64.New([1,3,5,6,6,9,13])
 583         self.assertTrue(not da1.isStrictlyMonotonic(True));
 584         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
 585         self.assertTrue(da1.isMonotonic(True));
 586         da1.checkMonotonic(True);
 587         self.assertTrue(not da1.isStrictlyMonotonic(False));
 588         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
 589         self.assertTrue(not da1.isMonotonic(False));
 590         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
 591         #
 592         da1=DataArrayInt64.New([1,3,5,6,5,9,13])
 593         self.assertTrue(not da1.isStrictlyMonotonic(True));
 594         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
 595         self.assertTrue(not da1.isMonotonic(True));
 596         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
 597         self.assertTrue(not da1.isStrictlyMonotonic(False));
 598         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
 599         self.assertTrue(not da1.isMonotonic(False));
 600         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
 601         #
 602         da1=DataArrayInt64.New([13,9,7,6,5,3,1])
 603         self.assertTrue(not da1.isStrictlyMonotonic(True));
 604         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
 605         self.assertTrue(not da1.isMonotonic(True));
 606         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
 607         self.assertTrue(da1.isStrictlyMonotonic(False));
 608         da1.checkStrictlyMonotonic(False);
 609         self.assertTrue(da1.isMonotonic(False));
 610         da1.checkMonotonic(False);
 611         #
 612         da1=DataArrayInt64.New([13,9,6,6,5,3,1])
 613         self.assertTrue(not da1.isStrictlyMonotonic(True));
 614         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
 615         self.assertTrue(not da1.isMonotonic(True));
 616         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
 617         self.assertTrue(not da1.isStrictlyMonotonic(False));
 618         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
 619         self.assertTrue(da1.isMonotonic(False));
 620         da1.checkMonotonic(False);
 621         #
 622         da1=DataArrayInt64.New([13,9,5,6,5,3,1])
 623         self.assertTrue(not da1.isStrictlyMonotonic(True));
 624         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
 625         self.assertTrue(not da1.isMonotonic(True));
 626         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
 627         self.assertTrue(not da1.isStrictlyMonotonic(False));
 628         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
 629         self.assertTrue(not da1.isMonotonic(False));
 630         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
 631         #
 632         da1=DataArrayInt64.New([])
 633         self.assertTrue(da1.isStrictlyMonotonic(True));
 634         da1.checkStrictlyMonotonic(True);
 635         self.assertTrue(da1.isMonotonic(True));
 636         da1.checkMonotonic(True);
 637         self.assertTrue(da1.isStrictlyMonotonic(False));
 638         da1.checkStrictlyMonotonic(False);
 639         self.assertTrue(da1.isMonotonic(False));
 640         da1.checkMonotonic(False);
 641         #
 642         da1=DataArrayInt64.New([13])
 643         self.assertTrue(da1.isStrictlyMonotonic(True));
 644         da1.checkStrictlyMonotonic(True);
 645         self.assertTrue(da1.isMonotonic(True));
 646         da1.checkMonotonic(True);
 647         self.assertTrue(da1.isStrictlyMonotonic(False));
 648         da1.checkStrictlyMonotonic(False);
 649         self.assertTrue(da1.isMonotonic(False));
 650         da1.checkMonotonic(False);
 651         pass
 652
 653     def testDAIIndicesOfSubPart(self):
 654         a=DataArrayInt64([9,10,0,6,4,11,3,8])
 655         b=DataArrayInt64([6,0,11,8])
 656         c=a.indicesOfSubPart(b)
 657         self.assertTrue(c.isEqual(DataArrayInt([3,2,5,7])))
 658         #
 659         d=DataArrayInt64([9,10,0,6,4,11,0,8])
 660         self.assertRaises(InterpKernelException,d.indicesOfSubPart,b) # 0 appears twice in the d array
 661         f=DataArrayInt64([6,0,11,8,12])
 662         self.assertRaises(InterpKernelException,a.indicesOfSubPart,f) # 12 in f does not exist in a
 663         pass
 664
 665     def testDAIsortToHaveConsecutivePairs(self):
 666         dref=DataArrayInt64([(6, 216), (216, 218), (218, 220), (220, 222), (222, 224), (224, 226)])
 667         dtest=DataArrayInt64([(6, 216), (218, 216), (224, 226), (222, 220), (218, 220), (222, 224)])
 668         dtest.sortToHaveConsecutivePairs()
 669         self.assertTrue(dtest.isEqual(dref))
 670
 671     def testDAIFromLinkedListOfPairToList1(self):
 672         d=DataArrayInt64([(5,7),(7,3),(3,12),(12,17)])
 673         zeRes=DataArrayInt64([5,7,3,12,17])
 674         self.assertTrue(d.fromLinkedListOfPairToList().isEqual(zeRes))
 675         d.rearrange(1)
 676         self.assertRaises(InterpKernelException,d.fromLinkedListOfPairToList)
 677         d.rearrange(2)
 678         self.assertTrue(d.fromLinkedListOfPairToList().isEqual(zeRes))
 679         d2=DataArrayInt64([(5,7)])
 680         self.assertTrue(d2.fromLinkedListOfPairToList().isEqual(DataArrayInt64([5,7])))
 681         d3=DataArrayInt64([(5,7),(7,3),(4,12),(12,17)])
 682         self.assertRaises(InterpKernelException,d3.fromLinkedListOfPairToList) # not a linked list of pair
 683         d4=DataArrayInt64([(5,7),(7,3),(12,3),(12,17)])
 684         self.assertRaises(InterpKernelException,d4.fromLinkedListOfPairToList) # not a linked list of pair, but can be repaired !
 685         d4.sortEachPairToMakeALinkedList()
 686         self.assertTrue(d4.fromLinkedListOfPairToList().isEqual(zeRes))
 687         pass
 688
 689     def testDAIfindIdsExt1(self):
 690         d=DataArrayInt64([4,6,-2,3,7,0,10])
 691         self.assertTrue(d.findIdsGreaterOrEqualTo(3).isEqual(DataArrayInt([0,1,3,4,6])))
 692         self.assertTrue(d.findIdsGreaterThan(3).isEqual(DataArrayInt([0,1,4,6])))
 693         self.assertTrue(d.findIdsLowerThan(3).isEqual(DataArrayInt([2,5])))
 694         self.assertTrue(d.findIdsLowerOrEqualTo(3).isEqual(DataArrayInt([2,3,5])))
 695         pass
 696
 697     def testDAICheckUniformAndGuess1(self):
 698         d=DataArrayInt64([3,3],1,2)
 699         self.assertRaises(InterpKernelException,d.checkUniformAndGuess)# non single compo
 700         d=DataArrayInt64([])
 701         self.assertRaises(InterpKernelException,d.checkUniformAndGuess)# empty
 702         d=DataArrayInt64()
 703         self.assertRaises(InterpKernelException,d.checkUniformAndGuess)# non allocated
 704         d=DataArrayInt64([3,3,3])
 705         self.assertEqual(3,d.checkUniformAndGuess())
 706         d=DataArrayInt64([7])
 707         self.assertEqual(7,d.checkUniformAndGuess())
 708         d=DataArrayInt64([3,4,3])
 709         self.assertRaises(InterpKernelException,d.checkUniformAndGuess)# non uniform
 710         pass
 711
 712     def testDAIFindIdForEach1(self):
 713         a1=DataArrayInt64([17,27,2,10,-4,3,12,27,16])
 714         b1=DataArrayInt64([3,16,-4,27,17])
 715         ret=a1.findIdForEach(b1)
 716         self.assertTrue(ret.isEqual(DataArrayInt([5,8,4,7,0])))
 717         self.assertTrue(a1[ret].isEqual(b1))
 718         b2=DataArrayInt64([3,16,22,27,17])
 719         self.assertRaises(InterpKernelException,a1.findIdForEach,b2) # 22 not in a1 !
 720         a1.rearrange(3)
 721         self.assertRaises(InterpKernelException,a1.findIdForEach,b1) # a1 is not single component
 722         pass
 723
 724     def testGlobalHelpers(self):
 725         arr0 = vtk2med_cell_types()
 726         self.assertEqual(len(arr0),43)
 727         arr1 = med2vtk_cell_types()
 728         self.assertEqual(len(arr1),34)
 729         arr2 = AllGeometricTypes()
 730         self.assertEqual(len(arr2),25)
 731         for elt in arr2:
 732             MEDCouplingUMesh.GetReprOfGeometricType(elt)
 733             self.assertNotEqual(MEDCouplingUMesh.GetDimensionOfGeometricType(elt),-1)
 734         pass
 735
 736     def testVoronoi2D_3(self):
 737         """
 738         Non regression test for EDF20418 : After 8.5.0 MEDCouplingUMesh.Interset2DMeshes method (called by voronoize) is sensible to cell orientation of 2 input meshes. This test check correct behavior in
 739         case of non standard orientation input cell.
 740         """
 741         coo = DataArrayDouble([0.018036113896685007,0.030867224641316506,0.019000000000000003,0.030833333333333407,0.018518056948342503,0.030850278987324904,0.018773068345659904,0.031180320157635305,0.018546136691319805,0.031527306981937307,0.018291125294002404,0.031197265811626906],6,2)
 742         m = MEDCouplingUMesh("mesh",2)
 743         m.setCoords(coo)
 744         m.allocateCells()
 745         m.insertNextCell(NORM_TRI3,[0,1,4])
 746         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
 747         f.setMesh(m)
 748         f.setArray(DataArrayDouble([12613576.708019681, 18945164.734307285, 22385248.637775388, 17074219.938821714, 19361929.467164982, 19258841.562907547]))
 749         f.setGaussLocalizationOnType(NORM_TRI3,[0, 0, 1, 0, 0, 1],[0.0915762, 0.0915762, 0.816848, 0.0915762, 0.0915762, 0.816848, 0.445948, 0.108103, 0.445948, 0.445948, 0.108103, 0.445948],[0.0549759, 0.0549759, 0.0549759, 0.111691, 0.111691, 0.111691])
 750         f.setName("field")
 751         f_voro = f.voronoize(1e-13)
 752         ref_area = DataArrayDouble([4.6679303278867127, 4.2514546761810138, 4.2514546761809337, 6.6206415950989804, 6.2643538685231039, 6.6206415950989884])
 753         area = f_voro.buildMeasureField(True).getArray()*1e8
 754         self.assertTrue(ref_area.isEqual(area,1e-6))
 755         ref_bary = DataArrayDouble([(0.018231625096313969, 0.030950287685553721), (0.018826045778781105, 0.030916927013719033), (0.018533397739746087, 0.031364396601025746), (0.018541498169815956, 0.030944333493252929), (0.018660195622447071, 0.031132366117047686), (0.018400646702087166, 0.031159700554391174)])
 756         bary = f_voro.getMesh().computeCellCenterOfMass()
 757         self.assertTrue(ref_bary.isEqual(bary,1e-8))
 758         self.assertTrue(f_voro.getArray().isEqual(f.getArray(),1e-8))
 759         pass
 760
 761     def testDAIOccurenceRankInThis(self):
 762         arr=DataArrayInt([5,3,2,1,4,5,2,1,0,11,5,4])
 763         self.assertTrue(arr.occurenceRankInThis().isEqual(DataArrayInt([0,0,0,0,0,1,1,1,0,0,2,1])))
 764
 765     def testDAIFindPermutationFromFirstToSecondDuplicate(self):
 766         arr0 = DataArrayInt([5,3,2,1,4,5,2,1,0,11,5,4])
 767         arr1 = DataArrayInt([0,1,1,2,2,3,4,4,5,5,5,11])
 768         self.assertTrue(DataArrayInt.FindPermutationFromFirstToSecondDuplicate(arr0,arr1).isEqual(DataArrayInt([8,5,3,1,6,9,4,2,0,11,10,7])))
 769         self.assertTrue(DataArrayInt.FindPermutationFromFirstToSecondDuplicate(arr1,arr0).isEqual(DataArrayInt([8,3,7,2,6,1,4,11,0,5,10,9])))
 770
 771     def testDAIIndexOfSameConsecutiveValueGroups(self):
 772         arr = DataArrayInt([0,1,1,2,2,3,4,4,5,5,5,11])
 773         self.assertTrue(arr.indexOfSameConsecutiveValueGroups().isEqual(DataArrayInt([0,1,3,5,6,8,11,12])))
 774
 775     def testSkyLineGroupPacks(self):
 776         arr = DataArrayInt([1,4,5,0,2,4,5,6,1,3,5,6,7,2,6,7,0,1,5,8,9,0,1,2,4,6,8,9,10,1,2,3,5,7,9,10,11,2,3,6,10,11,4,5,9,12,13,4,5,6,8,10,12,13,14,5,6,7,9,11,13,14,15,6,7,10,14,15,8,9,13,8,9,10,12,14,9,10,11,13,15,10,11,14])
 777         arrI = DataArrayInt([0,3,8,13,16,21,29,37,42,47,55,63,68,71,76,81,84])
 778         sk = MEDCouplingSkyLineArray(arrI,arr)
 779         part = DataArrayInt([0,3,4,7,16])
 780         sk2 = sk.groupPacks(part)
 781         self.assertTrue(sk2.getValuesArray().isEqual(arr))
 782         self.assertTrue(sk2.getIndexArray().isEqual(DataArrayInt([0,13,16,37,84])))
 783
 784     def testSkyLineUniqueNotSortedByPack(self):
 785         arrI = DataArrayInt([0,3,9,15,18,24,36,48,54])
 786         arr = DataArrayInt([1,4,5,0,4,5,2,5,6,3,6,7,1,5,6,2,6,7,0,1,5,5,8,9,0,1,4,6,9,10,1,2,4,6,8,9,2,3,5,7,9,10,1,2,5,7,10,11,2,3,6,6,10,11])
 787         sk = MEDCouplingSkyLineArray(arrI,arr)
 788         sk2 = sk.uniqueNotSortedByPack()
 789         self.assertTrue(sk2.getIndexArray().isEqual(DataArrayInt([0,3,8,13,16,21,29,37,42])))
 790         self.assertTrue(sk2.getValuesArray().isEqual(DataArrayInt([1,4,5,0,2,4,5,6,1,3,5,6,7,2,6,7,0,1,5,8,9,0,1,2,4,6,8,9,10,1,2,3,5,7,9,10,11,2,3,6,10,11])))
 791
 792     def testSkyLineAggregatePacks1(self):
 793         arr = DataArrayDouble(3) ; arr.iota()
 794         m = MEDCouplingCMesh() ; m.setCoords(arr,arr) ; m = m.buildUnstructured()
 795         a,b = m.computeEnlargedNeighborsOfNodes()
 796         sk = MEDCouplingSkyLineArray(b,a)
 797         sk1 = sk.deepCopy()
 798         sk1.getValuesArray()[:] *= 2
 799         sk2 = sk.deepCopy()
 800         sk2.getValuesArray()[:] *= 3
 801         skOut = MEDCouplingSkyLineArray.AggregatePacks([sk,sk1,sk2])
 802         self.assertTrue(skOut.getIndexArray().isEqual(DataArrayInt([0,9,24,33,48,72,87,96,111,120])))
 803         self.assertTrue(skOut.getValuesArray().isEqual(DataArrayInt([1,3,4,2,6,8,3,9,12,0,2,3,4,5,0,4,6,8,10,0,6,9,12,15,1,4,5,2,8,10,3,12,15,0,1,4,6,7,0,2,8,12,14,0,3,12,18,21,0,1,2,3,5,6,7,8,0,2,4,6,10,12,14,16,0,3,6,9,15,18,21,24,1,2,4,7,8,2,4,8,14,16,3,6,12,21,24,3,4,7,6,8,14,9,12,21,3,4,5,6,8,6,8,10,12,16,9,12,15,18,24,4,5,7,8,10,14,12,15,21])))
 804
 805     def testDACopySorted1(self):
 806         d = DataArrayInt32([5,1,100,20])
 807         self.assertTrue(d.copySorted().isEqual(DataArrayInt32([1,5,20,100])))
 808         d = DataArrayInt64([5,1,100,20])
 809         self.assertTrue(d.copySorted().isEqual(DataArrayInt64([1,5,20,100])))
 810         d = DataArrayInt([5,1,100,20])
 811         self.assertTrue(d.copySorted().isEqual(DataArrayInt([1,5,20,100])))
 812         d = DataArrayDouble([5,1,100,20])
 813         self.assertTrue(d.copySorted().isEqual(DataArrayDouble([1,5,20,100]),1e-10))
 814
 815     def testFieldAreStrictlyCompatible(self):
 816         arr=DataArrayDouble(10) ; arr.iota()
 817         m=MEDCouplingCMesh() ; m.setCoords(arr,arr) ; m=m.buildUnstructured()
 818         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m)
 819         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setMesh(m)
 820         self.assertTrue(f.areStrictlyCompatible(f2))
 821         self.assertTrue(f.areStrictlyCompatibleForMulDiv(f2))
 822         f2.setMesh(f2.getMesh().deepCopy())
 823         self.assertTrue(not f.areStrictlyCompatible(f2))
 824         self.assertTrue(not f.areStrictlyCompatibleForMulDiv(f2))
 825         f3=MEDCouplingFieldDouble(ON_NODES) ; f3.setMesh(m)
 826         self.assertTrue(not f.areStrictlyCompatible(f3))
 827         self.assertTrue(not f.areStrictlyCompatibleForMulDiv(f3))
 828
 829     def testBugZipConnectivityTraducer(self):
 830         """
 831         Non regression test : here cell #1 and cell #2 are nearly the same but not the same. zipConnectivityTraducer called by areCellsIncludedIn
 832         failed to capture that.
 833         """
 834         coo = DataArrayDouble([0,1,2,3],4,1)
 835         m = MEDCouplingUMesh("",1)
 836         m.setCoords(coo)
 837         m.allocateCells()
 838         m.insertNextCell(NORM_SEG2,[0,1])
 839         m.insertNextCell(NORM_SEG2,[1,2])
 840         m.insertNextCell(NORM_SEG2,[2,1])
 841         #
 842         a,b = m.areCellsIncludedIn(m,0)
 843         self.assertTrue(a)
 844         self.assertTrue(b.isIota(3))
 845         #
 846         self.assertTrue(m.deepCopy().zipConnectivityTraducer(0).isIota(3))
 847         self.assertTrue(m.deepCopy().zipConnectivityTraducer(1).isIota(3))
 848         self.assertTrue(m.deepCopy().zipConnectivityTraducer(2).isEqual(DataArrayInt([0,1,1])))
 849
 850     def testBugAreCellsIncludedIn1(self):
 851         """
 852         Non regression test: a.areCellsIncludedIn(b) was buggy when some cells in b were duplicated into a following specified policy.
 853         """
 854         coo = DataArrayDouble([0,1,2,3,4],5,1)
 855         m = MEDCouplingUMesh("",1)
 856         m.setCoords(coo)
 857         m.allocateCells()
 858         # m contains several duplicated cells - some of those duplicated cells will be in m1
 859         for i in range(3):
 860             m.insertNextCell(NORM_SEG2,[0,1])
 861         for i in range(4):
 862             m.insertNextCell(NORM_SEG2,[1,2])
 863         for i in range(2):
 864             m.insertNextCell(NORM_SEG2,[2,3])
 865         for i in range(2):
 866             m.insertNextCell(NORM_SEG2,[3,4])
 867         #
 868         bexp = DataArrayInt([0,1,2, 3,4,5,6, 9,10])
 869         m1 = m[bexp]
 870         #
 871         a,b = m.areCellsIncludedIn(m1,0)
 872         self.assertTrue(a)
 873         self.assertTrue(b.isEqual(DataArrayInt([2,2,2, 6,6,6,6, 10,10])))
 874         #
 875         bexp2 = DataArrayInt([0,1,2, 3,4,0, 6, 9,10])
 876         m2 = m[bexp2]
 877         a,b = m.areCellsIncludedIn(m2,0)
 878         self.assertTrue(a)
 879         self.assertTrue(b.isEqual(DataArrayInt([2,2,2,6,6,2,6,10,10])))
 880
 881     def testSkyLineArrayThreshold(self):
 882         x = DataArrayInt([0, 1, 2, 11, 12, 13, 3, 4, 5, 6, 14, 15, 16, 17, 9, 10, 18, 19])
 883         xi = DataArrayInt([0, 6, 14, 18])
 884         sk = MEDCouplingSkyLineArray(xi,x)
 885         lsk,rsk = sk.thresholdPerPack(11)
 886         self.assertTrue(lsk.getValuesArray().isEqual(DataArrayInt([0, 1, 2, 3, 4, 5, 6, 9, 10])))
 887         self.assertTrue(lsk.getIndexArray().isEqual(DataArrayInt([0, 3, 7, 9])))
 888         self.assertTrue(rsk.getValuesArray().isEqual(DataArrayInt([11, 12, 13, 14, 15, 16, 17, 18, 19])))
 889         self.assertTrue(rsk.getIndexArray().isEqual(DataArrayInt([0, 3, 7, 9])))
 890
 891     def testPenta18GaussNE(self):
 892         conn = [1,0,2,4,3,5,6,7,8,9,13,14,11,10,15,12,17,16]
 893         coo = DataArrayDouble([(27.237499999999997, 9.8, 0.0), (26.974999999999994, 9.8, 0.0), (27.111517409545634, 9.532083869948877, 0.0), (27.237499999999997, 9.8, 0.5000000000000001), (26.974999999999994, 9.8, 0.5000000000000002), (27.111517409545634, 9.532083869948877, 0.5), (27.106249999999996, 9.8, 0.0), (27.17450870477282, 9.666041934974439, 0.0), (27.04325870477281, 9.666041934974439, 0.0), (27.106249999999996, 9.8, 0.5000000000000001), (27.237499999999997, 9.8, 0.25), (26.974999999999994, 9.8, 0.2500000000000001), (27.106249999999996, 9.8, 0.2500000000000001), (27.174508704772816, 9.666041934974439, 0.5), (27.043258704772814, 9.666041934974439, 0.5000000000000001), (27.111517409545634, 9.532083869948877, 0.25), (27.043258704772818, 9.666041934974436, 0.25000000000000006), (27.174508704772816, 9.666041934974436, 0.25)])
 894         m = MEDCouplingUMesh("mesh",3)
 895         m.setCoords(coo)
 896         m.allocateCells()
 897         m.insertNextCell(NORM_PENTA18,conn)
 898         f = MEDCouplingFieldDouble(ON_GAUSS_NE)
 899         f.setMesh(m)
 900         f.setArray(DataArrayDouble(18*[0.]))
 901         self.assertTrue(f.getLocalizationOfDiscr().isEqual(coo[conn],1e-10))
 902
 903     def testDADEigenValuesPb(self):
 904         """EDF22126 : eigen values with Identity matrix returned nan. Now it returns correct eigen values 1.0 """
 905         valuesExp = DataArrayDouble([(1.,1.,1.),(2.,-1.,0.),(2.,0.,1.),(3.,0.,0.)])
 906         d = DataArrayDouble(4, 6)
 907         for i,(v0, v1, v2, v3, v4, v5,) in enumerate([
 908                 (1, 1, 1, 0, 0, 0),
 909                 (1, 0, 0, 1, 0, 1),
 910                 (1, 1, 1, 0, 1, 0),
 911                 (1, 1, 1, 1, 1, 1)]):
 912             d[i] = [v0, v1, v2, v3, v4, v5]
 913         self.assertTrue(d.eigenValues().isEqual(valuesExp,1e-12))
 914         pass
 915
 916     def testBugOnReprOf1SGTUMesh(self):
 917         """ Non reg bug on repr of empty MEDCoupling1SGTUMesh instance """
 918         m = MEDCoupling1SGTUMesh()
 919         m.simpleRepr()
 920         str(m)
 921         m.advancedRepr()
 922         repr(m)
 923         m = MEDCoupling1DGTUMesh()
 924         m.simpleRepr()
 925         str(m)
 926         m.advancedRepr()
 927         repr(m)
 928
 929     def testCheckGeomConsistency0(self):
 930         """Test of MEDCouplingUMesh.checkGeomConsistency"""
 931         m = MEDCouplingUMesh("",2)
 932         m.setCoords(DataArrayDouble([(0,0),(1,0),(2,0),(0,1),(1,1),(2,1)]))
 933         m.allocateCells()
 934         m.insertNextCell(NORM_TRI6,[0,1,2,3,4,5])
 935         m.insertNextCell(NORM_TRI6,[0,1,3,3,4,5])
 936         m.checkConsistency()
 937         self.assertRaises(InterpKernelException,m.checkGeomConsistency) # cell1 is incorrect because node 3 is repeated twice
 938         m.getNodalConnectivity()[10]=2 # replace 3 by 2 for cell#1 to fix the problem
 939         m.checkConsistency()
 940         m.checkGeomConsistency() # now m is OK
 941
 942     def testInt32Int64Arr0(self):
 943         n = 30
 944         arr = DataArrayInt32(n)
 945         arr.iota() ; arr.rearrange(3)
 946         comps = ["a","bb","ccc"]
 947         name = "aaa"
 948         arr.setName(name) ; arr.setInfoOnComponents(comps)
 949         self.assertEqual(arr.accumulate(),[135, 145, 155])
 950         arr2 = arr.convertToInt64Arr() # test is here
 951         self.assertEqual(arr2.accumulate(),[135, 145, 155])
 952         self.assertTrue(isinstance(arr2,DataArrayInt64))
 953         self.assertEqual(arr2.getName(),name)
 954         self.assertEqual(arr2.getInfoOnComponents(),comps)
 955         arr3 = arr2.convertToInt32Arr() # test is here
 956         self.assertEqual(arr3.accumulate(),[135, 145, 155])
 957         self.assertTrue(isinstance(arr3,DataArrayInt32))
 958         self.assertEqual(arr3.getName(),name)
 959         self.assertEqual(arr3.getInfoOnComponents(),comps)
 960         self.assertTrue(arr3.isEqual(arr))
 961
 962     def testComputeMeshCenterOfMass0(self):
 963         #2D
 964         arr = DataArrayDouble(5) ; arr.iota()
 965         m = MEDCouplingCMesh() ; m.setCoords(arr,arr) ; m=m.buildUnstructured()
 966         self.assertTrue( m.computeMeshCenterOfMass().isEqual(DataArrayDouble([2,2],1,2),1e-12) )
 967         #3D
 968         m = MEDCouplingCMesh() ; m.setCoords(arr,arr,arr) ; m=m.buildUnstructured()
 969         self.assertTrue( m.computeMeshCenterOfMass().isEqual(DataArrayDouble([2,2,2],1,3),1e-12) )
 970
 971     def testBugPenta15_0(self):
 972         """
 973         Non regression test from Roberto Da Via pointing error in connectivity of 5th sub face of penta15 cell.
 974         """
 975         coo=DataArrayDouble([
 976             (0,1,1),(0,0,1),(1,0,1),
 977             (0,1,0),(0,0,0),(1,0,0),
 978             (0,0.5,1),(0.5,0,1),(0.5,0.5,1),
 979             (0,0.5,0),(0.5,0,0),(0.5,0.5,0),
 980             (0,1,0.5),(0,0,0.5),(1,0,0.5)
 981         ])
 982
 983         m = MEDCouplingUMesh("penta15",3)
 984         m.setCoords(coo)
 985         m.allocateCells()
 986         m.insertNextCell(NORM_PENTA15,list(range(15)))
 987         bm = m.buildBoundaryMesh(True)
 988         bm.writeVTK("boundary.vtu")
 989         conn_expected = [
 990             [6, 0, 1, 2, 6, 7, 8],
 991             [6, 3, 5, 4, 11, 10, 9],
 992             [8, 0, 3, 4, 1, 12, 9, 13, 6],
 993             [8, 1, 4, 5, 2, 13, 10, 14, 7],
 994             [8, 2, 5, 3, 0, 14, 11, 12, 8] # old = [8, 2, 4, 5, 0, 14, 11, 12, 8]
 995         ]
 996         self.assertTrue( bm.getNodalConnectivity().isEqual(DataArrayInt(sum(conn_expected,[]))) )
 997
 998     def testBugWithPolyhedInterpWithMoreThan255Nodes(self):
 999         """
1000         [EDF25207] : Check interpolation containing polyhedron with more than 255 nodes is OK at bbox computation stage
1001         """
1002         n = 8
1003         arr = DataArrayDouble(n) ; arr.iota()
1004         m = MEDCouplingCMesh()
1005         m.setCoords(arr,arr,arr)
1006         m = m.buildUnstructured()
1007         skin = m.computeSkin()
1008         skin.zipCoords()
1009         # check that skin contains more than 2**8-1 node to reveal bug
1010         self.assertTrue(skin.getNumberOfNodes()>255)
1011         # Build a single polyhedron cell from skin
1012         skin1 = MEDCoupling1SGTUMesh(skin)
1013         conn = skin1.getNodalConnectivity()
1014         conn.rearrange( MEDCouplingUMesh.GetNumberOfNodesOfGeometricType(skin1.getCellModelEnum()) )
1015         connPolyhed = conn.changeNbOfComponents(MEDCouplingUMesh.GetNumberOfNodesOfGeometricType(skin1.getCellModelEnum())+1,-1)
1016         connPolyhed.rearrange(1)
1017         connPolyhed.popBackSilent()
1018         meshSinglePolyhed = MEDCouplingUMesh("",3)
1019         meshSinglePolyhed.allocateCells()
1020         meshSinglePolyhed.insertNextCell(NORM_POLYHED,connPolyhed.getValues())
1021         meshSinglePolyhed.setCoords( skin1.getCoords() )
1022
1023         rem = MEDCouplingRemapper()
1024         rem.prepare(meshSinglePolyhed,m,"P0P0")
1025         res = rem.getCrudeMatrix()
1026         self.assertTrue( all([len(elt)==1 for elt in res]) )
1027         self.assertTrue( all([elt[0]>0.99 and elt[0]<1.01 for elt in res]) )
1028
1029     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
1030     def testShapeFuncAndDerivative0(self):
1031         """
1032         Test values returned by MEDCoupling on HEXA27 element of shape function and its derivatives.
1033         See https://www.code-aster.org/V2/doc/v10/fr/man_r/r3/r3.01.01.pdf
1034         """
1035         import numpy as np
1036
1037         ref_coords_hexa27_med = [[-1.0, -1.0, -1.0], [-1.0, 1.0, -1.0], [1.0, 1.0, -1.0], [1.0, -1.0, -1.0], [-1.0, -1.0, 1.0], [-1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, -1.0, 1.0], [-1.0, 0.0, -1.0], [0.0, 1.0, -1.0], [1.0, 0.0, -1.0], [0.0, -1.0, -1.0], [-1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [1.0, 0.0, 1.0], [0.0, -1.0, 1.0], [-1.0, -1.0, 0.0], [-1.0, 1.0, 0.0], [1.0, 1.0, 0.0], [1.0, -1.0, 0.0], [0.0, 0.0, -1.0], [-1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, 0.0]]
1038
1039         def coor2index(coor):
1040             zeMap = {-1.0 : 0, 0.0 : 2 , 1.0 : 1}
1041             return zeMap[coor]
1042
1043         vcoor2index = np.vectorize( coor2index )
1044         node2ijk_hexa27_med = vcoor2index( np.array(ref_coords_hexa27_med) )
1045
1046         def N_1d_quad(x):
1047             return np.array([-0.5*x*(1-x), 0.5*x*(x+1), 1.-x*x])
1048
1049         def N_3d_hexa27(x, i, j, k):
1050             return N_1d_quad(x[0])[i]*N_1d_quad(x[1])[j]*N_1d_quad(x[2])[k]
1051
1052         def N_hexa27(x):
1053             return np.array([N_3d_hexa27(x, *node2ijk_hexa27_med[node,:]) for node in range(27)])
1054
1055         # Implementing shape function derivatives
1056         def diff_N_1d_quad(x):
1057             return np.array([x-0.5, x+0.5, -2.*x])
1058
1059         def diff_N_3d_hexa27(x, i, j, k):
1060             return np.array([diff_N_1d_quad(x[0])[i]*N_1d_quad(x[1])[j]     *N_1d_quad(x[2])[k],
1061                             N_1d_quad(x[0])[i]     *diff_N_1d_quad(x[1])[j]*N_1d_quad(x[2])[k],
1062                             N_1d_quad(x[0])[i]     *N_1d_quad(x[1])[j]     *diff_N_1d_quad(x[2])[k]])
1063
1064         def diff_N_hexa27(x):
1065             return np.array([diff_N_3d_hexa27(x, *node2ijk_hexa27_med[node,:]) for node in range(27)])
1066         # computation of ref values
1067         posInRefCoord = [-0.85685375,-0.90643355,-0.90796825]
1068         ref = N_hexa27( np.array(posInRefCoord) )
1069         ref2 = diff_N_hexa27( np.array(posInRefCoord) )
1070         # computation using MEDCoupling
1071         gl = MEDCouplingGaussLocalization(NORM_HEXA27,sum(ref_coords_hexa27_med,[]),posInRefCoord,[1])
1072         mcShapeFunc = gl.getShapeFunctionValues()
1073         mcShapeFunc.rearrange(1)
1074         self.assertTrue( mcShapeFunc.isEqual(DataArrayDouble(ref),1e-12) )
1075
1076         mvDevOfShapeFunc = gl.getDerivativeOfShapeFunctionValues()
1077         mvDevOfShapeFunc.rearrange(1)
1078         ref2_mc = DataArrayDouble(ref2) ; ref2_mc.rearrange(1)
1079         self.assertTrue( mvDevOfShapeFunc.isEqual( ref2_mc, 1e-12) )
1080
1081     def testShapeFuncAndDerivative1(self):
1082         """
1083         This test focus
1084         """
1085         def GetShapeFunc(ref_coord,vec):
1086             gl3 = MEDCouplingGaussLocalization(gt,sum(ref_coord,[]), vec, [1])
1087             funVal = gl3.getShapeFunctionValues()
1088             funVal.rearrange(1)
1089             return funVal
1090
1091         def GetDerivative(ref_coord,vec):
1092             gl3 = MEDCouplingGaussLocalization(gt,sum(ref_coord,[]), vec, [1])
1093             funVal = gl3.getDerivativeOfShapeFunctionValues()
1094             return funVal
1095         vec = [-0.85685375,-0.90643355,-0.90796825]
1096         eps = 1e-6
1097         # 3D cells
1098         for gt in [NORM_TETRA4,NORM_TETRA10,NORM_HEXA8,NORM_PENTA6,NORM_PYRA5,NORM_PYRA13,NORM_PENTA15,NORM_PENTA6,NORM_PENTA18,NORM_HEXA20,NORM_HEXA27]: # type of cell for which derivatives are implemented
1099             ref_coord = [list(elt) for elt in MEDCouplingGaussLocalization.GetDefaultReferenceCoordinatesOf(gt).getValuesAsTuple()]
1100
1101             der_computed = GetDerivative(ref_coord,vec)
1102             der_computed.rearrange(3)
1103
1104             der_deduced = ( GetShapeFunc(ref_coord,[vec[0]+eps,vec[1],vec[2]])-GetShapeFunc(ref_coord,vec) ) / eps
1105             delta_X = der_computed[:,0]-der_deduced
1106             delta_X.abs()
1107             self.assertTrue(delta_X.findIdsNotInRange(-1e-4,+1e-4).empty())
1108
1109             der_deduced = ( GetShapeFunc(ref_coord,[vec[0],vec[1]+eps,vec[2]])-GetShapeFunc(ref_coord,vec) ) / eps
1110             delta_Y = der_computed[:,1]-der_deduced
1111             delta_Y.abs()
1112             self.assertTrue(delta_Y.findIdsNotInRange(-1e-5,+1e-5).empty())
1113
1114             der_deduced = ( GetShapeFunc(ref_coord,[vec[0],vec[1],vec[2]+eps])-GetShapeFunc(ref_coord,vec) ) / eps
1115             delta_Z = der_computed[:,2]-der_deduced
1116             delta_Z.abs()
1117             self.assertTrue(delta_Z.findIdsNotInRange(-1e-5,+1e-5).empty())
1118
1119         for gt,ref_coord  in [(NORM_TETRA4,[[0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]]),(NORM_TETRA10,[[0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0], [0.0, 0.5, 0.0], [0.0, 0.0, 0.5], [0.0, 0.5, 0.5], [0.5, 0.5, 0.0], [0.5, 0.0, 0.0], [0.5, 0.0, 0.5]]),(NORM_HEXA8,[[-1.0, -1.0, -1.0], [-1.0, 1.0, -1.0], [1.0, 1.0, -1.0], [1.0, -1.0, -1.0], [-1.0, -1.0, 1.0], [-1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, -1.0, 1.0]]),(NORM_HEXA8,[[-1.0, 1.0, 0.0], [-1.0, -1.0, 0.0], [1.0, -1.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]),(NORM_HEXA8,[[-1.0, -1.0, 0.0], [-1.0, 1.0, 0.0], [1.0, 1.0, 0.0], [1.0, -1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]),(NORM_PENTA6,[[-1.0, 1.0, 0.0], [-1.0, 0.0, 0.0], [-1.0, -0.0, 1.0], [1.0, 1.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 1.0]]),(NORM_PENTA6,[[-1.0, 1.0, 0.0], [-1.0, -1.0, 0.0], [1.0, -1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]),(NORM_PENTA6,[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]),(NORM_PYRA5,[[1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [-1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]),(NORM_PYRA13, [[1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [-1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [0.5, -0.5, 0.0], [-0.5, -0.5, 0.0], [-0.5, 0.5, 0.0], [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, -0.5, 0.5], [-0.5, 0.0, 0.5], [0.0, 0.5, 0.5]]),(NORM_PENTA15,[[-1.0, 1.0, 0.0], [-1.0, 0.0, 0.0], [-1.0, -0.0, 1.0], [1.0, 1.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 1.0], [-1.0, 0.5, 0.0], [-1.0, 0.0, 0.5], [-1.0, 0.5, 0.5], [1.0, 0.5, 0.0], [1.0, 0.0, 0.5], [1.0, 0.5, 0.5], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0]]),(NORM_PENTA18,[[-1.0, 1.0, 0.0], [-1.0, 0.0, 0.0], [-1.0, -0.0, 1.0], [1.0, 1.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 1.0], [-1.0, 0.5, 0.0], [-1.0, 0.0, 0.5], [-1.0, 0.5, 0.5], [1.0, 0.5, 0.0], [1.0, 0.0, 0.5], [1.0, 0.5, 0.5], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.5, 0.0], [0.0, 0.0, 0.5], [0.0, 0.5, 0.5]]),(NORM_HEXA20,[[-1.0, -1.0, -1.0], [-1.0, 1.0, -1.0], [1.0, 1.0, -1.0], [1.0, -1.0, -1.0], [-1.0, -1.0, 1.0], [-1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, -1.0, 1.0], [-1.0, 0.0, -1.0], [0.0, 1.0, -1.0], [1.0, 0.0, -1.0], [0.0, -1.0, -1.0], [-1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [1.0, 0.0, 1.0], [0.0, -1.0, 1.0], [-1.0, -1.0, 0.0], [-1.0, 1.0, 0.0], [1.0, 1.0, 0.0], [1.0, -1.0, 0.0]])]: # type of cell for which derivatives are implemented
1120
1121             der_computed = GetDerivative(ref_coord,vec)
1122             der_computed.rearrange(3)
1123
1124             der_deduced = ( GetShapeFunc(ref_coord,[vec[0]+eps,vec[1],vec[2]])-GetShapeFunc(ref_coord,vec) ) / eps
1125             delta_X = der_computed[:,0]-der_deduced
1126             delta_X.abs()
1127             self.assertTrue(delta_X.findIdsNotInRange(-1e-4,+1e-4).empty())
1128
1129             der_deduced = ( GetShapeFunc(ref_coord,[vec[0],vec[1]+eps,vec[2]])-GetShapeFunc(ref_coord,vec) ) / eps
1130             delta_Y = der_computed[:,1]-der_deduced
1131             delta_Y.abs()
1132             self.assertTrue(delta_Y.findIdsNotInRange(-1e-5,+1e-5).empty())
1133
1134             der_deduced = ( GetShapeFunc(ref_coord,[vec[0],vec[1],vec[2]+eps])-GetShapeFunc(ref_coord,vec) ) / eps
1135             delta_Z = der_computed[:,2]-der_deduced
1136             delta_Z.abs()
1137             self.assertTrue(delta_Z.findIdsNotInRange(-1e-5,+1e-5).empty())
1138
1139         # 2D cells
1140         vec = [0.64,0.2]
1141
1142         for gt in [NORM_QUAD4,NORM_QUAD8,NORM_QUAD9,NORM_TRI3,NORM_TRI6,NORM_TRI7]:
1143             ref_coord = [list(elt) for elt in MEDCouplingGaussLocalization.GetDefaultReferenceCoordinatesOf(gt).getValuesAsTuple()]
1144
1145             der_computed = GetDerivative(ref_coord,vec)
1146             der_computed.rearrange(2)
1147
1148             der_deduced = ( GetShapeFunc(ref_coord,[vec[0]+eps,vec[1]])-GetShapeFunc(ref_coord,vec) ) / eps
1149             delta_X = der_computed[:,0]-der_deduced
1150             delta_X.abs()
1151             self.assertTrue(delta_X.findIdsNotInRange(-1e-5,+1e-5).empty())
1152
1153             der_deduced = ( GetShapeFunc(ref_coord,[vec[0],vec[1]+eps])-GetShapeFunc(ref_coord,vec) ) / eps
1154             delta_Y = der_computed[:,1]-der_deduced
1155             delta_Y.abs()
1156             self.assertTrue(delta_Y.findIdsNotInRange(-1e-4,+1e-4).empty())
1157
1158         # B version of TRI6, QUAD4 and QUAD8
1159         for gt,ref_coord in [(NORM_TRI3,[[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]),(NORM_TRI6,[[0., 0.], [1., 0.], [0., 1.], [0.5, 0.], [0.5, 0.5], [0., 0.5]]),
1160             (NORM_QUAD4,[[-1., -1.], [1., -1.], [1., 1.], [-1., 1.]]),(NORM_QUAD4,[[-1., -1.], [-1., 1.], [1., 1.], [1., -1.]]),(NORM_QUAD4,[[-1., 0.], [1., 0.], [0., 0.], [0., 0.]]),(NORM_QUAD8,[[-1., -1.], [1., -1.], [1., 1.], [-1., 1.], [0., -1.], [1., 0.], [0., 1.], [-1., 0.]])]:
1161             der_computed = GetDerivative(ref_coord,vec)
1162             der_computed.rearrange(2)
1163
1164             der_deduced = ( GetShapeFunc(ref_coord,[vec[0]+eps,vec[1]])-GetShapeFunc(ref_coord,vec) ) / eps
1165             delta_X = der_computed[:,0]-der_deduced
1166             delta_X.abs()
1167             self.assertTrue(delta_X.findIdsNotInRange(-1e-5,+1e-5).empty())
1168
1169             der_deduced = ( GetShapeFunc(ref_coord,[vec[0],vec[1]+eps])-GetShapeFunc(ref_coord,vec) ) / eps
1170             delta_Y = der_computed[:,1]-der_deduced
1171             delta_Y.abs()
1172             self.assertTrue(delta_Y.findIdsNotInRange(-1e-5,+1e-5).empty())
1173
1174         # 1D cells
1175         vec = [0.64]
1176
1177         for gt in [NORM_SEG2,NORM_SEG3,NORM_SEG4]:
1178             ref_coord = [list(elt) for elt in MEDCouplingGaussLocalization.GetDefaultReferenceCoordinatesOf(gt).getValuesAsTuple()]
1179
1180             der_computed = GetDerivative(ref_coord,vec)
1181             der_computed.rearrange(1)
1182
1183             der_deduced = ( GetShapeFunc(ref_coord,[vec[0]+eps])-GetShapeFunc(ref_coord,vec) ) / eps
1184             delta_X = der_computed[:,0]-der_deduced
1185             delta_X.abs()
1186             self.assertTrue(delta_X.findIdsNotInRange(-1e-5,+1e-5).empty())
1187
1188         #B version of SEG2
1189         for gt,ref_coord in [(NORM_SEG2,[[0.], [1.]])]:
1190             der_computed = GetDerivative(ref_coord,vec)
1191             der_computed.rearrange(1)
1192
1193             der_deduced = ( GetShapeFunc(ref_coord,[vec[0]+eps])-GetShapeFunc(ref_coord,vec) ) / eps
1194             delta_X = der_computed[:,0]-der_deduced
1195             delta_X.abs()
1196             self.assertTrue(delta_X.findIdsNotInRange(-1e-5,+1e-5).empty())
1197
1198
1199     def testComputeTriangleHeight0(self):
1200         arr = DataArrayDouble([0,1])
1201         m = MEDCouplingCMesh() ; m.setCoords(arr,arr)
1202         m = m.buildUnstructured() ; m.simplexize(0) ; m = MEDCoupling1SGTUMesh(m)
1203         res = m.computeTriangleHeight()
1204         expected = DataArrayDouble([(1.0, 1.0, sqrt(2)/2.0), (sqrt(2)/2.0, 1.0, 1.0)])
1205         self.assertTrue( res.isEqual(expected,1e-12) )
1206         m.changeSpaceDimension(3,100)
1207         res2 = m.computeTriangleHeight()
1208         self.assertTrue( res2.isEqual(expected,1e-12) )
1209         expected2 = DataArrayDouble([sqrt(2)/2.0, sqrt(2)/2.0])
1210         self.assertTrue( res2.minPerTuple().isEqual(expected2,1e-12) )
1211
1212     def testDAILocateComponentId0(self):
1213         arr = DataArrayInt( [(0, 1, 2), (3, 4, 5), (6, 2, 3), (7, 8, 9), (9, 0, 10), (11, 12, 13), (14, 5, 11), (15, 16, 17)] )
1214         valToSearchIntoTuples = DataArrayInt( [1, 4, 6, 8, 10, 12, 14, 16, 17] )
1215         tupleIdHint = DataArrayInt( [0, 1, 2, 3, 4, 5, 6, 7, 7] )
1216         ret = arr.locateComponentId( valToSearchIntoTuples, tupleIdHint )
1217         self.assertTrue( ret.isEqual(DataArrayInt([1, 1, 0, 1, 2, 1, 0, 1, 2]) ) )
1218         pass
1219
1220     def testMeasureOnGaussPtMeshDimNotEqualSpaceDim0(self):
1221         """
1222         [EDF26877] : This test focuses on computation of measure field on field on Gauss Point in the special case where SpaceDim
1223         are not eqaul to the meshDim.
1224         """
1225         seg2 = MEDCouplingUMesh("mesh",1)
1226         seg2.setCoords(DataArrayDouble([(3,3),(4,4)]))
1227         seg2.allocateCells()
1228         seg2.insertNextCell(NORM_SEG2,[0,1])
1229         fff=MEDCouplingFieldDouble.New(ON_GAUSS_PT) ; fff.setName("CH1RB") ; fff.setNature(IntensiveMaximum)
1230         fff.setMesh(seg2)
1231         fff.setGaussLocalizationOnCells([0], [0.,1.], [0.333333333333333], [1.0])
1232         disc = fff.getDiscretization()
1233         # spaceDim = 2 meshDim = 1
1234         self.assertTrue( disc.getMeasureField(seg2,True).getArray().isEqual(DataArrayDouble([sqrt(2.0)]),1e-10) )
1235         # spaceDim = 3 meshDim = 1
1236         seg2.setCoords(DataArrayDouble([(3,3,3),(4,4,4)]))
1237         self.assertTrue( disc.getMeasureField(seg2,True).getArray().isEqual(DataArrayDouble([sqrt(3.0)]),1e-10) )
1238         # spaceDim = 3 meshDim = 2
1239         tri = MEDCouplingUMesh("mesh",2)
1240         tri.setCoords( DataArrayDouble([(0,0,0),(1,1,0),(2,2,2)]) )
1241         tri.allocateCells()
1242         tri.insertNextCell(NORM_TRI3,[0,1,2])
1243         fff=MEDCouplingFieldDouble.New(ON_GAUSS_PT) ; fff.setName("CH1RB") ; fff.setNature(IntensiveMaximum)
1244         fff.setMesh(tri)
1245         fff.setGaussLocalizationOnCells(list(range(0, 1)), [0., 0., 1., 0., 0., 1.], [0.3333333333333333, 0.3333333333333333], [0.5])
1246         disc = fff.getDiscretization()
1247         self.assertTrue( disc.getMeasureField(tri,True).getArray().isEqual( tri.getMeasureField(True).getArray(), 1e-10) )
1248         pass
1249
1250     def testUMeshExplodeMeshTo(self):
1251         """
1252         [EDF27988] : implementation of reduceToCells implies implementation of MEDCouplingUMesh.explodeMeshTo
1253         """
1254         arr = DataArrayDouble(5) ; arr.iota()
1255         m = MEDCouplingCMesh() ; m.setCoords(arr,arr,arr)
1256         m = m.buildUnstructured()
1257         m1 = m[::2] ; m2 = m[1::2]
1258         m1.simplexize(PLANAR_FACE_5)
1259         m = MEDCouplingUMesh.MergeUMeshesOnSameCoords([m1,m2])
1260         mE1 = m.explodeMeshTo(-1)
1261         ref1 = m.buildDescendingConnectivity()
1262         mE2 = m.explodeMeshTo(-2)
1263         ref2 = m.explode3DMeshTo1D()
1264         mE3 = m.explodeMeshTo(-3)
1265         self.assertTrue( len(mE1) ==5 )
1266         self.assertTrue( mE1[0].getNodalConnectivity().isEqual(ref1[0].getNodalConnectivity()) )
1267         self.assertTrue( mE1[0].getNodalConnectivityIndex().isEqual(ref1[0].getNodalConnectivityIndex()) )
1268         self.assertTrue( mE1[0].getCoords().getHiddenCppPointer() == m.getCoords().getHiddenCppPointer() )
1269         for i in range(1,5):
1270             self.assertTrue( mE1[i].isEqual(ref1[i]) )
1271         #
1272         self.assertTrue( len(mE2) ==5 )
1273         self.assertTrue( mE2[0].getNodalConnectivity().isEqual(ref2[0].getNodalConnectivity()) )
1274         self.assertTrue( mE2[0].getNodalConnectivityIndex().isEqual(ref2[0].getNodalConnectivityIndex()) )
1275         self.assertTrue( mE2[0].getCoords().getHiddenCppPointer() == m.getCoords().getHiddenCppPointer() )
1276         for i in range(1,5):
1277             self.assertTrue( mE2[i].isEqual(ref2[i]) )
1278         #
1279         self.assertTrue( mE3[0].getMeshDimension() == 0 )
1280         self.assertTrue( mE3[0].getNumberOfCells() == mE3[0].getNumberOfNodes() )
1281         a,b = m.getReverseNodalConnectivity()
1282         self.assertTrue( mE3[3].isEqual(a) and mE3[4].isEqual(b) )
1283         ref3_2 = (m.getNodalConnectivityIndex().deltaShiftIndex()-1) ; ref3_2.computeOffsetsFull()
1284         self.assertTrue( ref3_2.isEqual(mE3[2]) )
1285         tmp = m.getNodalConnectivityIndex().deepCopy() ; tmp.popBackSilent() ; tmp = tmp.buildComplement( len(m.getNodalConnectivity()) ) ; ref3_1 = m.getNodalConnectivity()[tmp]
1286         self.assertTrue( ref3_1.isEqual(mE3[1]) )
1287         #
1288         cellsInPolyh = [37,160]
1289         polyh = m[cellsInPolyh]
1290         polyh.convertAllToPoly()
1291         m[cellsInPolyh] = polyh
1292         pE3 = m.explodeMeshTo(-3)
1293         self.assertTrue( pE3[0].getMeshDimension() == 0 )
1294         self.assertTrue( pE3[0].getNumberOfCells() == pE3[0].getNumberOfNodes() )
1295         a,b = m.getReverseNodalConnectivity()
1296         self.assertTrue( pE3[3].isEqual(a) and pE3[4].isEqual(b) )
1297         self.assertTrue( pE3[2].isEqual(mE3[2]) ) # indexed arrays are the same
1298
1299         ref_a,ref_b = DataArrayInt.ExtractFromIndexedArrays( DataArrayInt(cellsInPolyh).buildComplement(m.getNumberOfCells()), mE3[1], mE3[2] )
1300         a,b = DataArrayInt.ExtractFromIndexedArrays( DataArrayInt(cellsInPolyh).buildComplement(m.getNumberOfCells()), pE3[1], pE3[2] )
1301         self.assertTrue( ref_a.isEqual(a) )
1302         self.assertTrue( ref_b.isEqual(b) )
1303         for cell in cellsInPolyh:
1304             ref_c,ref_d = DataArrayInt.ExtractFromIndexedArrays( cell, mE3[1], mE3[2] ) ; ref_c.sort()
1305             c,d = DataArrayInt.ExtractFromIndexedArrays( cell, pE3[1], pE3[2] )
1306             self.assertTrue( ref_c.isEqual(c) )
1307             self.assertTrue( ref_d.isEqual(d) )
1308
1309     def testGetCellContainingPointRelativeEps(self):
1310         """
1311         See EDF27860 : This test checks that detection of point inside a cell works by normalizing cell around origin with factor equal to the max delta of bbox along axis X, Y or Z.
1312         """
1313         # in this test cell is vuluntary far from origin {15260.775604514516, 11197.646906189217, 14187.820484060947}
1314         # and caracteritic size is ~ 1500
1315         coo = DataArrayDouble( [(14724.199858870656, 11928.888084722483, 14442.32726944039), (14788.407409534622, 11992.60694822231, 14453.86181555231), (15572.175148726046, 10798.586790270576, 14471.54225356788), (15643.898717334796, 10853.094666047728, 14477.233802854305), (15005.31495255754, 11573.261110174888, 13933.313698681504), (15070.29423166349, 11636.377758513776, 13946.650959030132), (15797.351350158377, 10466.40572765595, 13965.524190108257), (15869.808770928525, 10519.99285973948, 13972.419352086607), (15273.866774426142, 11216.458197414971, 13433.169979717744), (15340.421031616577, 11277.882145177837, 13446.53598386297), (16013.382514001762, 10132.795887638129, 13465.184281842226), (16086.979064572806, 10184.802292369684, 13472.147425473782)] )
1316         m = MEDCouplingUMesh("",3)
1317         m.setCoords(coo)
1318         m.allocateCells()
1319         m.insertNextCell(NORM_TETRA4,[0,5,4,6])
1320         m.insertNextCell(NORM_TETRA4,[4,5,9,7])
1321
1322         ##### See EDF2760 pt is outside cell 0 (6e-4) and 1 (8e-4)
1323         pt = DataArrayDouble([(15263.41200205526, 11314.957094727113, 13950.0)])
1324         a,b = m.getCellsContainingPoints(pt,1e-3)
1325         self.assertTrue(a.isEqual(DataArrayInt([0,1])))
1326         self.assertTrue(b.isEqual(DataArrayInt([0,2])))
1327
1328         # by shifting pt by 10 along Z pt in only inside cell # 0
1329         pt += [0,0,10]
1330         a1,b1 = m.getCellsContainingPoints(pt,1e-3)
1331         self.assertTrue(a1.isEqual(DataArrayInt([0])))
1332         self.assertTrue(b1.isEqual(DataArrayInt([0,1])))
1333
1334     pass
1335
1336 if __name__ == '__main__':
1337     unittest.main()