src/MEDCoupling_Swig/MEDCouplingBasicsTest4.py

   1 #  -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2016  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 from MEDCoupling import *
  22 import unittest
  23 from math import pi,e,sqrt,cos,sin
  24 from datetime import datetime
  25 from MEDCouplingDataForTest import MEDCouplingDataForTest
  26 import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@cea.fr
  27 from sys import platform
  28
  29 def checkFreeMemory(size):
  30     """
  31     Get node total memory and memory usage
  32     """
  33     ret = True
  34     dic = {}
  35     if platform not in ["win32"]:
  36         with open('/proc/meminfo', 'r') as mem:
  37             tmp = 0
  38             for i in mem:
  39                 sline = i.split()
  40                 if str(sline[0]) == 'MemTotal:':
  41                     dic['total'] = int(sline[1])
  42                 elif str(sline[0]) in ('MemFree:', 'Buffers:', 'Cached:'):
  43                     tmp += int(sline[1])
  44             dic['free'] = tmp
  45             dic['used'] = int(dic['total']) - int(dic['free'])
  46             ret = dic['free'] > size
  47     #TODO: extend this method for Windows OS
  48     return ret
  49
  50
  51 class MEDCouplingBasicsTest4(unittest.TestCase):
  52     def testSwigDADOp4(self):
  53         da=DataArrayDouble.New(range(6,30),12,2)
  54         self.assertEqual(12,da.getNumberOfTuples());
  55         self.assertEqual(2,da.getNumberOfComponents());
  56         for i in xrange(24):
  57             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
  58             pass
  59         # operator transpose
  60         da.transpose()
  61         self.assertEqual(2,da.getNumberOfTuples());
  62         self.assertEqual(12,da.getNumberOfComponents());
  63         for i in xrange(24):
  64             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
  65             pass
  66         da.transpose()
  67         # operator __neg__
  68         da2=DataArrayDouble.New(12,1)
  69         da2.iota(0.)
  70         dabis=-da
  71         for i in xrange(24):
  72             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
  73             pass
  74         # operator+=
  75         da+=da2
  76         expected1=[6.,7.,9.,10.,12.,13.,15.,16.,18.,19.,21.,22.,24.,25.,27.,28.,30.,31.,33.,34.,36.,37.,39.,40.]
  77         for i in xrange(24):
  78             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
  79             pass
  80         da=-dabis
  81         da+=[100.,101.]
  82         expected2=[106.,108.,108.,110.,110.,112.,112.,114.,114.,116.,116.,118.,118.,120.,120.,122.,122.,124.,124.,126.,126.,128.,128.,130.]
  83         self.assertEqual(12,da.getNumberOfTuples());
  84         self.assertEqual(2,da.getNumberOfComponents());
  85         for i in xrange(24):
  86             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
  87             pass
  88         for pos,elt in enumerate(dabis):
  89             da[pos]+=elt
  90             pass
  91         self.assertEqual(12,da.getNumberOfTuples());
  92         self.assertEqual(2,da.getNumberOfComponents());
  93         for elt in da:
  94             li=elt[:]
  95             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
  96             pass
  97         # operator-=
  98         da=DataArrayDouble.New(range(6,30),12,2)
  99         da2=DataArrayDouble.New(range(12),12,1)
 100         dabis=-da
 101         da-=da2
 102         expected1=[6.,7.,7.,8.,8.,9.,9.,10.,10.,11.,11.,12.,12.,13.,13.,14.,14.,15.,15.,16.,16.,17.,17.,18.]
 103         for i in xrange(24):
 104             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
 105             pass
 106         da=-dabis
 107         da-=[100.,101.]
 108         expected2=[-94.,-94.,-92.,-92.,-90.,-90.,-88.,-88.,-86.,-86.,-84.,-84.,-82.,-82.,-80.,-80.,-78.,-78.,-76.,-76.,-74.,-74.,-72.,-72.]
 109         self.assertEqual(12,da.getNumberOfTuples());
 110         self.assertEqual(2,da.getNumberOfComponents());
 111         for i in xrange(24):
 112             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
 113             pass
 114         for pos,elt in enumerate(dabis):
 115             da[pos]-=elt
 116             pass
 117         self.assertEqual(12,da.getNumberOfTuples());
 118         self.assertEqual(2,da.getNumberOfComponents());
 119         expected3=[-88.,-87.,-84.,-83.,-80.,-79.,-76.,-75.,-72.,-71.,-68.,-67.,-64.,-63.,-60.,-59.,-56.,-55.,-52.,-51.,-48.,-47.,-44.,-43.]
 120         for i in xrange(24):
 121             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
 122             pass
 123         # operator*=
 124         da=DataArrayDouble.New(range(6,30),12,2)
 125         da2=DataArrayDouble.New(range(12),12,1)
 126         dabis=-da
 127         da*=da2
 128         expected1=[0.,0.,8.,9.,20.,22.,36.,39.,56.,60.,80.,85.,108.,114.,140.,147.,176.,184.,216.,225.,260.,270.,308.,319.]
 129         for i in xrange(24):
 130             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
 131             pass
 132         da=-dabis
 133         da*=[100.,101.]
 134         expected2=[600.,707.,800.,909.,1000.,1111.,1200.,1313.,1400.,1515.,1600.,1717.,1800.,1919.,2000.,2121.,2200.,2323.,2400.,2525.,2600.,2727.,2800.,2929.]
 135         self.assertEqual(12,da.getNumberOfTuples());
 136         self.assertEqual(2,da.getNumberOfComponents());
 137         for i in xrange(24):
 138             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
 139             pass
 140         for pos,elt in enumerate(dabis):
 141             da[pos]*=elt
 142             pass
 143         self.assertEqual(12,da.getNumberOfTuples());
 144         self.assertEqual(2,da.getNumberOfComponents());
 145         expected3=[-3600.,-4949.,-6400.,-8181.,-10000.,-12221.,-14400.,-17069.,-19600.,-22725.,-25600.,-29189.,-32400.,-36461.,-40000.,-44541.,-48400.,-53429.,-57600.,-63125.,-67600.,-73629.,-78400.,-84941.0]
 146         for i in xrange(24):
 147             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
 148             pass
 149         # operator/=
 150         da=DataArrayDouble.New(range(6,30),12,2)
 151         da2=DataArrayDouble.New(range(1,13),12,1)
 152         dabis=-da
 153         da/=da2
 154         expected1=[6.0,7.0,4.0,4.5,3.3333333333333335,3.6666666666666665,3.0,3.25,2.8,3.0,2.6666666666666665,2.8333333333333335,2.5714285714285716,2.7142857142857144,2.5,2.625,2.4444444444444446,2.5555555555555554,2.4,2.5,2.3636363636363638,2.4545454545454546,2.3333333333333335,2.4166666666666665]
 155         for i in xrange(24):
 156             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
 157             pass
 158         da=-dabis
 159         da/=[100.,101.]
 160         expected2=[0.06,0.06930693069306931,0.08,0.0891089108910891,0.1,0.10891089108910891,0.12,0.12871287128712872,0.14,0.1485148514851485,0.16,0.16831683168316833,0.18,0.18811881188118812,0.2,0.2079207920792079,0.22,0.22772277227722773,0.24,0.24752475247524752,0.26,0.26732673267326734,0.28,0.2871287128712871]
 161         self.assertEqual(12,da.getNumberOfTuples());
 162         self.assertEqual(2,da.getNumberOfComponents());
 163         for i in xrange(24):
 164             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
 165             pass
 166         for pos,elt in enumerate(dabis):
 167             da[pos]/=elt
 168             pass
 169         self.assertEqual(12,da.getNumberOfTuples());
 170         self.assertEqual(2,da.getNumberOfComponents());
 171         expected3=[-0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.0099009900990099]
 172         for i in xrange(24):
 173             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
 174             pass
 175         pass
 176
 177     def testSwigDAIOp4(self):
 178         da=DataArrayInt.New(range(6,30),12,2)
 179         self.assertEqual(12,da.getNumberOfTuples());
 180         self.assertEqual(2,da.getNumberOfComponents());
 181         for i in xrange(24):
 182             self.assertEqual(da.getIJ(0,i),i+6)
 183             pass
 184         # operator transpose
 185         da.transpose()
 186         self.assertEqual(2,da.getNumberOfTuples());
 187         self.assertEqual(12,da.getNumberOfComponents());
 188         for i in xrange(24):
 189             self.assertEqual(da.getIJ(0,i),i+6)
 190             pass
 191         da.transpose()
 192         # operator __neg__
 193         da2=DataArrayInt.New(12,1)
 194         da2.iota(0)
 195         dabis=-da
 196         for i in xrange(24):
 197             self.assertEqual(dabis.getIJ(0,i),-(i+6))
 198             pass
 199         # operator+=
 200         da+=da2
 201         expected1=[6,7,9,10,12,13,15,16,18,19,21,22,24,25,27,28,30,31,33,34,36,37,39,40]
 202         for i in xrange(24):
 203             self.assertEqual(da.getIJ(0,i),expected1[i])
 204             pass
 205         da=-dabis
 206         da+=[100,101]
 207         expected2=[106,108,108,110,110,112,112,114,114,116,116,118,118,120,120,122,122,124,124,126,126,128,128,130]
 208         self.assertEqual(12,da.getNumberOfTuples());
 209         self.assertEqual(2,da.getNumberOfComponents());
 210         for i in xrange(24):
 211             self.assertEqual(da.getIJ(0,i),expected2[i])
 212             pass
 213         for pos,elt in enumerate(dabis):
 214             da[pos]+=elt
 215             pass
 216         self.assertEqual(12,da.getNumberOfTuples());
 217         self.assertEqual(2,da.getNumberOfComponents());
 218         for elt in da:
 219             li=elt[:]
 220             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
 221             pass
 222         # operator-=
 223         da=DataArrayInt.New(range(6,30),12,2)
 224         da2=DataArrayInt.New(range(12),12,1)
 225         dabis=-da
 226         da-=da2
 227         expected1=[6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18]
 228         for i in xrange(24):
 229             self.assertEqual(da.getIJ(0,i),expected1[i])
 230             pass
 231         da=-dabis
 232         da-=[100,101]
 233         expected2=[-94,-94,-92,-92,-90,-90,-88,-88,-86,-86,-84,-84,-82,-82,-80,-80,-78,-78,-76,-76,-74,-74,-72,-72]
 234         self.assertEqual(12,da.getNumberOfTuples());
 235         self.assertEqual(2,da.getNumberOfComponents());
 236         for i in xrange(24):
 237             self.assertEqual(da.getIJ(0,i),expected2[i])
 238             pass
 239         for pos,elt in enumerate(dabis):
 240             da[pos]-=elt
 241             pass
 242         self.assertEqual(12,da.getNumberOfTuples());
 243         self.assertEqual(2,da.getNumberOfComponents());
 244         expected3=[-88,-87,-84,-83,-80,-79,-76,-75,-72,-71,-68,-67,-64,-63,-60,-59,-56,-55,-52,-51,-48,-47,-44,-43]
 245         for i in xrange(24):
 246             self.assertEqual(da.getIJ(0,i),expected3[i])
 247             pass
 248         # operator*=
 249         da=DataArrayInt.New(range(6,30),12,2)
 250         da2=DataArrayInt.New(range(12),12,1)
 251         dabis=-da
 252         da*=da2
 253         expected1=[0,0,8,9,20,22,36,39,56,60,80,85,108,114,140,147,176,184,216,225,260,270,308,319]
 254         for i in xrange(24):
 255             self.assertEqual(da.getIJ(0,i),expected1[i])
 256             pass
 257         da=-dabis
 258         da*=[100,101]
 259         expected2=[600,707,800,909,1000,1111,1200,1313,1400,1515,1600,1717,1800,1919,2000,2121,2200,2323,2400,2525,2600,2727,2800,2929]
 260         self.assertEqual(12,da.getNumberOfTuples());
 261         self.assertEqual(2,da.getNumberOfComponents());
 262         for i in xrange(24):
 263             self.assertEqual(da.getIJ(0,i),expected2[i])
 264             pass
 265         for pos,elt in enumerate(dabis):
 266             da[pos]*=elt
 267             pass
 268         self.assertEqual(12,da.getNumberOfTuples());
 269         self.assertEqual(2,da.getNumberOfComponents());
 270         expected3=[-3600,-4949,-6400,-8181,-10000,-12221,-14400,-17069,-19600,-22725,-25600,-29189,-32400,-36461,-40000,-44541,-48400,-53429,-57600,-63125,-67600,-73629,-78400,-84941.0]
 271         for i in xrange(24):
 272             self.assertEqual(da.getIJ(0,i),expected3[i])
 273             pass
 274         # operator/=
 275         da=DataArrayInt.New(range(6,30),12,2)
 276         da2=DataArrayInt.New(range(1,13),12,1)
 277         dabis=-da
 278         da/=da2
 279         expected1=[6,7,4,4,3,3,3,3,2,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
 280         for i in xrange(24):
 281             self.assertEqual(da.getIJ(0,i),expected1[i])
 282             pass
 283         da=-dabis
 284         da/=DataArrayInt.New([2,3],1,2)
 285         self.assertEqual(12,da.getNumberOfTuples());
 286         self.assertEqual(2,da.getNumberOfComponents());
 287         expected2=[3,2,4,3,5,3,6,4,7,5,8,5,9,6,10,7,11,7,12,8,13,9,14,9]
 288         for i in xrange(24):
 289             self.assertEqual(da.getIJ(0,i),expected2[i])
 290             pass
 291         pass
 292
 293     def testSwigDADOp5(self):
 294         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
 295         da.rearrange(3)
 296         da2=DataArrayDouble.New([5.,8.,10.,12])
 297         self.assertEqual(4,da2.getNumberOfTuples());
 298         self.assertEqual(1,da2.getNumberOfComponents());
 299         da3=da+da2
 300         self.assertEqual(4,da3.getNumberOfTuples());
 301         self.assertEqual(3,da3.getNumberOfComponents());
 302         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
 303         for i in xrange(12):
 304             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
 305             pass
 306         da3=da2+da
 307         self.assertEqual(4,da3.getNumberOfTuples());
 308         self.assertEqual(3,da3.getNumberOfComponents());
 309         for i in xrange(12):
 310             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
 311             pass
 312         # Test new API of classmethod DataArrayDouble.New
 313         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
 314         da=DataArrayDouble.New(vals)
 315         self.assertEqual(12,da.getNumberOfTuples());
 316         self.assertEqual(1,da.getNumberOfComponents());
 317         for i in xrange(12):
 318             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
 319             pass
 320         da=DataArrayDouble.New(vals,12)
 321         self.assertEqual(12,da.getNumberOfTuples());
 322         self.assertEqual(1,da.getNumberOfComponents());
 323         for i in xrange(12):
 324             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
 325             pass
 326         da=DataArrayDouble.New(vals,1,12)
 327         self.assertEqual(1,da.getNumberOfTuples());
 328         self.assertEqual(12,da.getNumberOfComponents());
 329         for i in xrange(12):
 330             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
 331             pass
 332         da=DataArrayDouble.New(vals,6,2)
 333         self.assertEqual(6,da.getNumberOfTuples());
 334         self.assertEqual(2,da.getNumberOfComponents());
 335         for i in xrange(12):
 336             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
 337             pass
 338         da=DataArrayDouble.New(vals,4,3)
 339         self.assertEqual(4,da.getNumberOfTuples());
 340         self.assertEqual(3,da.getNumberOfComponents());
 341         for i in xrange(12):
 342             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
 343             pass
 344         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
 345         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
 346         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
 347         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
 348         pass
 349
 350     def testSwigDADOp6(self):
 351         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
 352         da.rearrange(3)
 353         da2=DataArrayInt.New([5,8,10,12])
 354         self.assertEqual(4,da2.getNumberOfTuples());
 355         self.assertEqual(1,da2.getNumberOfComponents());
 356         da3=da+da2
 357         self.assertEqual(4,da3.getNumberOfTuples());
 358         self.assertEqual(3,da3.getNumberOfComponents());
 359         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
 360         for i in xrange(12):
 361             self.assertEqual(da3.getIJ(0,i),expected1[i])
 362             pass
 363         da3=da2+da
 364         self.assertEqual(4,da3.getNumberOfTuples());
 365         self.assertEqual(3,da3.getNumberOfComponents());
 366         for i in xrange(12):
 367             self.assertEqual(da3.getIJ(0,i),expected1[i])
 368             pass
 369         da3=da+DataArrayInt.New(da2.getValues())
 370         # Test new API of classmethod DataArrayInt.New
 371         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
 372         da=DataArrayDouble.New(vals)
 373         self.assertEqual(12,da.getNumberOfTuples());
 374         self.assertEqual(1,da.getNumberOfComponents());
 375         for i in xrange(12):
 376             self.assertEqual(da.getIJ(0,i),vals[i])
 377             pass
 378         da=DataArrayDouble.New(vals,12)
 379         self.assertEqual(12,da.getNumberOfTuples());
 380         self.assertEqual(1,da.getNumberOfComponents());
 381         for i in xrange(12):
 382             self.assertEqual(da.getIJ(0,i),vals[i])
 383             pass
 384         da=DataArrayDouble.New(vals,1,12)
 385         self.assertEqual(1,da.getNumberOfTuples());
 386         self.assertEqual(12,da.getNumberOfComponents());
 387         for i in xrange(12):
 388             self.assertEqual(da.getIJ(0,i),vals[i])
 389             pass
 390         da=DataArrayDouble.New(vals,6,2)
 391         self.assertEqual(6,da.getNumberOfTuples());
 392         self.assertEqual(2,da.getNumberOfComponents());
 393         for i in xrange(12):
 394             self.assertEqual(da.getIJ(0,i),vals[i])
 395             pass
 396         da=DataArrayDouble.New(vals,4,3)
 397         self.assertEqual(4,da.getNumberOfTuples());
 398         self.assertEqual(3,da.getNumberOfComponents());
 399         for i in xrange(12):
 400             self.assertEqual(da.getIJ(0,i),vals[i])
 401             pass
 402         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
 403         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
 404         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
 405         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
 406         pass
 407
 408     def testSwigDADOp9(self):
 409         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
 410         da1=DataArrayDouble(l1,4,3)
 411         self.assertEqual(4,da1.getNumberOfTuples());
 412         self.assertEqual(3,da1.getNumberOfComponents());
 413         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
 414         self.assertTrue(da2.isEqual(da1,1e-12))
 415         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
 416         da3=DataArrayDouble(l1,4)
 417         self.assertTrue(da3.isEqual(da1,1e-12))
 418         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
 419         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
 420         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
 421         da1=DataArrayDouble(l1,4,3)
 422         self.assertEqual(4,da1.getNumberOfTuples());
 423         self.assertEqual(3,da1.getNumberOfComponents());
 424         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
 425         self.assertTrue(da2.isEqual(da1,1e-12))
 426         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
 427         da3=DataArrayDouble(l1,4)
 428         self.assertTrue(da3.isEqual(da1,1e-12))
 429         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
 430         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
 431         #
 432         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
 433         da1=DataArrayInt(l1,4,3)
 434         self.assertEqual(4,da1.getNumberOfTuples());
 435         self.assertEqual(3,da1.getNumberOfComponents());
 436         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
 437         self.assertTrue(da2.isEqual(da1))
 438         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
 439         da3=DataArrayInt(l1,4)
 440         self.assertTrue(da3.isEqual(da1))
 441         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
 442         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
 443         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
 444         da1=DataArrayInt(l1,4,3)
 445         self.assertEqual(4,da1.getNumberOfTuples());
 446         self.assertEqual(3,da1.getNumberOfComponents());
 447         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
 448         self.assertTrue(da2.isEqual(da1))
 449         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
 450         da3=DataArrayInt(l1,4)
 451         self.assertTrue(da3.isEqual(da1))
 452         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
 453         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
 454         pass
 455
 456     def testRenumberNodesInConn1(self):
 457         mesh2DCoords=[-0.3,-0.3,0., 0.2,-0.3,0., 0.7,-0.3,0., -0.3,0.2,0., 0.2,0.2,0., 0.7,0.2,0., -0.3,0.7,0., 0.2,0.7,0., 0.7,0.7,0. ]
 458         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
 459         mesh2D=MEDCouplingUMesh.New("mesh",2);
 460         mesh2D.allocateCells(5);
 461         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
 462         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
 463         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
 464         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
 465         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
 466         mesh2D.finishInsertingCells();
 467         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
 468         mesh2D.setCoords(myCoords);
 469         mesh2D.checkConsistencyLight();
 470         #
 471         mesh3DCoords=[-0.3,-0.3,0., -0.3,0.2,0., 0.2,0.2,0., 0.2,-0.3,0., -0.3,-0.3,1., -0.3,0.2,1., 0.2,0.2,1., 0.2,-0.3,1. ]
 472         mesh3DConn=[0,1,2,3,4,5,6,7]
 473         mesh3D=MEDCouplingUMesh.New("mesh",3);
 474         mesh3D.allocateCells(1);
 475         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
 476         mesh3D.finishInsertingCells();
 477         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
 478         mesh3D.setCoords(myCoords3D);
 479         mesh3D.checkConsistencyLight();
 480         #
 481         mesh3D_2=mesh3D.deepCopy();
 482         mesh2D_2=mesh2D.deepCopy();
 483         mesh3D_4=mesh3D.deepCopy();
 484         mesh2D_4=mesh2D.deepCopy();
 485         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
 486         renumNodes=DataArrayInt.New();
 487         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
 488         renumNodes.iota(oldNbOf3DNodes);
 489         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
 490         mesh3D.setCoords(coo);
 491         mesh2D.setCoords(coo);
 492         mesh2DCpy=mesh2D.deepCopy()
 493         mesh2D_3=mesh2D.deepCopy();
 494         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
 495         mesh2D.renumberNodesInConn(renumNodes);
 496         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
 497         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
 498         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
 499         #
 500         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
 501         self.assertTrue(da1==None);
 502         self.assertEqual(8,da2.getNumberOfTuples());
 503         self.assertEqual(1,da2.getNumberOfComponents());
 504         expected1=[8,11,12,9,4,5,6,7]
 505         for i in xrange(8):
 506             self.assertEqual(expected1[i],da2.getIJ(i,0));
 507             pass
 508         #
 509         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
 510         self.assertTrue(da1==None);
 511         self.assertEqual(9,da2.getNumberOfTuples());
 512         self.assertEqual(1,da2.getNumberOfComponents());
 513         for i in xrange(9):
 514             self.assertEqual(8+i,da2.getIJ(i,0));
 515             pass
 516         #
 517         mesh2D_5=mesh2D_4.deepCopy();
 518         mesh2D_5.translate([1.,0.,0.]);
 519         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
 520         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
 521         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
 522         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
 523         mesh3D_4.checkConsistencyLight(); mesh2D_4.checkConsistencyLight(); mesh2D_5.checkConsistencyLight();
 524         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
 525         self.assertEqual(3,mesh3D_4.getSpaceDimension());
 526         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
 527         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
 528         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
 529         expected2=[18,0,1,2,3,4,5,6,7]
 530         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
 531         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
 532         expected5=[-0.3,-0.3,0., -0.3,0.2,0., 0.2,0.2,0., 0.2,-0.3,0., -0.3,-0.3,1., -0.3,0.2,1., 0.2,0.2,1., 0.2,-0.3,1., -0.3,-0.3,0., 0.2,-0.3,0., 0.7,-0.3,0., -0.3,0.2,0., 0.2,0.2,0., 0.7,0.2,0., -0.3,0.7,0., 0.2,0.7,0., 0.7,0.7,0., 0.7, -0.3, 0.0, 1.2, -0.3, 0.0, 1.7, -0.3, 0.0, 0.7, 0.2, 0.0, 1.2, 0.2, 0.0, 1.7, 0.2, 0.0, 0.7, 0.7, 0.0, 1.2, 0.7, 0.0, 1.7, 0.7, 0.0]
 533         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
 534         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
 535         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
 536         for i in xrange(78):
 537             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
 538             pass
 539         #
 540         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
 541         mesh3D_4.checkConsistencyLight(); mesh2D_4.checkConsistencyLight(); mesh2D_5.checkConsistencyLight();
 542         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
 543         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
 544         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
 545         self.assertEqual(3,mesh3D_4.getSpaceDimension());
 546         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
 547         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
 548         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
 549         expected6=[18,0,1,2,3,4,5,6,7]
 550         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
 551         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
 552         expected9=[-0.3, -0.3, 0., -0.3, 0.2, 0., 0.2, 0.2, 0., 0.2, -0.3, 0., -0.3, -0.3, 1., -0.3, 0.2, 1.,
 553                     0.2, 0.2, 1., 0.2, -0.3, 1., 0.7, -0.3, 0., 0.7, 0.2, 0., -0.3, 0.7, 0., 0.2, 0.7, 0.,
 554                     0.7, 0.7, 0., 1.2, -0.3, 0., 1.7, -0.3, 0., 1.2, 0.2, 0., 1.7, 0.2, 0., 1.2, 0.7, 0., 1.7, 0.7, 0.]
 555         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
 556         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
 557         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
 558         for i in xrange(57):
 559             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
 560             pass
 561         #
 562         pass
 563
 564     def testComputeNeighborsOfCells1(self):
 565         m=MEDCouplingDataForTest.build2DTargetMesh_1();
 566         d1,d2=m.computeNeighborsOfCells();
 567         self.assertEqual(6,d2.getNumberOfTuples());
 568         self.assertEqual(10,d1.getNumberOfTuples());
 569         expected1=[0,2,4,6,8,10]
 570         expected2=[3,1,0,2,4,1,4,0,2,3]
 571         self.assertEqual(expected1,d2.getValues());
 572         self.assertEqual(expected2,d1.getValues());
 573         pass
 574
 575     def testCheckButterflyCellsBug1(self):
 576         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
 577         mesh2DConn=[4,1,0,2,3]
 578         mesh2D=MEDCouplingUMesh.New("mesh",2);
 579         mesh2D.allocateCells(1);
 580         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
 581         mesh2D.finishInsertingCells();
 582         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
 583         mesh2D.setCoords(myCoords);
 584         mesh2D.checkConsistencyLight();
 585         #
 586         v=mesh2D.checkButterflyCells();
 587         self.assertTrue(v.empty());
 588         pass
 589
 590     def testDataArrayIntRange1(self):
 591         d=DataArrayInt.Range(2,17,7);
 592         expected1=[2,9,16]
 593         self.assertEqual(3,d.getNumberOfTuples());
 594         self.assertEqual(1,d.getNumberOfComponents());
 595         self.assertEqual(expected1,d.getValues());
 596         #
 597         d=DataArrayInt.Range(2,23,7);
 598         self.assertEqual(3,d.getNumberOfTuples());
 599         self.assertEqual(1,d.getNumberOfComponents());
 600         self.assertEqual(expected1,d.getValues());
 601         #
 602         d=DataArrayInt.Range(2,24,7);
 603         expected2=[2,9,16,23]
 604         self.assertEqual(4,d.getNumberOfTuples());
 605         self.assertEqual(1,d.getNumberOfComponents());
 606         self.assertEqual(expected2,d.getValues());
 607         #
 608         d=DataArrayInt.Range(24,2,-7);
 609         expected3=[24,17,10,3]
 610         self.assertEqual(4,d.getNumberOfTuples());
 611         self.assertEqual(1,d.getNumberOfComponents());
 612         self.assertEqual(expected3,d.getValues());
 613         #
 614         d=DataArrayInt.Range(23,2,-7);
 615         expected4=[23,16,9]
 616         self.assertEqual(3,d.getNumberOfTuples());
 617         self.assertEqual(1,d.getNumberOfComponents());
 618         self.assertEqual(expected4,d.getValues());
 619         #
 620         d=DataArrayInt.Range(23,22,-7);
 621         self.assertEqual(1,d.getNumberOfTuples());
 622         self.assertEqual(1,d.getNumberOfComponents());
 623         self.assertEqual(23,d.getIJ(0,0));
 624         #
 625         d=DataArrayInt.Range(22,23,7);
 626         self.assertEqual(1,d.getNumberOfTuples());
 627         self.assertEqual(1,d.getNumberOfComponents());
 628         self.assertEqual(22,d.getIJ(0,0));
 629         #
 630         d=DataArrayInt.Range(22,22,7);
 631         self.assertEqual(0,d.getNumberOfTuples());
 632         self.assertEqual(1,d.getNumberOfComponents());
 633         #
 634         d=DataArrayInt.Range(22,22,-7);
 635         self.assertEqual(0,d.getNumberOfTuples());
 636         self.assertEqual(1,d.getNumberOfComponents());
 637         #
 638         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
 639         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
 640         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
 641         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
 642         pass
 643
 644     def testSwigUMeshGetItem1(self):
 645         m=MEDCouplingDataForTest.build2DTargetMesh_1();
 646         subMesh=m.buildPartOfMySelf([1,3],True);
 647         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 648         m1=m[[1,3]]
 649         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
 650         m2=m[(1,3)]
 651         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
 652         m3=m[1::2]
 653         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
 654         m4=m[DataArrayInt.New([1,3])]
 655         m5_1=m[1]
 656         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
 657         m5_2=m[3]
 658         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
 659         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
 660         m5.setName(subMesh.getName())
 661         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
 662         self.assertTrue(subMesh.isEqual(m1,1e-12))
 663         self.assertTrue(subMesh.isEqual(m2,1e-12))
 664         self.assertTrue(subMesh.isEqual(m3,1e-12))
 665         self.assertTrue(subMesh.isEqual(m4,1e-12))
 666         self.assertTrue(subMesh.isEqual(m5,1e-12))
 667         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
 668         pass
 669
 670     def testSwigGetItem3(self):
 671         da=DataArrayInt.New([4,5,6])
 672         self.assertEqual(5,da[1])
 673         self.assertEqual(6,da[-1])
 674         self.assertRaises(InterpKernelException,da.__getitem__,3)
 675         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
 676         self.assertEqual(9,da[1,2])
 677         da=DataArrayDouble.New([4.1,5.2,6.3])
 678         self.assertAlmostEqual(5.2,da[1],12)
 679         self.assertAlmostEqual(6.3,da[-1],12)
 680         self.assertRaises(InterpKernelException,da.__getitem__,3)
 681         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
 682         self.assertAlmostEqual(9.12,da[1,2],12)
 683         pass
 684
 685     def testSwigDADISub1(self):
 686         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
 687         bary=mesh3D.computeCellCenterOfMass()
 688         bary=bary[:,:2]
 689         pts=bary.getDifferentValues(1e-12)
 690         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
 691         for pos,pt in enumerate(pts):
 692             bary2=bary[:,:2]
 693             bary2[:]-=pt
 694             norm=bary2.magnitude()
 695             self.assertEqual(expected[pos],norm.findIdsInRange(-1.,1e-5).getValues())
 696             pass
 697         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
 698         for pos,pt in enumerate(pts):
 699             bary2=bary[:,:2]
 700             bary2[:]+=pt
 701             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
 702             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
 703             pass
 704         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
 705         for pos,pt in enumerate(pts):
 706             bary2=bary[:,:2]
 707             bary2[:]*=pt
 708             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
 709             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
 710             pass
 711         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
 712         for pos,pt in enumerate(pts):
 713             bary2=bary[:,:2]
 714             bary2[:]/=pt
 715             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
 716             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
 717             pass
 718         #
 719         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
 720         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
 721         expected5=[[1,11,101,77,77,77,77,77,77,4,14,104],[77,77,77,77,77,77,3,13,103,4,14,104],[77,77,77,2,12,102,77,77,77,4,14,104]]
 722         expected6=[[1,77,77,2,77,77,3,77,77,4,77,77],[77,77,101,77,77,102,77,77,103,77,77,104],[77,11,77,77,12,77,77,13,77,77,14,77]]
 723         for pos,tup in enumerate(d):
 724             f=e[:]
 725             self.assertTrue(isinstance(f,DataArrayInt))
 726             f[tup]=77
 727             self.assertEqual(expected5[pos],f.getValues())
 728             self.assertEqual(6*[77],f[tup].getValues())
 729             f=e[:]
 730             f[:,tup]=77
 731             self.assertEqual(expected6[pos],f.getValues())
 732             self.assertEqual(8*[77],f[:,tup].getValues())
 733             pass
 734         #
 735         e=e.convertToDblArr()
 736         for pos,tup in enumerate(d):
 737             f=e[:]
 738             self.assertTrue(isinstance(f,DataArrayDouble))
 739             f[tup]=77.
 740             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
 741             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
 742             f=e[:]
 743             f[:,tup]=77.
 744             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
 745             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
 746             pass
 747         pass
 748
 749     def testDataArrayDoubleGetMinMaxPerComponent1(self):
 750         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
 751         d1=DataArrayDouble.New();
 752         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
 753         d1=DataArrayDouble.New(values1,4,3);
 754         res=d1.getMinMaxPerComponent();
 755         self.assertTrue(isinstance(res,list))
 756         self.assertEqual(3,len(res))
 757         for i in xrange(3):
 758             self.assertTrue(isinstance(res[i],tuple))
 759             self.assertEqual(2,len(res[i]))
 760             pass
 761         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
 762         for i in xrange(6):
 763             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
 764             pass
 765         #
 766         d1.rearrange(2);
 767         res=d1.getMinMaxPerComponent();
 768         self.assertTrue(isinstance(res,list))
 769         self.assertEqual(2,len(res))
 770         for i in xrange(2):
 771             self.assertTrue(isinstance(res[i],tuple))
 772             self.assertEqual(2,len(res[i]))
 773             pass
 774         expected2=[1.,3.,-0.9,3.]
 775         for i in xrange(4):
 776             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
 777             pass
 778         #
 779         d1.rearrange(1);
 780         res=d1.getMinMaxPerComponent();
 781         self.assertTrue(isinstance(res,list))
 782         self.assertEqual(1,len(res))
 783         for i in xrange(1):
 784             self.assertTrue(isinstance(res[i],tuple))
 785             self.assertEqual(2,len(res[i]))
 786             pass
 787         expected3=[-0.9,3.]
 788         for i in xrange(2):
 789             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
 790             pass
 791         pass
 792
 793     def testDataArrayIntGetHashCode1(self):
 794         d1=DataArrayInt.New(range(3545))
 795         d2=DataArrayInt.New(range(3545))
 796         self.assertEqual(d2.getHashCode(),d1.getHashCode())
 797         self.assertEqual(232341068,d1.getHashCode())
 798         d1[886]=6
 799         self.assertEqual(232340188,d1.getHashCode())
 800         pass
 801
 802     def testZipConnectivityPol1(self):
 803         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 804         cells1=[2,3,4]
 805         m2_1=m1.buildPartOfMySelf(cells1,True);
 806         m2=m2_1
 807         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
 808         # no permutation policy 0
 809         isOk,arr=m1.areCellsIncludedIn(m2,0)
 810         self.assertTrue(isOk);
 811         self.assertEqual(3,arr.getNumberOfTuples());
 812         self.assertEqual(1,arr.getNumberOfComponents());
 813         self.assertEqual(cells1,arr.getValues())
 814         # no permutation policy 1
 815         isOk,arr=m1.areCellsIncludedIn(m2,1)
 816         self.assertTrue(isOk);
 817         self.assertEqual(3,arr.getNumberOfTuples());
 818         self.assertEqual(1,arr.getNumberOfComponents());
 819         self.assertEqual(cells1,arr.getValues())
 820         # no permutation policy 2
 821         isOk,arr=m1.areCellsIncludedIn(m2,2)
 822         self.assertTrue(isOk);
 823         self.assertEqual(3,arr.getNumberOfTuples());
 824         self.assertEqual(1,arr.getNumberOfComponents());
 825         self.assertEqual(cells1,arr.getValues())
 826         # some modification into m2
 827         modif1=[2,4,5]
 828         m2.getNodalConnectivity()[1:4]=modif1
 829         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
 830         expected1=[5,3,4]
 831         isOk,arr=m1.areCellsIncludedIn(m2,0)
 832         self.assertTrue(not isOk);
 833         self.assertEqual(3,arr.getNumberOfTuples());
 834         self.assertEqual(1,arr.getNumberOfComponents());
 835         self.assertEqual(expected1,arr.getValues())
 836         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
 837         isOk,arr=m1.areCellsIncludedIn(m2,1)
 838         self.assertTrue(isOk);
 839         self.assertEqual(3,arr.getNumberOfTuples());
 840         self.assertEqual(1,arr.getNumberOfComponents());
 841         self.assertEqual(cells1,arr.getValues())
 842         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
 843         isOk,arr=m1.areCellsIncludedIn(m2,2)
 844         self.assertTrue(isOk);
 845         self.assertEqual(3,arr.getNumberOfTuples());
 846         self.assertEqual(1,arr.getNumberOfComponents());
 847         self.assertEqual(cells1,arr.getValues())
 848         #some new modification into m2
 849         modif2=[2,5,4]
 850         m2.getNodalConnectivity()[1:4]=modif2
 851         #policy 0 fails because cell0 in m2 has not exactly the same conn
 852         isOk,arr=m1.areCellsIncludedIn(m2,0)
 853         self.assertTrue(not isOk);
 854         self.assertEqual(3,arr.getNumberOfTuples());
 855         self.assertEqual(1,arr.getNumberOfComponents());
 856         self.assertEqual(expected1,arr.getValues())
 857         #policy 1 fails too because cell0 in m2 has not same orientation
 858         isOk,arr=m1.areCellsIncludedIn(m2,1)
 859         self.assertTrue(not isOk);
 860         self.assertEqual(3,arr.getNumberOfTuples());
 861         self.assertEqual(1,arr.getNumberOfComponents());
 862         self.assertEqual(expected1,arr.getValues())
 863         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
 864         isOk,arr=m1.areCellsIncludedIn(m2,2)
 865         self.assertTrue(isOk);
 866         self.assertEqual(3,arr.getNumberOfTuples());
 867         self.assertEqual(1,arr.getNumberOfComponents());
 868         self.assertEqual(cells1,arr.getValues())
 869         # Now 1D
 870         cells2=[3,2]
 871         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
 872         m2_1=m1.buildPartOfMySelf(cells2,True);
 873         m2=m2_1
 874         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
 875         # no permutation policy 0
 876         isOk,arr=m1.areCellsIncludedIn(m2,0)
 877         self.assertTrue(isOk);
 878         self.assertEqual(2,arr.getNumberOfTuples());
 879         self.assertEqual(1,arr.getNumberOfComponents());
 880         self.assertEqual(cells2,arr.getValues())
 881         # no permutation policy 1
 882         isOk,arr=m1.areCellsIncludedIn(m2,1)
 883         self.assertTrue(isOk);
 884         self.assertEqual(2,arr.getNumberOfTuples());
 885         self.assertEqual(1,arr.getNumberOfComponents());
 886         self.assertEqual(cells2,arr.getValues())
 887         # no permutation policy 2
 888         isOk,arr=m1.areCellsIncludedIn(m2,2)
 889         self.assertTrue(isOk);
 890         self.assertEqual(2,arr.getNumberOfTuples());
 891         self.assertEqual(1,arr.getNumberOfComponents());
 892         self.assertEqual(cells2,arr.getValues())
 893         # some modification into m2
 894         modif3=[4,3]
 895         m2.getNodalConnectivity()[1:3]=modif3
 896         #policy 0 fails because cell0 in m2 has not exactly the same conn
 897         expected2=[4,2]
 898         isOk,arr=m1.areCellsIncludedIn(m2,0)
 899         self.assertTrue(not isOk);
 900         self.assertEqual(2,arr.getNumberOfTuples());
 901         self.assertEqual(1,arr.getNumberOfComponents());
 902         self.assertEqual(expected2,arr.getValues())
 903         #policy 1 fails too because cell0 in m2 has not same orientation
 904         isOk,arr=m1.areCellsIncludedIn(m2,1)
 905         self.assertTrue(not isOk);
 906         self.assertEqual(2,arr.getNumberOfTuples());
 907         self.assertEqual(1,arr.getNumberOfComponents());
 908         self.assertEqual(expected2,arr.getValues())
 909         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
 910         isOk,arr=m1.areCellsIncludedIn(m2,2)
 911         self.assertTrue(isOk);
 912         self.assertEqual(2,arr.getNumberOfTuples());
 913         self.assertEqual(1,arr.getNumberOfComponents());
 914         self.assertEqual(cells2,arr.getValues())
 915         pass
 916
 917     def toSeeIfDaIIopsAreOK(self,d):
 918         d+=5
 919         d*=6
 920         d/=3
 921         d-=2
 922         d%=7
 923         pass
 924
 925     def testSwigDAIOp5(self):
 926         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
 927         self.toSeeIfDaIIopsAreOK(d)
 928         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
 929         self.assertTrue(d.isEqual(dExp));
 930         pass
 931
 932     def toSeeIfDaDIopsAreOK(self,d):
 933         d+=5
 934         d*=6
 935         d/=3
 936         d-=2
 937         pass
 938
 939     def testSwigDADOp7(self):
 940         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
 941         self.toSeeIfDaDIopsAreOK(d)
 942         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
 943         self.assertTrue(d.isEqual(dExp,1e-14));
 944         pass
 945
 946     def testConvexEnvelop2D1(self):
 947         coords=[7.54758495819e-14,-1.12270326253e-12,8.43143594193,-1.02835845055e-12,4.21571797096,7.30183771609,-4.21571797097,7.30183771609,-8.43143594193,-1.09439981894e-12,-4.21571797097,-7.30183771609,4.21571797097,-7.30183771609,16.8628718839,-1.02835845055e-12,12.6471539129,7.30183771609,8.43143594193,14.6036754322,2.26427548746e-13,14.6036754322,-8.43143594193,14.6036754322,-12.6471539129,7.30183771609,-16.8628718839,-1.39630321727e-12,-12.6471539129,-7.30183771609,-8.43143594193,-14.6036754322,3.7737924791e-14,-14.6036754322,8.43143594193,-14.6036754322,12.6471539129,-7.30183771609,25.2943078258,-1.07553085654e-12,21.0785898548,7.30183771609,16.8628718839,14.6036754322,12.6471539129,21.9055131483,4.21571797096,21.9055131483,-4.21571797097,21.9055131483,-12.6471539129,21.9055131483,-16.8628718839,14.6036754322,-21.0785898548,7.30183771609,-25.2943078258,-1.02835845055e-12,-21.0785898548,-7.30183771609,-16.8628718839,-14.6036754322,-12.6471539129,-21.9055131483,-4.21571797097,-21.9055131483,4.21571797097,-21.9055131483,12.6471539129,-21.9055131483,16.8628718839,-14.6036754322,21.0785898548,-7.30183771609,33.7257437677,-7.45324014622e-13,29.5100257968,7.30183771609,25.2943078258,14.6036754322,21.0785898548,21.9055131483,16.8628718839,29.2073508644,8.43143594193,29.2073508644,-1.20761359331e-12,29.2073508644,-8.43143594193,29.2073508644,-16.8628718839,29.2073508644,-21.0785898548,21.9055131483,-25.2943078258,14.6036754322,-29.5100257968,7.30183771609,-33.7257437677,-7.26455052226e-13,-29.5100257968,-7.30183771609,-25.2943078258,-14.6036754322,-21.0785898548,-21.9055131483,-16.8628718839,-29.2073508644,-8.43143594193,-29.2073508644,4.15117172701e-13,-29.2073508644,8.43143594193,-29.2073508644,16.8628718839,-29.2073508644,21.0785898548,-21.9055131483,25.2943078258,-14.6036754322,29.5100257968,-7.30183771609,42.1571797097,-1.86802727715e-12,37.9414617387,7.30183771609,33.7257437677,14.6036754322,29.5100257968,21.9055131483,25.2943078258,29.2073508644,21.0785898548,36.5091885805,12.6471539129,36.5091885805,4.21571797096,36.5091885805,-4.21571797096,36.5091885805,-12.6471539129,36.5091885805,-21.0785898548,36.5091885805,-25.2943078258,29.2073508644,-29.5100257968,21.9055131483,-33.7257437677,14.6036754322,-37.9414617387,7.30183771609,-42.1571797097,-9.81186044565e-13,-37.9414617387,-7.30183771609,-33.7257437677,-14.6036754322,-29.5100257968,-21.9055131483,-25.2943078258,-29.2073508644,-21.0785898548,-36.5091885805,-12.6471539129,-36.5091885805,-4.21571797097,-36.5091885805,4.21571797097,-36.5091885805,12.6471539129,-36.5091885805,21.0785898548,-36.5091885805,25.2943078258,-29.2073508644,29.5100257968,-21.9055131483,33.7257437677,-14.6036754322,37.9414617387,-7.30183771609,50.5886156516,-6.98151608633e-13,46.3728976806,7.30183771609,42.1571797097,14.6036754322,37.9414617387,21.9055131483,33.7257437677,29.2073508644,29.5100257968,36.5091885805,25.2943078258,43.8110262966,16.8628718839,43.8110262966,8.43143594193,43.8110262966,-1.84915831476e-12,43.8110262966,-8.43143594193,43.8110262966,-16.8628718839,43.8110262966,-25.2943078258,43.8110262966,-29.5100257968,36.5091885805,-33.7257437677,29.2073508644,-37.9414617387,21.9055131483,-42.1571797097,14.6036754322,-46.3728976806,7.30183771609,-50.5886156516,-1.47177906685e-12,-46.3728976806,-7.30183771609,-42.1571797097,-14.6036754322,-37.9414617387,-21.9055131483,-33.7257437677,-29.2073508644,-29.5100257968,-36.5091885805,-25.2943078258,-43.8110262966,-16.8628718839,-43.8110262966,-8.43143594193,-43.8110262966,7.54758495819e-14,-43.8110262966,8.43143594193,-43.8110262966,16.8628718839,-43.8110262966,25.2943078258,-43.8110262966,29.5100257968,-36.5091885805,33.7257437677,-29.2073508644,37.9414617387,-21.9055131483,42.1571797097,-14.6036754322,46.3728976806,-7.30183771609,59.0200515935,-7.9249642061e-13,54.8043336225,7.30183771609,50.5886156516,14.6036754322,46.3728976806,21.9055131483,42.1571797097,29.2073508644,37.9414617387,36.5091885805,33.7257437677,43.8110262966,29.5100257968,51.1128640127,21.0785898548,51.1128640127,12.6471539129,51.1128640127,4.21571797096,51.1128640127,-4.21571797096,51.1128640127,-12.6471539129,51.1128640127,-21.0785898548,51.1128640127,-29.5100257968,51.1128640127,-33.7257437677,43.8110262966,-37.9414617387,36.5091885805,-42.1571797097,29.2073508644,-46.3728976806,21.9055131483,-50.5886156516,14.6036754322,-54.8043336226,7.30183771609,-59.0200515935,-1.31139288649e-12,-54.8043336226,-7.30183771609,-50.5886156516,-14.6036754322,-46.3728976806,-21.9055131483,-42.1571797097,-29.2073508644,-37.9414617387,-36.5091885805,-33.7257437677,-43.8110262966,-29.5100257968,-51.1128640127,-21.0785898548,-51.1128640127,-12.6471539129,-51.1128640127,-4.21571797097,-51.1128640127,4.21571797097,-51.1128640127,12.6471539129,-51.1128640127,21.0785898548,-51.1128640127,29.5100257968,-51.1128640127,33.7257437677,-43.8110262966,37.9414617387,-36.5091885805,42.1571797097,-29.2073508644,46.3728976806,-21.9055131483,50.5886156516,-14.6036754322,54.8043336225,-7.30183771609,67.4514875354,-2.14162723189e-12,63.2357695645,7.30183771609,59.0200515935,14.6036754322,54.8043336226,21.9055131483,50.5886156516,29.2073508644,46.3728976806,36.5091885805,42.1571797097,43.8110262966,37.9414617387,51.1128640127,33.7257437677,58.4147017287,25.2943078258,58.4147017287,16.8628718839,58.4147017287,8.43143594193,58.4147017287,6.79282646237e-13,58.4147017287,-8.43143594193,58.4147017287,-16.8628718839,58.4147017287,-25.2943078258,58.4147017287,-33.7257437677,58.4147017287,-37.9414617387,51.1128640127,-42.1571797097,43.8110262966,-46.3728976806,36.5091885805,-50.5886156516,29.2073508644,-54.8043336226,21.9055131483,-59.0200515935,14.6036754322,-63.2357695645,7.30183771609,-67.4514875354,-1.16044118732e-12,-63.2357695645,-7.30183771609,-59.0200515935,-14.6036754322,-54.8043336226,-21.9055131483,-50.5886156516,-29.2073508644,-46.3728976806,-36.5091885805,-42.1571797097,-43.8110262966,-37.9414617387,-51.1128640127,-33.7257437677,-58.4147017287,-25.2943078258,-58.4147017287,-16.8628718839,-58.4147017287,-8.43143594193,-58.4147017287,-5.66068871864e-14,-58.4147017287,8.43143594193,-58.4147017287,16.8628718839,-58.4147017287,25.2943078258,-58.4147017287,33.7257437677,-58.4147017287,37.9414617387,-51.1128640127,42.1571797097,-43.8110262966,46.3728976806,-36.5091885805,50.5886156516,-29.2073508644,54.8043336226,-21.9055131483,59.0200515935,-14.6036754322,63.2357695645,-7.30183771609,75.8829234774,-2.29257893105e-12,71.6672055064,7.30183771609,67.4514875354,14.6036754322,63.2357695645,21.9055131483,59.0200515935,29.2073508644,54.8043336226,36.5091885805,50.5886156516,43.8110262966,46.3728976806,51.1128640127,42.1571797097,58.4147017287,37.9414617387,65.7165394448,29.5100257968,65.7165394448,21.0785898548,65.7165394448,12.6471539129,65.7165394448,4.21571797097,65.7165394448,-4.21571797096,65.7165394448,-12.6471539129,65.7165394448,-21.0785898548,65.7165394448,-29.5100257968,65.7165394448,-37.9414617387,65.7165394448,-42.1571797097,58.4147017287,-46.3728976806,51.1128640127,-50.5886156516,43.8110262966,-54.8043336226,36.5091885805,-59.0200515935,29.2073508644,-63.2357695645,21.9055131483,-67.4514875354,14.6036754322,-71.6672055064,7.30183771609,-75.8829234774,-1.31139288649e-12,-71.6672055064,-7.30183771609,-67.4514875354,-14.6036754322,-63.2357695645,-21.9055131483,-59.0200515935,-29.2073508644,-54.8043336226,-36.5091885805,-50.5886156516,-43.8110262966,-46.3728976806,-51.1128640127,-42.1571797097,-58.4147017287,-37.9414617387,-65.7165394448,-29.5100257968,-65.7165394448,-21.0785898548,-65.7165394448,-12.6471539129,-65.7165394448,-4.21571797097,-65.7165394448,4.21571797097,-65.7165394448,12.6471539129,-65.7165394448,21.0785898548,-65.7165394448,29.5100257968,-65.7165394448,37.9414617387,-65.7165394448,42.1571797097,-58.4147017287,46.3728976806,-51.1128640127,50.5886156516,-43.8110262966,54.8043336226,-36.5091885805,59.0200515935,-29.2073508644,63.2357695645,-21.9055131483,67.4514875354,-14.6036754322,71.6672055064,-7.30183771609,84.3143594193,-1.49064802924e-12,80.0986414483,7.30183771609,75.8829234774,14.6036754322,71.6672055064,21.9055131483,67.4514875354,29.2073508644,63.2357695645,36.5091885805,59.0200515935,43.8110262966,54.8043336226,51.1128640127,50.5886156516,58.4147017287,46.3728976806,65.7165394448,42.1571797097,73.0183771609,33.7257437677,73.0183771609,25.2943078258,73.0183771609,16.8628718839,73.0183771609,8.43143594193,73.0183771609,2.0755858635e-12,73.0183771609,-8.43143594193,73.0183771609,-16.8628718839,73.0183771609,-25.2943078258,73.0183771609,-33.7257437677,73.0183771609,-42.1571797097,73.0183771609,-46.3728976806,65.7165394448,-50.5886156516,58.4147017287,-54.8043336226,51.1128640127,-59.0200515935,43.8110262966,-63.2357695645,36.5091885805,-67.4514875354,29.2073508644,-71.6672055064,21.9055131483,-75.8829234774,14.6036754322,-80.0986414483,7.30183771609,-84.3143594193,-1.11326878133e-12,-80.0986414483,-7.30183771609,-75.8829234774,-14.6036754322,-71.6672055064,-21.9055131483,-67.4514875354,-29.2073508644,-63.2357695645,-36.5091885805,-59.0200515935,-43.8110262966,-54.8043336226,-51.1128640127,-50.5886156516,-58.4147017287,-46.3728976806,-65.7165394448,-42.1571797097,-73.0183771609,-33.7257437677,-73.0183771609,-25.2943078258,-73.0183771609,-16.8628718839,-73.0183771609,-8.43143594193,-73.0183771609,-5.66068871864e-14,-73.0183771609,8.43143594193,-73.0183771609,16.8628718839,-73.0183771609,25.2943078258,-73.0183771609,33.7257437677,-73.0183771609,42.1571797097,-73.0183771609,46.3728976806,-65.7165394448,50.5886156516,-58.4147017287,54.8043336226,-51.1128640127,59.0200515935,-43.8110262966,63.2357695645,-36.5091885805,67.4514875354,-29.2073508644,71.6672055064,-21.9055131483,75.8829234774,-14.6036754322,80.0986414483,-7.3018377161]
 948         conn=[0,2,3,4,5,6,1,1,8,2,0,6,18,7,2,9,10,3,0,1,8,3,10,11,12,4,0,2,4,3,12,13,14,5,0,5,0,4,14,15,16,6,6,1,0,5,16,17,18,7,20,8,1,18,36,19,8,21,9,2,1,7,20,9,22,23,10,2,8,21,10,23,24,11,3,2,9,11,24,25,26,12,3,10,12,11,26,27,13,4,3,13,12,27,28,29,14,4,14,4,13,29,30,15,5,15,5,14,30,31,32,16,16,6,5,15,32,33,17,17,18,6,16,33,34,35,18,7,1,6,17,35,36,19,38,20,7,36,60,37,20,39,21,8,7,19,38,21,40,22,9,8,20,39,22,41,42,23,9,21,40,23,42,43,24,10,9,22,24,43,44,25,11,10,23,25,44,45,46,26,11,24,26,25,46,47,27,12,11,27,26,47,48,28,13,12,28,27,48,49,50,29,13,29,13,28,50,51,30,14,30,14,29,51,52,31,15,31,15,30,52,53,54,32,32,16,15,31,54,55,33,33,17,16,32,55,56,34,34,35,17,33,56,57,58,35,36,18,17,34,58,59,36,19,7,18,35,59,60,37,62,38,19,60,90,61,38,63,39,20,19,37,62,39,64,40,21,20,38,63,40,65,41,22,21,39,64,41,66,67,42,22,40,65,42,67,68,43,23,22,41,43,68,69,44,24,23,42,44,69,70,45,25,24,43,45,70,71,72,46,25,44,46,45,72,73,47,26,25,47,46,73,74,48,27,26,48,47,74,75,49,28,27,49,48,75,76,77,50,28,50,28,49,77,78,51,29,51,29,50,78,79,52,30,52,30,51,79,80,53,31,53,31,52,80,81,82,54,54,32,31,53,82,83,55,55,33,32,54,83,84,56,56,34,33,55,84,85,57,57,58,34,56,85,86,87,58,59,35,34,57,87,88,59,60,36,35,58,88,89,60,37,19,36,59,89,90,61,92,62,37,90,126,91,62,93,63,38,37,61,92,63,94,64,39,38,62,93,64,95,65,40,39,63,94,65,96,66,41,40,64,95,66,97,98,67,41,65,96,67,98,99,68,42,41,66,68,99,100,69,43,42,67,69,100,101,70,44,43,68,70,101,102,71,45,44,69,71,102,103,104,72,45,70,72,71,104,105,73,46,45,73,72,105,106,74,47,46,74,73,106,107,75,48,47,75,74,107,108,76,49,48,76,75,108,109,110,77,49,77,49,76,110,111,78,50,78,50,77,111,112,79,51,79,51,78,112,113,80,52,80,52,79,113,114,81,53,81,53,80,114,115,116,82,82,54,53,81,116,117,83,83,55,54,82,117,118,84,84,56,55,83,118,119,85,85,57,56,84,119,120,86,86,87,57,85,120,121,122,87,88,58,57,86,122,123,88,89,59,58,87,123,124,89,90,60,59,88,124,125,90,61,37,60,89,125,126,91,128,92,61,126,168,127,92,129,93,62,61,91,128,93,130,94,63,62,92,129,94,131,95,64,63,93,130,95,132,96,65,64,94,131,96,133,97,66,65,95,132,97,134,135,98,66,96,133,98,135,136,99,67,66,97,99,136,137,100,68,67,98,100,137,138,101,69,68,99,101,138,139,102,70,69,100,102,139,140,103,71,70,101,103,140,141,142,104,71,102,104,103,142,143,105,72,71,105,104,143,144,106,73,72,106,105,144,145,107,74,73,107,106,145,146,108,75,74,108,107,146,147,109,76,75,109,108,147,148,149,110,76,110,76,109,149,150,111,77,111,77,110,150,151,112,78,112,78,111,151,152,113,79,113,79,112,152,153,114,80,114,80,113,153,154,115,81,115,81,114,154,155,156,116,116,82,81,115,156,157,117,117,83,82,116,157,158,118,118,84,83,117,158,159,119,119,85,84,118,159,160,120,120,86,85,119,160,161,121,121,122,86,120,161,162,163,122,123,87,86,121,163,164,123,124,88,87,122,164,165,124,125,89,88,123,165,166,125,126,90,89,124,166,167,126,91,61,90,125,167,168,127,170,128,91,168,216,169,128,171,129,92,91,127,170,129,172,130,93,92,128,171,130,173,131,94,93,129,172,131,174,132,95,94,130,173,132,175,133,96,95,131,174,133,176,134,97,96,132,175,134,177,178,135,97,133,176,135,178,179,136,98,97,134,136,179,180,137,99,98,135,137,180,181,138,100,99,136,138,181,182,139,101,100,137,139,182,183,140,102,101,138,140,183,184,141,103,102,139,141,184,185,186,142,103,140,142,141,186,187,143,104,103,143,142,187,188,144,105,104,144,143,188,189,145,106,105,145,144,189,190,146,107,106,146,145,190,191,147,108,107,147,146,191,192,148,109,108,148,147,192,193,194,149,109,149,109,148,194,195,150,110,150,110,149,195,196,151,111,151,111,150,196,197,152,112,152,112,151,197,198,153,113,153,113,152,198,199,154,114,154,114,153,199,200,155,115,155,115,154,200,201,202,156,156,116,115,155,202,203,157,157,117,116,156,203,204,158,158,118,117,157,204,205,159,159,119,118,158,205,206,160,160,120,119,159,206,207,161,161,121,120,160,207,208,162,162,163,121,161,208,209,210,163,164,122,121,162,210,211,164,165,123,122,163,211,212,165,166,124,123,164,212,213,166,167,125,124,165,213,214,167,168,126,125,166,214,215,168,127,91,126,167,215,216,169,218,170,127,216,270,217,170,219,171,128,127,169,218,171,220,172,129,128,170,219,172,221,173,130,129,171,220,173,222,174,131,130,172,221,174,223,175,132,131,173,222,175,224,176,133,132,174,223,176,225,177,134,133,175,224,177,226,227,178,134,176,225,178,227,228,179,135,134,177,179,228,229,180,136,135,178,180,229,230,181,137,136,179,181,230,231,182,138,137,180,182,231,232,183,139,138,181,183,232,233,184,140,139,182,184,233,234,185,141,140,183,185,234,235,236,186,141,184,186,185,236,237,187,142,141,187,186,237,238,188,143,142,188,187,238,239,189,144,143,189,188,239,240,190,145,144,190,189,240,241,191,146,145,191,190,241,242,192,147,146,192,191,242,243,193,148,147,193,192,243,244,245,194,148,194,148,193,245,246,195,149,195,149,194,246,247,196,150,196,150,195,247,248,197,151,197,151,196,248,249,198,152,198,152,197,249,250,199,153,199,153,198,250,251,200,154,200,154,199,251,252,201,155,201,155,200,252,253,254,202,202,156,155,201,254,255,203,203,157,156,202,255,256,204,204,158,157,203,256,257,205,205,159,158,204,257,258,206,206,160,159,205,258,259,207,207,161,160,206,259,260,208,208,162,161,207,260,261,209,209,210,162,208,261,262,263,210,211,163,162,209,263,264,211,212,164,163,210,264,265,212,213,165,164,211,265,266,213,214,166,165,212,266,267,214,215,167,166,213,267,268,215,216,168,167,214,268,269,216,169,127,168,215,269,270,217,272,218,169,270,330,271,218,273,219,170,169,217,272,219,274,220,171,170,218,273,220,275,221,172,171,219,274,221,276,222,173,172,220,275,222,277,223,174,173,221,276,223,278,224,175,174,222,277,224,279,225,176,175,223,278,225,280,226,177,176,224,279,226,281,282,227,177,225,280,227,282,283,228,178,177,226,228,283,284,229,179,178,227,229,284,285,230,180,179,228,230,285,286,231,181,180,229,231,286,287,232,182,181,230,232,287,288,233,183,182,231,233,288,289,234,184,183,232,234,289,290,235,185,184,233,235,290,291,292,236,185,234,236,235,292,293,237,186,185,237,236,293,294,238,187,186,238,237,294,295,239,188,187,239,238,295,296,240,189,188,240,239,296,297,241,190,189,241,240,297,298,242,191,190,242,241,298,299,243,192,191,243,242,299,300,244,193,192,244,243,300,301,302,245,193,245,193,244,302,303,246,194,246,194,245,303,304,247,195,247,195,246,304,305,248,196,248,196,247,305,306,249,197,249,197,248,306,307,250,198,250,198,249,307,308,251,199,251,199,250,308,309,252,200,252,200,251,309,310,253,201,253,201,252,310,311,312,254,254,202,201,253,312,313,255,255,203,202,254,313,314,256,256,204,203,255,314,315,257,257,205,204,256,315,316,258,258,206,205,257,316,317,259,259,207,206,258,317,318,260,260,208,207,259,318,319,261,261,209,208,260,319,320,262,262,263,209,261,320,321,322,263,264,210,209,262,322,323,264,265,211,210,263,323,324,265,266,212,211,264,324,325,266,267,213,212,265,325,326,267,268,214,213,266,326,327,268,269,215,214,267,327,328,269,270,216,215,268,328,329,270,217,169,216,269,329,330,271,272,217,330,273,218,217,271,274,219,218,272,275,220,219,273,276,221,220,274,277,222,221,275,278,223,222,276,279,224,223,277,280,225,224,278,281,226,225,279,281,282,226,280,283,227,226,281,284,228,227,282,285,229,228,283,286,230,229,284,287,231,230,285,288,232,231,286,289,233,232,287,290,234,233,288,291,235,234,289,291,292,235,290,291,293,236,235,292,294,237,236,293,295,238,237,294,296,239,238,295,297,240,239,296,298,241,240,297,299,242,241,298,300,243,242,299,301,244,243,301,300,302,244,244,301,303,245,245,302,304,246,246,303,305,247,247,304,306,248,248,305,307,249,249,306,308,250,250,307,309,251,251,308,310,252,252,309,311,253,311,253,310,312,254,253,311,313,255,254,312,314,256,255,313,315,257,256,314,316,258,257,315,317,259,258,316,318,260,259,317,319,261,260,318,320,262,261,319,321,321,322,262,320,323,263,262,321,324,264,263,322,325,265,264,323,326,266,265,324,327,267,266,325,328,268,267,326,329,269,268,327,330,270,269,328,271,217,270,329]
 949         connI=[0,7,14,21,28,35,42,49,56,63,70,77,84,91,98,105,112,119,126,133,140,147,154,161,168,175,182,189,196,203,210,217,224,231,238,245,252,259,266,273,280,287,294,301,308,315,322,329,336,343,350,357,364,371,378,385,392,399,406,413,420,427,434,441,448,455,462,469,476,483,490,497,504,511,518,525,532,539,546,553,560,567,574,581,588,595,602,609,616,623,630,637,644,651,658,665,672,679,686,693,700,707,714,721,728,735,742,749,756,763,770,777,784,791,798,805,812,819,826,833,840,847,854,861,868,875,882,889,896,903,910,917,924,931,938,945,952,959,966,973,980,987,994,1001,1008,1015,1022,1029,1036,1043,1050,1057,1064,1071,1078,1085,1092,1099,1106,1113,1120,1127,1134,1141,1148,1155,1162,1169,1176,1183,1190,1197,1204,1211,1218,1225,1232,1239,1246,1253,1260,1267,1274,1281,1288,1295,1302,1309,1316,1323,1330,1337,1344,1351,1358,1365,1372,1379,1386,1393,1400,1407,1414,1421,1428,1435,1442,1449,1456,1463,1470,1477,1484,1491,1498,1505,1512,1519,1526,1533,1540,1547,1554,1561,1568,1575,1582,1589,1596,1603,1610,1617,1624,1631,1638,1645,1652,1659,1666,1673,1680,1687,1694,1701,1708,1715,1722,1729,1736,1743,1750,1757,1764,1771,1778,1785,1792,1799,1806,1813,1820,1827,1834,1841,1848,1855,1862,1869,1876,1883,1890,1897,1901,1905,1909,1913,1917,1921,1925,1929,1933,1937,1941,1945,1949,1953,1957,1961,1965,1969,1973,1977,1981,1985,1989,1993,1997,2001,2005,2009,2013,2017,2021,2025,2029,2033,2037,2041,2045,2049,2053,2057,2061,2065,2069,2073,2077,2081,2085,2089,2093,2097,2101,2105,2109,2113,2117,2121,2125,2129,2133,2137]
 950         #
 951         m=MEDCouplingUMesh.New("convexhull",2);
 952         m.allocateCells(331);
 953         for i in xrange(331):
 954             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
 955             pass
 956         m.finishInsertingCells();
 957         coordsDa=DataArrayDouble.New(coords,331,2);
 958         m.setCoords(coordsDa);
 959         m.checkConsistencyLight();
 960         #
 961         da=m.convexEnvelop2D();
 962         m.checkConsistencyLight()
 963         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
 964         daC=da.buildComplement(m.getNumberOfCells());
 965         expected2=DataArrayInt.New([271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,302,303,304,305,306,307,308,309,310,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330]);
 966         self.assertTrue(expected2.isEqual(daC));
 967         #
 968         vals=m.getMeasureField(False).getArray()
 969         ref=271*[184.69493088478035]+3*[-61.564976961404426,-92.34746544254946,-92.34746544259811,-92.34746544253488,-92.3474654425349,-92.34746544180479,-92.34746544253493,-92.3474654419026,-92.34746544190256,-92.34746544253491]+2*[61.564976961404426,-92.34746544254946,-92.34746544259811,-92.34746544253488,-92.3474654425349,-92.34746544180479,-92.34746544253493,-92.3474654419026,-92.34746544190256,-92.34746544253491]+[-61.564976961404426,-92.34746544254946,-92.34746544259811,-92.34746544253488,-92.3474654425349,-92.34746544180479,-92.34746544253493,-92.3474654419026,-92.34746544190256,-92.34746544253491]
 970         vals-=DataArrayDouble.New(ref)
 971         vals.abs()
 972         theTest=vals.findIdsInRange(-1.,1e-7)
 973         self.assertTrue(theTest.isIota(331))
 974         pass
 975
 976     def testSwigDAIOp8(self):
 977         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
 978         self.assertTrue(7 in da)
 979         self.assertTrue(47 in da)
 980         self.assertTrue(15 in da)
 981         self.assertEqual(0,da.index(7))
 982         self.assertEqual(10,da.index(47))
 983         self.assertTrue(14 not in da)
 984         self.assertEqual(5,da.findIdSequence([9,9]))
 985         self.assertEqual(-1,da.findIdSequence([5,8]))
 986         da.rearrange(2)
 987         self.assertTrue([47,16] not in da)
 988         self.assertTrue([5,6] not in da)
 989         self.assertTrue([6,7] in da)
 990         self.assertEqual(4,da.index([12,13]))
 991         pass
 992
 993     def testDataArraySort1(self):
 994         arr=DataArrayInt.New();
 995         self.assertRaises(InterpKernelException,arr.sort,True)
 996         self.assertRaises(InterpKernelException,arr.sort,False)
 997         values=[2,1,6,5,4,7]
 998         arr.alloc(3,2);
 999         self.assertRaises(InterpKernelException,arr.sort,True)
1000         self.assertRaises(InterpKernelException,arr.sort,False)
1001         arr.rearrange(1);
1002         arr.setValues(values,6,1)
1003         arr1=arr.deepCopy();
1004         arr2=arr.deepCopy();
1005         arr1.sort(True);
1006         expected1=[1,2,4,5,6,7]
1007         self.assertEqual(6,arr1.getNumberOfTuples());
1008         self.assertEqual(1,arr1.getNumberOfComponents());
1009         self.assertEqual(expected1,arr1.getValues());
1010         arr2.sort(False);
1011         expected2=[7,6,5,4,2,1]
1012         self.assertEqual(6,arr2.getNumberOfTuples());
1013         self.assertEqual(1,arr2.getNumberOfComponents());
1014         self.assertTrue(expected2,arr2.getValues());
1015         #
1016         ard=DataArrayDouble.New();
1017         self.assertRaises(InterpKernelException,ard.sort,True)
1018         self.assertRaises(InterpKernelException,ard.sort,False)
1019         valuesD=[2.,1.,6.,5.,4.,7.]
1020         ard.alloc(3,2);
1021         self.assertRaises(InterpKernelException,ard.sort,True)
1022         self.assertRaises(InterpKernelException,ard.sort,False)
1023         ard.rearrange(1);
1024         ard.setValues(valuesD,6,1)
1025         ard1=ard.deepCopy();
1026         ard2=ard.deepCopy();
1027         ard1.sort(True);
1028         expected3=[1.,2.,4.,5.,6.,7.]
1029         self.assertEqual(6,ard1.getNumberOfTuples());
1030         self.assertEqual(1,ard1.getNumberOfComponents());
1031         for i in xrange(6):
1032             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
1033             pass
1034         ard2.sort(False);
1035         expected4=[7.,6.,5.,4.,2.,1.]
1036         self.assertEqual(6,ard2.getNumberOfTuples());
1037         self.assertEqual(1,ard2.getNumberOfComponents());
1038         for i in xrange(6):
1039             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
1040             pass
1041         pass
1042
1043     def testPartitionBySpreadZone1(self):
1044         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1045         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
1046         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
1047         #
1048         v2=m4.partitionBySpreadZone();
1049         self.assertTrue(3,len(v2));
1050         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
1051         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
1052         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
1053         #
1054         m5=m4.buildSpreadZonesWithPoly();
1055         self.assertEqual(3,m5.getNumberOfCells());
1056         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
1057         self.assertEqual([5,15,16,17,14,11,13,12,5,2,1,0,3,6,7,8,5,5,18,21,22,20,19],m5.getNodalConnectivity().getValues())
1058         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
1059         #
1060         pass
1061
1062     def testGiveCellsWithType1(self):
1063         expected0=[1,2]
1064         expected1=[0,3,4]
1065         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1066         da=m.giveCellsWithType(NORM_TRI3);
1067         self.assertEqual(2,da.getNumberOfTuples());
1068         self.assertEqual(1,da.getNumberOfComponents());
1069         self.assertEqual(expected0,da.getValues())
1070         #
1071         da=m.giveCellsWithType(NORM_QUAD4);
1072         self.assertEqual(3,da.getNumberOfTuples());
1073         self.assertEqual(1,da.getNumberOfComponents());
1074         self.assertEqual(expected1,da.getValues())
1075         #
1076         da=m.giveCellsWithType(NORM_TRI6);
1077         self.assertEqual(0,da.getNumberOfTuples());
1078         self.assertEqual(1,da.getNumberOfComponents());
1079         #
1080         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
1081         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
1082         pass
1083
1084     def testSwigDAOp1(self):
1085         d=DataArrayDouble.New(5,2)
1086         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
1087         d.setInfoOnComponents(["X [m]","Y [m]"])
1088         d.setName("AName")
1089         #
1090         d1=d+[8,9]
1091         self.assertTrue(d1.isEqualWithoutConsideringStr(DataArrayDouble.New([10.0,12.0,12.0,14.0,14.0,16.0,16.0,18.0,18.0,20.0]),1e-12))
1092         d1bis=DataArrayDouble.New([8,9],1,2)+d
1093         self.assertTrue(d1bis.isEqual(d1,1e-12))
1094         d1ter=[8,9]+d
1095         self.assertTrue(d1ter.isEqual(d1,1e-12))
1096         #
1097         d2=d1-[8,9]
1098         self.assertTrue(d2.isEqual(d,1e-12))
1099         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
1100         #
1101         d3=d*[8,9]
1102         self.assertTrue(d3.isEqualWithoutConsideringStr(DataArrayDouble.New([16.0,27.0,32.0,45.0,48.0,63.0,64.0,81.0,80.0,99.0]),1e-12))
1103         d3bis=DataArrayDouble.New([8,9],1,2)*d
1104         self.assertTrue(d3bis.isEqual(d3,1e-12))
1105         d3ter=[8,9]*d
1106         self.assertTrue(d3ter.isEqual(d3,1e-12))
1107         #
1108         d4=d3/[8,9]
1109         self.assertTrue(d4.isEqual(d,1e-12))
1110         #
1111         d=DataArrayInt.New(5,2)
1112         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
1113         d.setInfoOnComponents(["X [m]","Y [m]"])
1114         d.setName("AName")
1115         #
1116         d1=d+[8,9]
1117         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
1118         d1bis=DataArrayInt.New([8,9],1,2)+d
1119         self.assertTrue(d1bis.isEqual(d1))
1120         d1ter=[8,9]+d
1121         self.assertTrue(d1ter.isEqual(d1))
1122         #
1123         d2=d1-[8,9]
1124         self.assertTrue(d2.isEqual(d))
1125         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
1126         #
1127         d3=d*[8,9]
1128         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
1129         d3bis=DataArrayInt.New([8,9],1,2)*d
1130         self.assertTrue(d3bis.isEqual(d3))
1131         d3ter=[8,9]*d
1132         self.assertTrue(d3ter.isEqual(d3))
1133         #
1134         d4=d3/[8,9]
1135         self.assertTrue(d4.isEqual(d))
1136         #
1137         d5=d%[4,5]
1138         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
1139         pass
1140
1141     def testSwigSelectTupleId2DAIBug1(self):
1142         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
1143         self.assertEqual([2,6,10],da[2::6].getValues())
1144         self.assertEqual([0,4,8],da[::6].getValues())
1145         self.assertEqual([5,9],da[7::6].getValues())
1146         self.assertEqual([5],da[7:-5:6].getValues())
1147         pass
1148
1149     def testSwigCpp5Safe1(self):
1150         m=MEDCouplingUMesh.New("toto",2)
1151         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
1152         m.setCoords(coords)
1153         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
1154         expected1=[[2.,3.,3.,3.,3.,4.,2.,4.0],[4.,5.,5.,5.,5.,6.,4.,6.0],[6.,7.,7.,7.,7.,8.,6.,8.0]]
1155         for pos,vec in enumerate(vecs):
1156             m2=m.deepCopy()
1157             m2.translate(vec)
1158             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
1159             pass
1160         for pos,vec in enumerate(vecs):
1161             m2=m.deepCopy()
1162             m2.translate(vec.buildDADouble())
1163             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
1164             pass
1165         pass
1166
1167     def testSwigBugNonRegressionZipDA(self):
1168         angles=map(lambda x:pi/3*x,xrange(6))
1169         radius=3
1170         #
1171         dad=DataArrayDouble.New(6, 2)
1172         dad[:,0]=radius
1173         dad[:,1]=angles
1174         #
1175         dad2=dad.fromPolarToCart()
1176         dads=[dad2.deepCopy() for elt in 7*[None]]
1177         #
1178         translationToPerform=[[0.01,0.02],[3./2.*radius,-radius*sqrt(3.)/2],[3./2.*radius,radius*sqrt(3.)/2],[0.,radius*sqrt(3.)],[-3./2.*radius,radius*sqrt(3.)/2],[-3./2.*radius,-radius*sqrt(3.)/2],[0.,-radius*sqrt(3.)]]
1179         for d,t in zip(dads,translationToPerform):
1180             d+=t
1181             pass
1182         for elt in dads:
1183             self.assertTrue(not dad2.isEqual(elt,1e-12))
1184             pass
1185         for d,t in zip(dads,translationToPerform):
1186             d-=t
1187             pass
1188         for elt in dads:
1189             self.assertTrue(dad2.isEqual(elt,1e-12))
1190             pass
1191         pass
1192
1193     def testBuildSlice3D2(self):
1194         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1195         vec1=[-0.07,1.,0.07]
1196         origin1=[1.524,1.4552,1.74768]
1197         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
1198         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
1199         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
1200         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
1201         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
1202         f.setArray(arr)
1203         f.checkConsistencyLight()
1204         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
1205         self.assertTrue(expected1.isEqual(ids))
1206         arr2=arr[expected1]
1207         #
1208         f2=f.extractSlice3D(origin1,vec1,1e-10)
1209         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
1210         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
1211         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
1212         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
1213         pass
1214
1215     def testComputeTupleIdsToSelectFromCellIds1(self):
1216         m=MEDCouplingDataForTest.build2DTargetMesh_3()
1217         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
1218         f.setMesh(m);
1219         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
1220         f.setArray(arr)
1221         #
1222         f2=f.buildSubPart([1,5,9])
1223         f2.checkConsistencyLight()
1224         cI=m.computeNbOfNodesPerCell()
1225         cI.computeOffsetsFull()
1226         sel=DataArrayInt([1,5,9])
1227         res=sel.buildExplicitArrByRanges(cI)
1228         arr2=arr[res]
1229         self.assertTrue(arr2.isEqual(DataArrayDouble([13,14,15,16,17,18,19,20,59,60,61,62,63,64,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110],15,2),1e-12))
1230         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
1231         pass
1232
1233     def testComputeSkin1(self):
1234         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
1235         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
1236         umesh=cmesh.buildUnstructured()
1237         #
1238         skin=umesh.computeSkin()
1239         self.assertEqual(18,skin.getNumberOfCells())
1240         self.assertEqual(1,skin.getMeshDimension())
1241         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
1242         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
1243         self.assertEqual([1,1,0,1,0,5,1,2,1,1,3,2,1,4,3,1,9,4,1,5,10,1,14,9,1,10,15,1,19,14,1,15,20,1,24,19,1,20,25,1,25,26,1,26,27,1,27,28,1,28,29,1,29,24],skin.getNodalConnectivity().getValues())
1244         ids=skin.computeFetchedNodeIds()
1245         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
1246         part=umesh.buildFacePartOfMySelfNode(ids,True)
1247         part.setName(skin.getName());
1248         self.assertTrue(part.isEqual(skin,1e-12))
1249         part2=part[1::2]
1250         part[::2]=part2
1251         self.assertTrue(not part.isEqual(skin,1e-12))
1252         trad=part.zipConnectivityTraducer(0)
1253         self.assertEqual(9,part.getNumberOfCells())
1254         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
1255         pass
1256
1257     def testUMeshSetPartOfMySelf2(self):
1258         # resize with explicit ids list
1259         m=MEDCouplingDataForTest.build2DTargetMesh_1()
1260         self.assertEqual([3,4],m.getAllGeoTypes())
1261         part=m[[0,3,4]]
1262         part.simplexize(0)
1263         part2=part[[1,2,5]]
1264         m[[0,3,4]]=part2
1265         self.assertEqual([3,0,4,1,3,1,4,2,3,4,5,2,3,6,7,4,3,7,5,4],m.getNodalConnectivity().getValues())
1266         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
1267         self.assertEqual([3],m.getAllGeoTypes())
1268         # no resize with explicit ids list
1269         m=MEDCouplingDataForTest.build2DTargetMesh_1()
1270         part=m[[0,3]]
1271         part.convertAllToPoly()
1272         m[[3,4]]=part
1273         self.assertEqual([4,0,3,4,1,3,1,4,2,3,4,5,2,5,0,3,4,1,5,6,7,4,3],m.getNodalConnectivity().getValues())
1274         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
1275         self.assertEqual([3,4,5],m.getAllGeoTypes())
1276         # resize with range ids
1277         m=MEDCouplingDataForTest.build2DTargetMesh_1()
1278         part=m[3:]
1279         m[1:3]=part
1280         self.assertEqual([4,0,3,4,1,4,6,7,4,3,4,7,8,5,4,4,6,7,4,3,4,7,8,5,4],m.getNodalConnectivity().getValues())
1281         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
1282         self.assertEqual([4],m.getAllGeoTypes())
1283         # no resize with range ids
1284         m=MEDCouplingDataForTest.build2DTargetMesh_1()
1285         part=m[0::3]
1286         part.convertAllToPoly()
1287         m[3:]=part
1288         self.assertEqual([4,0,3,4,1,3,1,4,2,3,4,5,2,5,0,3,4,1,5,6,7,4,3],m.getNodalConnectivity().getValues())
1289         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
1290         self.assertEqual([3,4,5],m.getAllGeoTypes())
1291         # no resize with range ids negative direction
1292         m=MEDCouplingDataForTest.build2DTargetMesh_1()
1293         part=m[3::-3]
1294         part.convertAllToPoly()
1295         m[:-3:-1]=part
1296         self.assertEqual([4,0,3,4,1,3,1,4,2,3,4,5,2,5,0,3,4,1,5,6,7,4,3],m.getNodalConnectivity().getValues())
1297         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
1298         self.assertEqual([3,4,5],m.getAllGeoTypes())
1299         pass
1300
1301     def testUnPolyze3(self):
1302         coord=[0.0,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5,0.0,0.5,0.5,-0.5,-0.5,0.5,0.5,-0.5,0.5]
1303         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
1304         m=MEDCouplingUMesh.New("a mesh",3);
1305         m.allocateCells(1);
1306         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
1307         m.finishInsertingCells();
1308         coords=DataArrayDouble(coord,6,3);
1309         m.setCoords(coords);
1310         m.checkConsistencyLight();
1311         #
1312         vol=m.getMeasureField(False);
1313         self.assertEqual(1,vol.getArray().getNumberOfTuples());
1314         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
1315         #
1316         m.unPolyze();
1317         #
1318         self.assertEqual([NORM_PENTA6],m.getAllGeoTypes())
1319         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
1320         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
1321         #
1322         vol=m.getMeasureField(False);
1323         self.assertEqual(1,vol.getArray().getNumberOfTuples());
1324         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
1325         pass
1326
1327     def testKrSpatialDiscretization1(self):
1328         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
1329         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
1330         targetPointCoordsX=[-0.5,-0.45,-0.4,-0.35,-0.3,-0.25,-0.2,-0.15,-0.1,-0.05,-6.93889390391e-17,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.05,1.1,1.15,1.2,1.25,1.3,1.35,1.4,1.45]
1331         targetFieldValsExpected=[2.975379475824351, 2.95613491917003, 2.936890362515361, 2.917645805861018, 2.898401249206574, 2.879156692552137, 2.859912135897732, 2.840667579243201, 2.821423022588731, 2.802178465934342, 2.78293390927989, 2.763689352625457, 2.744444795971001, 2.725209522098197, 2.709077577124666, 2.706677252549218, 2.727467797847971, 2.713338094723676, 2.671342424824244, 2.664877370146978, 2.653840141412181, 2.619607861392791, 2.569777214476479, 2.513263929794591, 2.450732752808528, 2.368313560985155, 2.250909795670307, 2.098194272085416, 1.954257891732065, 1.895040660973802, 1.865256788315972, 1.835475248687992, 1.80569370905998, 1.775912169431971, 1.746130629803976, 1.716349090175918, 1.686567550547855, 1.656786010919941, 1.627004471291988, 1.597222931663817]
1332         coeffsExpected=DataArrayDouble.New([52.238272642008695, 26.186513281350948, -173.42106377948534, 324.56733663875184, -104.64968873410248, 34.375030568158316, -256.12372208190425, 105.2292032463934, -16.239907618144965, 7.838025836978943, 2.621910745077291, -0.4902609628247241])
1333         #
1334         nbOfInputPoints=10;
1335         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
1336         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
1337         cmesh=MEDCouplingCMesh.New("aMesh");
1338         cmesh.setCoordsAt(0,srcArrX);
1339         umesh=cmesh.buildUnstructured();
1340         f.setMesh(umesh);
1341         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
1342         f.setArray(srcVals);
1343         f.checkConsistencyLight();
1344         #
1345         res0=f.getValueOn(targetPointCoordsX[:1]);
1346         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
1347         #
1348         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
1349         self.assertEqual(40,valuesToTest.getNumberOfTuples());
1350         self.assertEqual(1,valuesToTest.getNumberOfComponents());
1351         for i in xrange(40):
1352             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
1353             pass
1354         fd=f.getDiscretization()
1355         del f
1356         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
1357         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
1358         self.assertEqual(2,isDrift)
1359         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
1360         #
1361         pass
1362
1363     def testDuplicateEachTupleNTimes1(self):
1364         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
1365         d2=d.duplicateEachTupleNTimes(3)
1366         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
1367         self.assertEqual("aname",d2.getName())
1368         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
1369         #
1370         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
1371         d2=d.duplicateEachTupleNTimes(3)
1372         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
1373         self.assertEqual("aname",d2.getName())
1374         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
1375         pass
1376
1377     def testSwigComputeTupleIdsNearTuples1(self):
1378         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
1379         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
1380         self.assertEqual([2,0,4,1],arr.getValues())
1381         self.assertEqual([0,1,3,4],arrI.getValues())
1382         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
1383         self.assertEqual([2,0,4,1],arr.getValues())
1384         self.assertEqual([0,1,3,4],arrI.getValues())
1385         expected0=[[2],[0,4],[1]]
1386         expected1=[[0,1],[0,2],[0,1]]
1387         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
1388             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
1389             self.assertEqual(expected0[pos],arr.getValues())
1390             self.assertEqual(expected1[pos],arrI.getValues())
1391             pass
1392         pass
1393
1394     def testSwigDataTupleIOp1(self):
1395         d=DataArrayDouble(10,1)
1396         d.iota(7.)
1397         for elt in d:
1398             elt+=2.
1399             pass
1400         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
1401         self.assertTrue(toTest.isEqual(d,1e-12))
1402         for elt in d:
1403             elt-=2.
1404             pass
1405         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
1406         self.assertTrue(toTest.isEqual(d,1e-12))
1407         for elt in d:
1408             elt*=2.
1409             pass
1410         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
1411         self.assertTrue(toTest.isEqual(d,1e-12))
1412         for elt in d:
1413             elt/=2.
1414             pass
1415         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
1416         self.assertTrue(toTest.isEqual(d,1e-12))
1417         #
1418         d=DataArrayInt(10,1)
1419         d.iota(7)
1420         for elt in d:
1421             elt+=2
1422             pass
1423         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
1424         for elt in d:
1425             elt-=2
1426             pass
1427         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
1428         for elt in d:
1429             elt*=2
1430             pass
1431         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
1432         for elt in d:
1433             elt/=2
1434             pass
1435         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
1436         for elt in d:
1437             elt%=3
1438             pass
1439         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
1440         pass
1441
1442     def testIntersect2DMeshesTmp5(self):
1443         coords=DataArrayDouble.New([41,0,42,0,0,42,0,41,41.5,0,29.698484809834998,29.698484809834994,0,41.5,28.991378028648452,28.991378028648445,-42,0,-41,0,-29.698484809834994,29.698484809834998,-41.5,0,-28.991378028648445,28.991378028648452,0,-42,0,-41,-29.698484809835001,-29.698484809834994,0,-41.5,-28.991378028648455,-28.991378028648445,29.698484809834987,-29.698484809835001,28.991378028648441,-28.991378028648455,43,0,0,43,42.5,0,30.405591591021544,30.40559159102154,0,42.5,-43,0,-30.40559159102154,30.405591591021544,-42.5,0,0,-43,-30.405591591021551,-30.40559159102154,0,-42.5,30.405591591021537,-30.405591591021551,44,0,0,44,43.5,0,31.112698372208094,31.112698372208087,0,43.5,-44,0,-31.112698372208087,31.112698372208094,-43.5,0,0,-44,-31.112698372208097,-31.112698372208087,0,-43.5,31.112698372208083,-31.112698372208097,45,0,0,45,44.5,0,31.81980515339464,31.819805153394636,0,44.5,-45,0,-31.819805153394636,31.81980515339464,-44.5,0,0,-45,-31.819805153394647,-31.819805153394636,0,-44.5,31.819805153394629,-31.819805153394647,47,0,0,47,46,0,33.234018715767739,33.234018715767732,0,46,-47,0,-33.234018715767732,33.234018715767739,-46,0,0,-47,-33.234018715767739,-33.234018715767732,0,-46,33.234018715767725,-33.234018715767739,49,0,0,49,48,0,34.648232278140831,34.648232278140824,0,48,-49,0,-34.648232278140824,34.648232278140831,-48,0,0,-49,-34.648232278140839,-34.648232278140824,0,-48,34.648232278140817,-34.648232278140839,51,0,0,51,50,0,36.062445840513924,36.062445840513924,0,50,-51,0,-36.062445840513924,36.062445840513924,-50,0,0,-51,-36.062445840513931,-36.062445840513924,0,-50,36.062445840513917,-36.062445840513931,53,0,0,53,52,0,37.476659402887023,37.476659402887016,0,52,-53,0,-37.476659402887016,37.476659402887023,-52,0,0,-53,-37.47665940288703,-37.476659402887016,0,-52,37.476659402887009,-37.47665940288703,55,0,0,55,54,0,38.890872965260115,38.890872965260108,0,54,-55,0,-38.890872965260108,38.890872965260115,-54,0,0,-55,-38.890872965260122,-38.890872965260108,0,-54,38.890872965260101,-38.890872965260122,59,0,0,59,57,0,41.719300090006307,41.7193000900063,0,57,-59,0,-41.7193000900063,41.719300090006307,-57,0,0,-59,-41.719300090006314,-41.7193000900063,0,-57,41.719300090006293,-41.719300090006314,63,0,0,63,61,0,44.547727214752499,44.547727214752491,0,61,-63,0,-44.547727214752491,44.547727214752499,-61,0,0,-63,-44.547727214752506,-44.547727214752491,0,-61,44.547727214752484,-44.547727214752506,67,0,0,67,65,0,47.37615433949869,47.376154339498683,0,65,-67,0,-47.376154339498683,47.37615433949869,-65,0,0,-67,-47.376154339498697,-47.376154339498683,0,-65,47.376154339498676,-47.376154339498697,71,0,0,71,69,0,50.204581464244875,50.204581464244868,0,69,-71,0,-50.204581464244868,50.204581464244875,-69,0,0,-71,-50.204581464244889,-50.204581464244868,0,-69,50.20458146424486,-50.204581464244889,75,0,0,75,73,0,53.033008588991066,53.033008588991059,0,73,-75,0,-53.033008588991059,53.033008588991066,-73,0,0,-75,-53.033008588991073,-53.033008588991059,0,-73,53.033008588991052,-53.033008588991073,80,0,0,80,77.5,0,56.568542494923804,56.568542494923797,0,77.5,-80,0,-56.568542494923797,56.568542494923804,-77.5,0,0,-80,-56.568542494923818,-56.568542494923797,0,-77.5,56.56854249492379,-56.568542494923818],188,2)
1444         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12,8,9,8,13,14,11,15,16,17,8,14,13,1,0,16,18,4,19,8,1,20,21,2,22,23,24,5,8,2,21,25,8,24,26,27,10,8,8,25,28,13,27,29,30,15,8,13,28,20,1,30,31,22,18,8,20,32,33,21,34,35,36,23,8,21,33,37,25,36,38,39,26,8,25,37,40,28,39,41,42,29,8,28,40,32,20,42,43,34,31,8,32,44,45,33,46,47,48,35,8,33,45,49,37,48,50,51,38,8,37,49,52,40,51,53,54,41,8,40,52,44,32,54,55,46,43,8,44,56,57,45,58,59,60,47,8,45,57,61,49,60,62,63,50,8,49,61,64,52,63,65,66,53,8,52,64,56,44,66,67,58,55,8,56,68,69,57,70,71,72,59,8,57,69,73,61,72,74,75,62,8,61,73,76,64,75,77,78,65,8,64,76,68,56,78,79,70,67,8,68,80,81,69,82,83,84,71,8,69,81,85,73,84,86,87,74,8,73,85,88,76,87,89,90,77,8,76,88,80,68,90,91,82,79,8,80,92,93,81,94,95,96,83,8,81,93,97,85,96,98,99,86,8,85,97,100,88,99,101,102,89,8,88,100,92,80,102,103,94,91,8,92,104,105,93,106,107,108,95,8,93,105,109,97,108,110,111,98,8,97,109,112,100,111,113,114,101,8,100,112,104,92,114,115,106,103,8,104,116,117,105,118,119,120,107,8,105,117,121,109,120,122,123,110,8,109,121,124,112,123,125,126,113,8,112,124,116,104,126,127,118,115,8,116,128,129,117,130,131,132,119,8,117,129,133,121,132,134,135,122,8,121,133,136,124,135,137,138,125,8,124,136,128,116,138,139,130,127,8,128,140,141,129,142,143,144,131,8,129,141,145,133,144,146,147,134,8,133,145,148,136,147,149,150,137,8,136,148,140,128,150,151,142,139,8,140,152,153,141,154,155,156,143,8,141,153,157,145,156,158,159,146,8,145,157,160,148,159,161,162,149,8,148,160,152,140,162,163,154,151,8,152,164,165,153,166,167,168,155,8,153,165,169,157,168,170,171,158,8,157,169,172,160,171,173,174,161,8,160,172,164,152,174,175,166,163,8,164,176,177,165,178,179,180,167,8,165,177,181,169,180,182,183,170,8,169,181,184,172,183,185,186,173,8,172,184,176,164,186,187,178,175],540)
1445         connI=DataArrayInt.New([0,9,18,27,36,45,54,63,72,81,90,99,108,117,126,135,144,153,162,171,180,189,198,207,216,225,234,243,252,261,270,279,288,297,306,315,324,333,342,351,360,369,378,387,396,405,414,423,432,441,450,459,468,477,486,495,504,513,522,531,540],61)
1446         #
1447         m1=MEDCouplingUMesh.New("Fix",2);
1448         m1.setCoords(coords);
1449         m1.setConnectivity(conn,connI,True);
1450         #
1451         coords=DataArrayDouble([46.5,-2.5,53.5,-2.5,53.5,2.5,46.5,2.5,50,-2.5,53.5,0,50,2.5,46.5,0,60.5,-2.5,60.5,2.5,57,-2.5,60.5,0,57,2.5,53.5,7.5,46.5,7.5,53.5,5,50,7.5,46.5,5,60.5,7.5,60.5,5,57,7.5,-2,47,2,47,2,53,-2,53,0,47,2,50,0,53,-2,50,6,47,6,53,4,47,6,50,4,53,2,59,-2,59,2,56,0,59,-2,56,6,59,6,56,4,59],42,2)
1452         # connectivity
1453         conn=DataArrayInt([8,0,1,2,3,4,5,6,7,8,1,8,9,2,10,11,12,5,8,3,2,13,14,6,15,16,17,8,2,9,18,13,12,19,20,15,8,21,22,23,24,25,26,27,28,8,22,29,30,23,31,32,33,26,8,24,23,34,35,27,36,37,38,8,23,30,39,34,33,40,41,36],72);
1454         conn.setName("");
1455         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
1456         m2=MEDCouplingUMesh.New("Mobile",2);
1457         m2.setCoords(coords);
1458         m2.setConnectivity(conn,connI,True);
1459         #
1460         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
1461         self.assertEqual(105,m3.getNumberOfCells());
1462         self.assertEqual(105,d1.getNumberOfTuples());
1463         self.assertEqual(105,d2.getNumberOfTuples());
1464         self.assertEqual(704,m3.getNumberOfNodes());
1465         #
1466         areaExpected=[-65.18804756198824,-65.18804756198824,-65.18804756198824,-65.18804756198824,-66.75884388878285,-66.75884388878285,-66.7588438887833,-66.75884388878308,-68.32964021557768,-68.32964021557768,-68.32964021557814,-68.32964021557791,-69.9004365423732,-69.9004365423732,-69.90043654237297,-69.90043654237297,-1.194568659706448,-1.0869994447159463,-142.2316939607081,-144.51326206513068,-144.5132620651309,-1.1945686597064424,-143.3186934054243,-5.002264310862817,-10.0261332846393,-3.9727823117092953,-7.290862524642649,-124.504404940456,-3.9727823117093237,-146.82366506060032,-150.79644737231024,-5.002264310862776,-145.79418306144626,-5.00208651738126,-10.054764051268958,-4.001067863263231,-8.027932154428669,-129.99378209314813,-4.001067863263216,-153.07856481622616,-157.0796326794898,-5.0020865173811915,-152.07754616210832,-5.001928880064381,-10.050590216368969,-4.00098721602491,-8.025810856794209,-136.28350081741684,-4.000987216024939,-159.36183077064402,-163.36281798667005,-5.0019288800643285,-158.36088910660442,-1.2991516319851801,-3.702636830195414,-3.7815130030068254,-6.265364371195623,-0.02516260900254963,-0.6553944641345026,-3.975752765070567,-7.368528340442765,-142.57249927881398,-0.02516260900254963,-3.9757527650706095,-165.64508791977525,-169.64600329384803,-1.299151631985167,-3.7026368301953885,-164.6442148316677,-10.00321285677458,-20.08414323176165,-8.001644468035863,-16.042954878437143,-304.0096070742277,-8.00164446803587,-350.1399180412005,-358.1415625092368,-10.003212856774468,-348.13834965246224,-3.794150313030109,-8.65049239704272,-0.02260276689354157,-0.5885167811200915,-370.2185414798688,-0.022602766893559393,-383.2517009710623,-383.2743037379555,-3.7941503130300576,-379.48015342492505,-408.40704496667513,-408.4070449666742,-408.4070449666742,-408.4070449666742,-433.53978619538975,-433.5397861953902,-433.5397861953911,-433.53978619539066,-458.67252742410983,-458.6725274241094,-458.67252742410983,-458.6725274241089,-608.6835766330232,-608.6835766330232,-608.6835766330232,-608.6835766330241]
1467         expected1=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,16,16,17,18,19,19,20,20,20,20,20,21,21,22,23,23,24,24,24,24,24,25,25,26,27,27,28,28,28,28,28,29,29,30,31,31,32,32,32,32,32,32,32,32,32,33,33,33,34,35,35,35,36,36,36,36,36,37,37,38,39,39,40,40,40,40,40,41,41,42,43,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59]
1468         expected2=[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,2,-1,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,1,2,3,4,5,6,7,-1,4,6,-1,-1,0,1,-1,1,3,6,7,-1,6,-1,-1,1,-1,1,3,6,7,-1,6,-1,-1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
1469         f3=m3.getMeasureField(False).getArray().getValues();
1470         for i in xrange(105):
1471             self.assertAlmostEqual(areaExpected[i],f3[i],10)
1472             pass
1473         self.assertEqual(expected1,d1.getValues())
1474         self.assertEqual(expected2,d2.getValues())
1475         pass
1476
1477     def testSwig2Intersect2DMeshesQuadra1(self):
1478         import cmath
1479         def createDiagCircle(lX, lY, R, cells=[0,1]):
1480             """ A circle in a square box, cut along the diagonal.
1481             """
1482             c = []
1483             for i in range(8):
1484               c.append(cmath.rect(R, i*pi/4))
1485
1486             coords = [0.0,0.0,          c[3].real,c[3].imag,       -lX/2.0, lY/2.0,
1487                       0.0, lY/2.0,      lX/2.0,lY/2.0,             lX/2.0,0.0,
1488                       #   6                  7                              8
1489                       lX/2.0,-lY/2.0,   c[7].real,c[7].imag,       c[1].real,c[1].imag,
1490                       #   9                  10                            11
1491                       c[5].real,c[5].imag,   -lX/2.0,-lY/2.0,      0.0, -lY/2.0,
1492                       #   12                  13                            14
1493                       -lX/2.0,0.0,         0.0,0.0,                  0.0, 0.0]
1494             # Points 13 (reps. 14) are average of points (6,7) (resp (1,2))
1495             coords[13*2]   = 0.5*(coords[6*2]+coords[7*2])
1496             coords[13*2+1] = 0.5*(coords[6*2+1]+coords[7*2+1])
1497             coords[14*2]   = 0.5*(coords[1*2]+coords[2*2])
1498             coords[14*2+1] = 0.5*(coords[1*2+1]+coords[2*2+1])
1499             connec  = [1,7,8,0]      # half circle up right
1500             connec3 = [6,7,1,2,4,13,8,14,3,5]
1501
1502             baseMesh = MEDCouplingUMesh.New("box_circle", 2)
1503             baseMesh.allocateCells(2)
1504             meshCoords = DataArrayDouble.New(coords, len(coords)/2, 2)
1505             meshCoords.setInfoOnComponents(["X [au]", "Y [au]"])
1506             baseMesh.setCoords(meshCoords)
1507
1508             if 0 in cells:
1509               baseMesh.insertNextCell(NORM_QPOLYG, connec)
1510             if 1 in cells:
1511               baseMesh.insertNextCell(NORM_QPOLYG, connec3)
1512             baseMesh.finishInsertingCells()
1513             baseMesh.checkConsistencyLight()
1514             return baseMesh
1515
1516         eps = 1.0e-7
1517         m1 = createDiagCircle(1.0, 1.0, 0.5*0.90, cells=[0,1])
1518         m2 = createDiagCircle(1.0, 1.0, 0.5*0.95, cells=[0])
1519         m3, _, _= MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
1520         m3.mergeNodes(eps)
1521         m3.convertDegeneratedCells()
1522         m3.zipCoords()
1523         m4 = m3.deepCopy()
1524         m5, _, _ = MEDCouplingUMesh.Intersect2DMeshes(m3, m4, eps)
1525         m5.mergeNodes(eps)
1526         # Check coordinates:
1527         self.assertTrue(m3.getCoords().isEqual(m5.getCoords(), eps))
1528
1529     def testIntersect2DMeshesTmp7(self):
1530         eps = 1.0e-8
1531         coords = [-0.5,-0.5,   -0.5, 0.5, 0.5, 0.5,    0.5,-0.5]
1532         connec = range(4)
1533         m1 = MEDCouplingUMesh.New("box", 2)
1534         m1.allocateCells(1)
1535         meshCoords = DataArrayDouble.New(coords, len(coords)/2, 2)
1536         m1.setCoords(meshCoords)
1537         m1.insertNextCell(NORM_POLYGON, connec)
1538         m1.finishInsertingCells()
1539
1540         m2 = MEDCouplingDataForTest.buildCircle(0.25, 0.2, 0.4)
1541         # Was looping indefinitly:
1542         m_intersec, resToM1, resToM2 = MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
1543         m_intersec.zipCoords()
1544         coo_tgt = DataArrayDouble([-0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.03284271247461901, 0.4828427124746191,
1545           -0.014575131106459124, 0.5000000000000001, 0.5, -0.11224989991991996, 0.24271243444677046, 0.5, 0.5, 0.19387505004004,
1546           -0.04799910280454185, -0.06682678787499614, -0.023843325638122054, 0.4915644577163915, 0.5, -0.30612494995996, 0.0, -0.5,
1547           -0.5, 0.0, -0.25728756555322957, 0.5, -0.023843325638122026, 0.49156445771639157, -0.04799910280454181, -0.06682678787499613], 17 ,2)
1548         conn_tgt = [32, 5, 2, 6, 4, 7, 8, 9, 10, 32, 6, 3, 0, 1, 5, 4, 11, 12, 13, 14, 15, 16]
1549         connI_tgt = [0, 9, 22]
1550         res1_tgt  = [0, 0]
1551         res2_tgt = [0, -1]
1552         self.assert_(coo_tgt.isEqualWithoutConsideringStr(m_intersec.getCoords(), 1e-12))
1553         self.assertEqual(conn_tgt, m_intersec.getNodalConnectivity().getValues())
1554         self.assertEqual(connI_tgt, m_intersec.getNodalConnectivityIndex().getValues())
1555         self.assertEqual(res1_tgt, resToM1.getValues())
1556         self.assertEqual(res2_tgt, resToM2.getValues())
1557
1558     def testDAIBuildUnique1(self):
1559         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
1560         e=d.buildUnique()
1561         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
1562         pass
1563
1564     def testDAIPartitionByDifferentValues1(self):
1565         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
1566         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
1567         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
1568             self.assertEqual(expected[i][0],elt[1])
1569             self.assertEqual(expected[i][1],elt[0].getValues())
1570             pass
1571         pass
1572
1573     def testFieldGaussMultiDiscPerType1(self):
1574         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
1575         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
1576         mQ8.allocateCells(1)
1577         mQ8.insertNextCell(NORM_QUAD8,range(8))
1578         mQ8.finishInsertingCells()
1579         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
1580         mQ4.allocateCells(1)
1581         mQ4.insertNextCell(NORM_QUAD4,range(4))
1582         mQ4.finishInsertingCells()
1583         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
1584         mT3.allocateCells(1)
1585         mT3.insertNextCell(NORM_TRI3,range(3))
1586         mT3.finishInsertingCells()
1587
1588         tr=[[0.,0.],[2.,0.], [0.,2.],[2.,2.],[4.,2.],[6.,2.],[8.,2.],[10.,2.],[12.,2.],[0.,4.],[2.,4.],[4.,4.],[6.,4.],[8.,4.],[10.,4.],[12.,4.],[14.,4.],[16.,4.],[18.,4.],[20.,4.],[22.,4.]]
1589         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
1590         ms[:]=(elt.deepCopy() for elt in ms)
1591         for m,t in zip(ms,tr):
1592             d=m.getCoords() ; d+= t
1593             pass
1594         m=MEDCouplingUMesh.MergeUMeshes(ms)
1595         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
1596         f.setMesh(m)
1597         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
1598         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,[0,1,3],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
1599         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
1600         f.setGaussLocalizationOnCells([3,2,5],[0.,0.,1.,0.,1.,1.,0.,1.,0.5,0.,1.,0.5,0.5,1.,0.,0.5],[0.3,0.3,0.7,0.7,0.9,0.9],[0.8,0.05,0.15])
1601         f.setGaussLocalizationOnCells([4,6,8,7],[0.,0.,1.,0.,1.,1.,0.,1.,0.5,0.,1.,0.5,0.5,1.,0.,0.5],[0.3,0.3,0.7,0.7,0.9,0.9,-0.1,0.3],[0.7,0.05,0.15,0.1])
1602         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
1603         f.setGaussLocalizationOnCells([14,15,16,17,18,19],[0.,0.,1.,0.,1.,1.],[0.4,0.4,0.14,0.16],[0.22,0.78])
1604         self.assertEqual(46,f.getNumberOfTuplesExpected())
1605         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
1606         f.setArray(vals)
1607         f.checkConsistencyLight()
1608         #f.getLocalizationOfDiscr()
1609         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
1610         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
1611         self.assertEqual([0,0,1,1,2,1,2,2,2,3,3,3,3,3,4,4,4,4,4,4],f.getDiscretization().getArrayOfDiscIds().getValues())
1612         fc=f[[1,2,3,8]]
1613         fc.checkConsistencyLight()
1614         self.assertTrue(DataArrayDouble([13.7,14.7,15.7,16.7,17.7,18.7,19.7,20.7,21.7,22.7,23.7,24.7,25.7,26.7,27.7,28.7,29.7,30.7,31.7,32.7,33.7,34.7,35.7,36.7,82.7,83.7,84.7,85.7,86.7,87.7,88.7,89.7,90.7,91.7,92.7,93.7],12,3).isEqual(fc.getArray(),1e-10))
1615         fc.renumberCells([3,2,0,1])
1616         self.assertTrue(DataArrayDouble([28.7, 29.7, 30.7, 31.7, 32.7, 33.7, 34.7, 35.7, 36.7, 82.7, 83.7, 84.7, 85.7, 86.7, 87.7, 88.7, 89.7, 90.7, 91.7, 92.7, 93.7, 19.7, 20.7, 21.7, 22.7, 23.7, 24.7, 25.7, 26.7, 27.7, 13.7, 14.7, 15.7, 16.7, 17.7, 18.7],12,3).isEqual(fc.getArray(),1e-10))
1617         fc.getArray()
1618         pass
1619
1620     def testSwigRotate(self):
1621         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
1622         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
1623         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
1624         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
1625         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
1626         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
1627         pass
1628
1629     def testSwigCMeshProtection(self):
1630         cm=MEDCouplingCMesh()
1631         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
1632         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
1633         pass
1634
1635     def testSwigCellsInBoundingBox1(self):
1636         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
1637         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
1638         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
1639         pass
1640
1641     def testDAICheckMonotonic1(self):
1642         data1=[-1,0,2,2,4,5]
1643         data2=[6,2,0,-8,-9,-56]
1644         data3=[-1,0,3,2,4,6]
1645         data4=[7,5,2,3,0,-6]
1646         d=DataArrayInt.New(data1);
1647         self.assertTrue(d.isMonotonic(True));
1648         self.assertTrue(not d.isMonotonic(False));
1649         d.checkMonotonic(True);
1650         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
1651         d=DataArrayInt.New(data2);
1652         self.assertTrue(d.isMonotonic(False));
1653         self.assertTrue(not d.isMonotonic(True));
1654         d.checkMonotonic(False);
1655         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
1656         d=DataArrayInt.New(data3);
1657         self.assertTrue(not d.isMonotonic(False));
1658         self.assertTrue(not d.isMonotonic(True));
1659         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
1660         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
1661         d=DataArrayInt.New(data4);
1662         self.assertTrue(not d.isMonotonic(False));
1663         self.assertTrue(not d.isMonotonic(True));
1664         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
1665         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
1666         d=DataArrayInt.New(0,1)
1667         self.assertTrue(d.isMonotonic(True));
1668         self.assertTrue(d.isMonotonic(False));
1669         d.checkMonotonic(True);
1670         d.checkMonotonic(False);
1671         d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
1672         self.assertRaises(InterpKernelException,d.isMonotonic,True)
1673         self.assertRaises(InterpKernelException,d.isMonotonic,False)
1674         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
1675         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
1676         pass
1677
1678     def testSwigDASetItemOnEmpty1(self):
1679         d=DataArrayInt(0,1)
1680         isThrow=False
1681         try:
1682             d[0:1000:2]=4
1683         except InterpKernelException as e:
1684             isThrow=True
1685             pass
1686         self.assertTrue(isThrow)
1687         d[:]=4
1688         d[::2]=5
1689         #
1690         d=DataArrayDouble(0,1)
1691         isThrow=False
1692         try:
1693             d[0:1000:2]=4
1694         except InterpKernelException as e:
1695             isThrow=True
1696             pass
1697         self.assertTrue(isThrow)
1698         d[:]=4
1699         d[::2]=5
1700         d=DataArrayInt([],0,1)
1701         d2=DataArrayInt(0)
1702         self.assertTrue(d2.isEqual(d))
1703         d=DataArrayDouble([],0,1)
1704         d2=DataArrayDouble(0)
1705         self.assertTrue(d2.isEqual(d,1e-12))
1706         pass
1707
1708     def testSwigDAITransformWithIndArr1(self):
1709         arr=DataArrayInt([0,4,5,1])
1710         d=DataArrayInt([7,8,9,10])
1711         self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
1712         pass
1713
1714     def testIntersect2DMeshesTmp6(self):
1715         # coordinates
1716         coords=DataArrayDouble.New([2.7554552980815448e-15,45,-45,5.5109105961630896e-15,-31.819805153394636,31.81980515339464,2.8779199779962799e-15,47,2.8166876380389124e-15,46,-47,5.7558399559925599e-15,-33.234018715767732,33.234018715767739,-46,5.6333752760778247e-15],8,2);
1717         # connectivity
1718         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
1719         connI=DataArrayInt.New([0,9]);
1720         m1=MEDCouplingUMesh.New("Fixe",2);
1721         m1.setCoords(coords);
1722         m1.setConnectivity(conn,connI,True);
1723         #
1724         coords=DataArrayDouble.New([-7.3800475508445391,41.854329503018846,-3.7041190667754655,42.338274668899189,-3.7041190667754655,45.338274668899189,-7.3800475508445382,44.854329503018839,-5.5473631693521845,42.136406608386956,-3.7041190667754655,43.838274668899189,-5.5420833088100014,45.09630208595901,-7.3800475508445382,43.354329503018839,-3.7041190667754651,52.338274668899189,-7.3800475508445382,51.854329503018839,-3.7041190667754655,48.838274668899189,-5.5420833088100014,52.09630208595901,-7.3800475508445382,48.354329503018839],13,2);
1725         # connectivity
1726         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
1727         connI=DataArrayInt.New([0,9,18]);
1728         #
1729         m2=MEDCouplingUMesh.New("Mobile",2);
1730         m2.setCoords(coords);
1731         m2.setConnectivity(conn,connI,True);
1732         #
1733         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
1734         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
1735         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
1736         self.assertEqual(4,m3.getNumberOfCells());
1737         self.assertEqual(4,d1.getNumberOfTuples());
1738         self.assertEqual(4,d2.getNumberOfTuples());
1739         self.assertEqual(43,m3.getNumberOfNodes());
1740         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
1741         self.assertEqual(35,m3.getNumberOfNodes());
1742         m3.zipCoords();
1743         self.assertEqual(23,m3.getNumberOfNodes());
1744         #
1745         f=m3.getMeasureField(True);
1746         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
1747         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
1748         pass
1749
1750     def testDAPushBack(self):
1751         d=DataArrayDouble(0,1)
1752         for i in xrange(8):
1753             d.pushBackSilent(i)
1754             pass
1755         self.assertEqual(d.getNumberOfTuples(),8)
1756         self.assertEqual(d.getNbOfElemAllocated(),8)
1757         d.pushBackSilent(4.44)
1758         self.assertEqual(d.getNumberOfTuples(),9)
1759         self.assertEqual(d.getNbOfElemAllocated(),16)
1760         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
1761         e=d.deepCopy()
1762         self.assertEqual(e.getNumberOfTuples(),9)
1763         self.assertEqual(e.getNbOfElemAllocated(),9)
1764         self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
1765         self.assertAlmostEqual(d.popBackSilent(),4.44,12)
1766         self.assertEqual(d.getNumberOfTuples(),8)
1767         self.assertEqual(d.getNbOfElemAllocated(),16)
1768         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
1769         f=DataArrayDouble()
1770         f.reserve(1000)
1771         f.pushBackSilent(4.)
1772         self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
1773         self.assertEqual(f.getNumberOfTuples(),1)
1774         self.assertEqual(f.getNbOfElemAllocated(),1000)
1775         ff=f[:]
1776         self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
1777         self.assertEqual(ff.getNumberOfTuples(),1)
1778         self.assertEqual(ff.getNbOfElemAllocated(),1)
1779         d=DataArrayDouble()
1780         d.pushBackSilent(4.44)
1781         d.pushBackSilent(5.55)
1782         d.pushBackSilent(6.66)
1783         self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
1784         #
1785         d=DataArrayInt(0,1)
1786         for i in xrange(8):
1787             d.pushBackSilent(i)
1788             pass
1789         self.assertEqual(d.getNumberOfTuples(),8)
1790         self.assertEqual(d.getNbOfElemAllocated(),8)
1791         d.pushBackSilent(444)
1792         self.assertEqual(d.getNumberOfTuples(),9)
1793         self.assertEqual(d.getNbOfElemAllocated(),16)
1794         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
1795         e=d.deepCopy()
1796         self.assertEqual(e.getNumberOfTuples(),9)
1797         self.assertEqual(e.getNbOfElemAllocated(),9)
1798         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
1799         self.assertEqual(d.popBackSilent(),444)
1800         self.assertEqual(d.getNumberOfTuples(),8)
1801         self.assertEqual(d.getNbOfElemAllocated(),16)
1802         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
1803         f=DataArrayInt()
1804         f.reserve(1000)
1805         f.pushBackSilent(4)
1806         self.assertTrue(f.isEqual(DataArrayInt([4])))
1807         self.assertEqual(f.getNumberOfTuples(),1)
1808         self.assertEqual(f.getNbOfElemAllocated(),1000)
1809         ff=f[:]
1810         self.assertTrue(ff.isEqual(DataArrayInt([4])))
1811         self.assertEqual(ff.getNumberOfTuples(),1)
1812         self.assertEqual(ff.getNbOfElemAllocated(),1)
1813         d=DataArrayInt()
1814         d.pushBackSilent(444)
1815         d.pushBackSilent(555)
1816         d.pushBackSilent(666)
1817         self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
1818         #
1819         d=DataArrayInt()
1820         d.alloc(10,1)
1821         d.setInfoOnComponent(0,"ABC")
1822         d.setName("dEf")
1823         d.iota(7)
1824         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1825         self.assertEqual(10,d.getNbOfElemAllocated())
1826         d.pushBackSilent(55)
1827         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1828         self.assertEqual(20,d.getNbOfElemAllocated())
1829         d.reserve(4)
1830         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1831         self.assertEqual(4,d.getNbOfElemAllocated())
1832         d.pushBackSilent(5)
1833         e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1834         self.assertEqual(8,d.getNbOfElemAllocated())
1835         self.assertEqual(5,d.popBackSilent())
1836         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1837         self.assertEqual(8,d.getNbOfElemAllocated())
1838         self.assertRaises(OverflowError,d.reserve,-1)
1839         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1840         self.assertEqual(8,d.getNbOfElemAllocated())
1841         d.reserve(0)
1842         e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
1843         self.assertEqual(0,d.getNbOfElemAllocated())
1844         #
1845         d=DataArrayDouble()
1846         d.alloc(10,1)
1847         d.setInfoOnComponent(0,"ABC")
1848         d.setName("dEf")
1849         d.iota(7)
1850         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1851         self.assertEqual(10,d.getNbOfElemAllocated())
1852         d.pushBackSilent(55)
1853         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1854         self.assertEqual(20,d.getNbOfElemAllocated())
1855         d.reserve(4)
1856         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1857         self.assertEqual(4,d.getNbOfElemAllocated())
1858         d.pushBackSilent(5)
1859         e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1860         self.assertEqual(8,d.getNbOfElemAllocated())
1861         self.assertEqual(5.,d.popBackSilent())
1862         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1863         self.assertEqual(8,d.getNbOfElemAllocated())
1864         self.assertRaises(OverflowError,d.reserve,-1)
1865         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1866         self.assertEqual(8,d.getNbOfElemAllocated())
1867         d.reserve(0)
1868         e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
1869         self.assertEqual(0,d.getNbOfElemAllocated())
1870         pass
1871
1872     def testDAIBuildSubstractionOptimized1(self):
1873         da1=DataArrayInt.New([1,3,5,6,7,9,13])
1874         da2=DataArrayInt.New([3,5,9])
1875         da3=DataArrayInt.New([1,3,5])
1876         da4=DataArrayInt.New([1,3,5,6,7,9,13])
1877         #
1878         a=da1.buildSubstractionOptimized(da2);
1879         self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
1880         #
1881         a=da1.buildSubstractionOptimized(da3);
1882         self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
1883         #
1884         a=da1.buildSubstractionOptimized(da4);
1885         self.assertTrue(a.isEqual(DataArrayInt([])));
1886         pass
1887
1888     def testDAIIsStrictlyMonotonic1(self):
1889         da1=DataArrayInt.New([1,3,5,6,7,9,13])
1890         self.assertTrue(da1.isStrictlyMonotonic(True));
1891         da1.checkStrictlyMonotonic(True);
1892         self.assertTrue(da1.isMonotonic(True));
1893         da1.checkMonotonic(True);
1894         self.assertTrue(not da1.isStrictlyMonotonic(False));
1895         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1896         self.assertTrue(not da1.isMonotonic(False));
1897         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
1898         #
1899         da1=DataArrayInt.New([1,3,5,6,6,9,13])
1900         self.assertTrue(not da1.isStrictlyMonotonic(True));
1901         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1902         self.assertTrue(da1.isMonotonic(True));
1903         da1.checkMonotonic(True);
1904         self.assertTrue(not da1.isStrictlyMonotonic(False));
1905         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1906         self.assertTrue(not da1.isMonotonic(False));
1907         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
1908         #
1909         da1=DataArrayInt.New([1,3,5,6,5,9,13])
1910         self.assertTrue(not da1.isStrictlyMonotonic(True));
1911         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1912         self.assertTrue(not da1.isMonotonic(True));
1913         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
1914         self.assertTrue(not da1.isStrictlyMonotonic(False));
1915         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1916         self.assertTrue(not da1.isMonotonic(False));
1917         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
1918         #
1919         da1=DataArrayInt.New([13,9,7,6,5,3,1])
1920         self.assertTrue(not da1.isStrictlyMonotonic(True));
1921         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1922         self.assertTrue(not da1.isMonotonic(True));
1923         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
1924         self.assertTrue(da1.isStrictlyMonotonic(False));
1925         da1.checkStrictlyMonotonic(False);
1926         self.assertTrue(da1.isMonotonic(False));
1927         da1.checkMonotonic(False);
1928         #
1929         da1=DataArrayInt.New([13,9,6,6,5,3,1])
1930         self.assertTrue(not da1.isStrictlyMonotonic(True));
1931         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1932         self.assertTrue(not da1.isMonotonic(True));
1933         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
1934         self.assertTrue(not da1.isStrictlyMonotonic(False));
1935         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1936         self.assertTrue(da1.isMonotonic(False));
1937         da1.checkMonotonic(False);
1938         #
1939         da1=DataArrayInt.New([13,9,5,6,5,3,1])
1940         self.assertTrue(not da1.isStrictlyMonotonic(True));
1941         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1942         self.assertTrue(not da1.isMonotonic(True));
1943         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
1944         self.assertTrue(not da1.isStrictlyMonotonic(False));
1945         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1946         self.assertTrue(not da1.isMonotonic(False));
1947         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
1948         #
1949         da1=DataArrayInt.New([])
1950         self.assertTrue(da1.isStrictlyMonotonic(True));
1951         da1.checkStrictlyMonotonic(True);
1952         self.assertTrue(da1.isMonotonic(True));
1953         da1.checkMonotonic(True);
1954         self.assertTrue(da1.isStrictlyMonotonic(False));
1955         da1.checkStrictlyMonotonic(False);
1956         self.assertTrue(da1.isMonotonic(False));
1957         da1.checkMonotonic(False);
1958         #
1959         da1=DataArrayInt.New([13])
1960         self.assertTrue(da1.isStrictlyMonotonic(True));
1961         da1.checkStrictlyMonotonic(True);
1962         self.assertTrue(da1.isMonotonic(True));
1963         da1.checkMonotonic(True);
1964         self.assertTrue(da1.isStrictlyMonotonic(False));
1965         da1.checkStrictlyMonotonic(False);
1966         self.assertTrue(da1.isMonotonic(False));
1967         da1.checkMonotonic(False);
1968         pass
1969
1970     def testFindAndCorrectBadOriented3DCells1(self):
1971         nbOfDisc=20
1972         vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
1973         #
1974         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
1975         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
1976         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
1977         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
1978         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
1979         self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
1980         m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
1981         c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
1982         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
1983         c2=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0., 0.,0.,1.,0.,1.,1.,1.,0.,1.],6,3) ; m2.setCoords(c2)
1984         c3=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.],8,3) ; m3.setCoords(c3)
1985         c4=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.8,0.,0.,0.45,0.,0.,   0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.,0.8,0.,1.,0.45,0.,1.],12,3) ; m4.setCoords(c4)
1986         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
1987         expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
1988         for v in vects:
1989             for i in xrange(nbOfDisc):
1990                 mm=m.deepCopy()
1991                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
1992                 mm2=mm.deepCopy()
1993                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1994                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
1995                 self.assertTrue(mm.isEqual(mm2,1e-14))
1996                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1997                 mm.convertAllToPoly()
1998                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1999                 pass
2000             pass
2001         #
2002         mOK=m.deepCopy()
2003         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
2004         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
2005         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
2006         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
2007         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,[0,5,4,3,2,1,6,11,10,9,8,7]); #Not well oriented
2008         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
2009         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
2010         expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
2011         for v in vects:
2012             for i in xrange(nbOfDisc):
2013                 mm=m.deepCopy()
2014                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
2015                 mm2=mm.deepCopy() ; mm3=mm.deepCopy() ; mm3.convertAllToPoly()
2016                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
2017                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
2018                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
2019                 mOK.setCoords(mm.getCoords())
2020                 self.assertTrue(mm.isEqual(mOK,1e-14))
2021                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
2022                 mmm=mm.deepCopy()
2023                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
2024                 mm.convertAllToPoly()
2025                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
2026                 pass
2027             pass
2028         #
2029         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
2030         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented
2031         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented
2032         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
2033         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,range(12)); #Well oriented
2034         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
2035         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
2036         expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
2037         for v in vects:
2038             for i in xrange(nbOfDisc):
2039                 mm=m.deepCopy()
2040                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
2041                 mm2=mm.deepCopy() ; mm3=mm.deepCopy() ; mm3.convertAllToPoly()
2042                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
2043                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
2044                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
2045                 mOK.setCoords(mm.getCoords())
2046                 self.assertTrue(mm.isEqual(mOK,1e-14))
2047                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
2048                 mmm=mm.deepCopy()
2049                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
2050                 mm.convertAllToPoly()
2051                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
2052                 pass
2053             pass
2054         pass
2055
2056     def testSwig2CellOrientation1(self):
2057         coords=DataArrayDouble([-0.21606,-0.10803,0.29999999999999999,-0.21606,-0.10803,0.37700000000000006,0,-0.10803,0.29999999999999999,0,-0.10803,0.37700000000000006,0,0.10803,0.29999999999999999,0,0.10803,0.37700000000000006,-0.21606,0.10803,0.29999999999999999,-0.21606,0.10803,0.37700000000000006,0,0.03601,0.29999999999999999,0,0.03601,0.37700000000000006,0,-0.03601,0.29999999999999999,0,-0.03601,0.37700000000000006],12,3)
2058         conn=[[0,2,10,8,4,6],[1,3,11,9,5,7],[0,1,3,2],[2,3,11,10],[10,11,9,8],[8,9,5,4],[4,5,7,6],[6,7,1,0]]
2059         for i in xrange(256):
2060             mesh=MEDCouplingUMesh("FluidMesh_1",3);
2061             mesh.allocateCells(0)
2062             conn2=[elt[:] for elt in conn]
2063             code=bin(i)[2:] ; code='0'*(8-len(code))+code
2064             for face,rev in zip(conn2,code):
2065                 if bool(int(rev)):
2066                     face.reverse()
2067                     pass
2068                 pass
2069             conn3=[elt+[-1] for elt in conn2]
2070             conn3=sum(conn3,[])[:-1]
2071             mesh.insertNextCell(NORM_POLYHED,conn3)
2072             mesh.setCoords(coords)
2073             mesh.orientCorrectlyPolyhedrons()
2074             self.assertTrue(mesh.computeCellCenterOfMass().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
2075             pass
2076         pass
2077
2078     def testSwig2CheckConsecutiveCellTypesForMEDFileFrmt1(self):
2079         m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
2080         m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
2081         m1.insertNextCell(NORM_TRI3,[0,1,2])
2082         d=DataArrayDouble(4,3) ; d[:]=0.
2083         m1.setCoords(d)
2084         self.assertTrue(m1.checkConsecutiveCellTypes())
2085         self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
2086         m1.renumberCells([1,0])
2087         self.assertTrue(m1.checkConsecutiveCellTypes())
2088         self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
2089         pass
2090
2091     def testSwig2DAAccumulate1(self):
2092         d=DataArrayInt(10) ; d.iota(0)
2093         self.assertEqual([45],d.accumulate())
2094         self.assertEqual(45,d.accumulate(0))
2095         d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
2096         self.assertEqual([135,145,155],d.accumulate())
2097         self.assertEqual(135,d.accumulate(0))
2098         self.assertEqual(145,d.accumulate(1))
2099         self.assertEqual(155,d.accumulate(2))
2100         d=DataArrayDouble(10) ; d.iota(0.)
2101         self.assertEqual([45.],d.accumulate())
2102         self.assertEqual(45.,d.accumulate(0))
2103         d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
2104         self.assertEqual([135.,145.,155.],d.accumulate())
2105         self.assertEqual(135.,d.accumulate(0))
2106         self.assertEqual(145.,d.accumulate(1))
2107         self.assertEqual(155.,d.accumulate(2))
2108         pass
2109
2110     def testSwig2UMeshDistanceToMesh1(self):
2111         m=MEDCouplingUMesh("toto",2)
2112         coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
2113         m.setCoords(coords)
2114         m.allocateCells(0)
2115         m.insertNextCell(NORM_TRI3,[0,1,2])
2116         a,b=m.distanceToPoint([-0.335,2.27,1.21])
2117         self.assertEqual(0,b)
2118         self.assertAlmostEqual(0.022360988100374124,a,14);
2119         a,b=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
2120         self.assertEqual(0,b)
2121         self.assertAlmostEqual(0.022360988100374124,a,14);
2122         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
2123         self.assertAlmostEqual(5.243302871282566,a,14)
2124         self.assertEqual(0,b)
2125         #
2126         m=MEDCouplingUMesh("toto",2)
2127         coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
2128         m.setCoords(coords)
2129         m.allocateCells(0)
2130         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
2131         m.checkConsistency()
2132         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
2133         a,b=m.distanceToPoint([5.,2.,0.1])
2134         self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b)
2135         a,b=m.distanceToPoint([5.,-2.,4.])
2136         self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b)
2137         m.allocateCells(0)
2138         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
2139         m.checkConsistency()
2140         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
2141         a,b=m.distanceToPoint([11.,3.,4.])
2142         self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b)
2143         a,b=m.distanceToPoint([4.,12.,5.])
2144         self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b)
2145         d=DataArrayDouble([-1.2,3.,2.],1,3)
2146         for elt in d:
2147             a,b=m.distanceToPoint(d)
2148             self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b)
2149             pass
2150         #
2151         m=MEDCouplingUMesh("toto",1)
2152         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
2153         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
2154         a,b=m.distanceToPoint([-0.1,4.1])
2155         self.assertAlmostEqual(0.14142135623730925,a,14)  # b==1 self.assertEqual(2,c)
2156         a,b=m.distanceToPoint([0.,3.9])
2157         self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) # self.assertEqual(2,c)
2158         pass
2159
2160     def testSwig2NonRegressionPartitionBySpreadZone1(self):
2161         m=MEDCouplingCMesh()
2162         arr=DataArrayDouble(6) ; arr.iota(0.)
2163         m.setCoords(arr,arr,arr)
2164         m=m.buildUnstructured()
2165         mPart=m[50,80,85,87,92,122]
2166         zones=mPart.partitionBySpreadZone()
2167         self.assertEqual(4,len(zones))
2168         self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
2169         self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
2170         self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
2171         self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
2172         #
2173         n,ni=m.computeNeighborsOfCells()
2174         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
2175         self.assertEqual(13,b) ; self.assertTrue(a.isIota(125))
2176         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
2177         self.assertEqual(12,b) ; self.assertTrue(a.isIota(125))
2178         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
2179         self.assertEqual(11,b) ; self.assertTrue(a.isIota(125))
2180         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
2181         self.assertEqual(12,b) ; self.assertTrue(a.isIota(125))
2182         pass
2183
2184     def testSwigUMeshInsertNextCell1(self):
2185         m=MEDCouplingUMesh("toto",2)
2186         #
2187         coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
2188         da=DataArrayInt([0,1,2])
2189         m.allocateCells(0)
2190         for i in xrange(5):
2191             m.insertNextCell(NORM_TRI3,da)
2192             pass
2193         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2])))
2194         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
2195         #
2196         da=DataArrayInt([0,1,2,3])
2197         m.allocateCells(0)
2198         for i in xrange(5):
2199             m.insertNextCell(NORM_TRI3,3,da)
2200             pass
2201         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2])))
2202         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
2203         #
2204         da=DataArrayInt([0,1])
2205         m.allocateCells(0)
2206         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
2207         #
2208         da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
2209         m.allocateCells(0)
2210         for t in da:
2211             m.insertNextCell(NORM_TRI3,t)
2212             pass
2213         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,0,1,3,3,0,1,4,3,0,1,5,3,0,1,6])))
2214         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
2215         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
2216         pass
2217
2218     def testSwigCurveLinearMesh1(self):
2219         m=MEDCouplingCurveLinearMesh("toto")
2220         m.setNodeGridStructure([2,3])
2221         coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
2222         m.setCoords(coords)
2223         m.checkConsistencyLight()
2224         m0=m.deepCopy()
2225         self.assertTrue(m0.isEqual(m,1e-12))
2226         m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
2227         self.assertTrue(not m0.isEqual(m,1e-12))
2228         m0=m.deepCopy()
2229         self.assertTrue(m0.isEqual(m,1e-12))
2230         self.assertEqual(m.getNodeGridStructure(),(2,3))
2231         pass
2232
2233     def testSimplexize3(self):
2234         m=MEDCouplingUMesh("toto",3)
2235         m.allocateCells(0)
2236         m.insertNextCell(NORM_TETRA4,[0,1,2,3])
2237         self.assertEqual([NORM_TETRA4],m.getAllGeoTypesSorted())
2238         m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
2239         self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted())
2240         m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
2241         self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted())
2242         m.insertNextCell(NORM_TETRA4,[20,21,22,23])
2243         self.assertEqual([NORM_TETRA4,NORM_HEXA8,NORM_TETRA4],m.getAllGeoTypesSorted())
2244         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
2245         c2=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0., 0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.],8,3) ; c2+=[2.,0.,0.]
2246         c3=c2+[2.,0.,0.]
2247         c4=c1+[6.,0.,0.]
2248         c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
2249         m.setCoords(c)
2250         m.checkConsistency()
2251         #
2252         m1=m.deepCopy()
2253         d1=m1.simplexize(PLANAR_FACE_5)
2254         m1.checkConsistency()
2255         vol1=m1.getMeasureField(False).getArray()
2256         self.assertTrue(vol1.isEqual(DataArrayDouble([1./6, 1./6, 1./6,1./6, 1./6, 1./3,1./6, 1./6, 1./6, 1./6, 1./3, 1./6]),1e-12))
2257         self.assertEqual(m1.getNodalConnectivity().getValues(),[14,0,1,2,3,14,4,9,5,6,14,4,8,9,11,14,4,7,11,6,14,9,11,10,6,14,4,9,6,11,14,12,17,13,14,14,12,16,17,19,14,12,15,19,14,14,17,19,18,14,14,12,17,14,19,14,20,21,22,23])
2258         self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
2259         self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
2260         #
2261         m2=m.deepCopy()
2262         d2=m2.simplexize(PLANAR_FACE_6)
2263         m2.checkConsistency()
2264         vol2=m2.getMeasureField(False).getArray()
2265         self.assertTrue(vol2.isEqual(DataArrayDouble([1./6, 1./6, 1./6,1./6, 1./6, 1./6,1./6,1./6, 1./6, 1./6, 1./6, 1./6,1./6,1./6]),1e-12))
2266         self.assertEqual(m2.getNodalConnectivity().getValues(),[14,0,1,2,3,14,4,9,5,10,14,4,5,6,10,14,4,8,9,10,14,4,11,8,10,14,4,6,7,10,14,4,7,11,10,14,12,17,13,18,14,12,13,14,18,14,12,16,17,18,14,12,19,16,18,14,12,14,15,18,14,12,15,19,18,14,20,21,22,23])
2267         self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
2268         self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
2269         pass
2270
2271     def testSwig2CurveLinearMesh2(self):
2272         c=MEDCouplingCMesh()
2273         #2D
2274         arr1=DataArrayDouble([0,1,3,7])
2275         arr2=DataArrayDouble([0,1,1.5])
2276         c.setCoords(arr1,arr2)
2277         u=c.buildUnstructured()
2278         coo=u.getCoords()
2279         cl=MEDCouplingCurveLinearMesh()
2280         cl.setCoords(coo)
2281         cl.setNodeGridStructure([4,3])
2282         cl.checkConsistency()
2283         li1=[1.,2.,4.,0.5,1.,2.]
2284         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
2285         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
2286         li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
2287         self.assertTrue(cl.computeCellCenterOfMass().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
2288         self.assertTrue(u.computeCellCenterOfMass().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
2289         #3D
2290         c.setCoords(arr1,arr2,arr2)
2291         u=c.buildUnstructured()
2292         coo=u.getCoords()
2293         cl=MEDCouplingCurveLinearMesh()
2294         cl.setCoords(coo)
2295         cl.setNodeGridStructure([4,3,3])
2296         cl.checkConsistency()
2297         li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
2298         li2_1=[0.5,0.5,0.5,2.,0.5,0.5,5.,0.5,0.5,0.5,1.25,0.5,2.,1.25,0.5,5.,1.25,0.5,0.5,0.5,1.25,2.,0.5,1.25,5.,0.5,1.25,0.5,1.25,1.25,2.,1.25,1.25,5.,1.25,1.25]
2299         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
2300         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
2301         self.assertTrue(cl.computeCellCenterOfMass().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
2302         self.assertTrue(u.computeCellCenterOfMass().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
2303         #1D spaceDim 1
2304         coo=DataArrayDouble(5) ; coo.iota(0.)
2305         coo=coo*coo
2306         cl.setCoords(coo)
2307         cl.setNodeGridStructure([5])
2308         cl.checkConsistency()
2309         li3=[1.,3.,5.,7.]
2310         li3_1=[0.5,2.5,6.5,12.5]
2311         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
2312         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
2313         self.assertTrue(cl.computeCellCenterOfMass().isEqual(DataArrayDouble(li3_1),1e-14))
2314         self.assertTrue(cl.buildUnstructured().computeCellCenterOfMass().isEqual(DataArrayDouble(li3_1),1e-14))
2315         #1D spaceDim 2
2316         coo=DataArrayDouble.Meld(coo,coo)
2317         cl.setCoords(coo)
2318         cl.checkConsistency()
2319         li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
2320         li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
2321         self.assertEqual(2,cl.getSpaceDimension())
2322         self.assertEqual(1,cl.getMeshDimension())
2323         self.assertEqual(4,cl.getNumberOfCells())
2324         self.assertEqual(5,cl.getNumberOfNodes())
2325         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
2326         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
2327         self.assertTrue(cl.computeCellCenterOfMass().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
2328         self.assertTrue(cl.buildUnstructured().computeCellCenterOfMass().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
2329         pass
2330
2331     def testSwig2CurveLinearMeshNonRegression1(self):
2332         coords=DataArrayDouble([0.0, 0.0, 0.10000000149011612, 0.6000000238418579, 0.10000000149011612, 0.30000001192092896, 1.100000023841858, 0.10000000149011612, 0.20000000298023224, 0.10000000149011612, 0.6000000238418579, 0.20000000298023224, 0.699999988079071, 0.6000000238418579, 0.10000000149011612, 1.2000000476837158, 0.6000000238418579, 0.30000001192092896, 0.10000000149011612, 1.100000023841858, 0.30000001192092896, 0.5, 1.100000023841858, 0.20000000298023224, 1.0, 1.2000000476837158, 0.10000000149011612, 0.0, 0.10000000149011612, 0.5, 0.5, 0.10000000149011612, 0.6000000238418579, 1.2000000476837158, 0.10000000149011612, 0.699999988079071, 0.10000000149011612, 0.6000000238418579, 0.699999988079071, 0.6000000238418579, 0.6000000238418579, 0.5, 1.100000023841858, 0.6000000238418579, 0.6000000238418579, 0.10000000149011612, 1.0, 0.6000000238418579, 0.699999988079071, 1.2000000476837158, 0.699999988079071, 0.8999999761581421, 1.0, 0.5, 0.10000000149011612, 0.10000000149011612, 1.2000000476837158, 0.699999988079071, 0.10000000149011612, 1.0, 1.0, 0.10000000149011612, 1.100000023841858, 0.10000000149011612, 0.6000000238418579, 1.100000023841858, 0.6000000238418579, 0.6000000238418579, 1.100000023841858, 1.100000023841858, 0.6000000238418579, 1.2000000476837158, 0.10000000149011612, 1.2000000476837158, 1.0, 0.5, 1.100000023841858, 1.2000000476837158, 1.2000000476837158, 1.100000023841858, 1.0],27,3)
2333         m=MEDCouplingCurveLinearMesh("toto")
2334         m.setCoords(coords)
2335         m.setNodeGridStructure([3,3,3])
2336         #
2337         vol=m.getMeasureField(False).getArray()
2338         self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
2339         self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
2340         #
2341         self.assertTrue(m.computeCellCenterOfMass().isEqual(m.buildUnstructured().computeCellCenterOfMass(),1e-12))
2342         pass
2343
2344     def testSwig2NonRegressionDASetSelectedComponents1(self):
2345         da=DataArrayDouble.New([1.,2.,3.,4.,5.,6.],3,2)
2346         dv=DataArrayDouble.New();
2347         dv.alloc(4,4)
2348         dv.fillWithZero()
2349         # da has less tuples than dv
2350         dv.setSelectedComponents(da,[1,0])
2351         #
2352         self.assertTrue(dv.isEqual(DataArrayDouble([2.,1.,0.,0.,4.,3.,0.,0.,6.,5.,0.,0.,0.,0.,0.,0.],4,4),1e-14))
2353         #
2354         da=DataArrayInt.New([1,2,3,4,5,6],3,2)
2355         dv=DataArrayInt.New();
2356         dv.alloc(4,4)
2357         dv.fillWithZero()
2358         # da has less tuples than dv
2359         dv.setSelectedComponents(da,[1,0])
2360         #
2361         self.assertTrue(dv.isEqual(DataArrayInt([2,1,0,0,4,3,0,0,6,5,0,0,0,0,0,0],4,4)))
2362         pass
2363
2364     def testSwigSetItem3(self):
2365         # 1-2
2366         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2367         d[3]=[1,2]
2368         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,1,2,0,0,0,0],6,2),1e-14))
2369         # 2-2 false
2370         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2371         d[[5,3,2]]=[1,2]
2372         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,1,2,1,2,0,0,1,2],6,2),1e-14))
2373         # 3-2 false
2374         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2375         d[:]=[1,2]
2376         self.assertTrue(d.isEqual(DataArrayDouble([1,2,1,2,1,2,1,2,1,2,1,2],6,2),1e-14))
2377         # 4-2 false
2378         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2379         d[DataArrayInt([0,3,4])]=[1,2]
2380         self.assertTrue(d.isEqual(DataArrayDouble([1,2,0,0,0,0,1,2,1,2,0,0],6,2),1e-14))
2381         # 5-2
2382         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2383         d[5,1]=[7]
2384         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,7],6,2),1e-14))
2385         # 6-2 false
2386         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2387         d[[3,5],1]=[7]
2388         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,7,0,0,0,7],6,2),1e-14))
2389         # 7-2 false
2390         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2391         d[:-1:2,1]=[7]
2392         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,7,0,0,0,7,0,0],6,2),1e-14))
2393         # 8-2 false
2394         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2395         d[DataArrayInt([0,3,4]),1]=[7]
2396         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,0,0,7,0,7,0,0],6,2),1e-14))
2397         # 9-2
2398         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2399         d[3,[1,0]]=[7,8]
2400         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,8,7,0,0,0,0],6,2),1e-14))
2401         # 10-2 false
2402         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2403         d[[1,3,4],[1,0]]=[7,8]
2404         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,8,7,0,0],6,2),1e-14))
2405         # 11-2 false
2406         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2407         d[1::2,[1,0]]=[7,8]
2408         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,0,0,8,7],6,2),1e-14))
2409         # 12-2 false
2410         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2411         d[DataArrayInt([1,4]),[1,0]]=[7,8]
2412         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,0,0,8,7,0,0],6,2),1e-14))
2413         # 13-2
2414         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2415         d[1,:-1]=[9]
2416         self.assertTrue(d.isEqual(DataArrayDouble([0,0,9,0,0,0,0,0,0,0,0,0],6,2),1e-14))
2417         # 14-2 false
2418         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2419         d[[1,4,5],:]=[7,8]
2420         self.assertTrue(d.isEqual(DataArrayDouble([0,0,7,8,0,0,0,0,7,8,7,8],6,2),1e-14))
2421         # 15-2 false
2422         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2423         d[1::2,:]=[3,9]
2424         self.assertTrue(d.isEqual(DataArrayDouble([0,0,3,9,0,0,3,9,0,0,3,9],6,2),1e-14))
2425         # 1-2
2426         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2427         d[3]=[1,2]
2428         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,1,2,0,0,0,0],6,2)))
2429         # 2-2 false
2430         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2431         d[[5,3,2]]=[1,2]
2432         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,1,2,1,2,0,0,1,2],6,2)))
2433         # 3-2 false
2434         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2435         d[:]=[1,2]
2436         self.assertTrue(d.isEqual(DataArrayInt([1,2,1,2,1,2,1,2,1,2,1,2],6,2)))
2437         # 4-2 false
2438         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2439         d[DataArrayInt([0,3,4])]=[1,2]
2440         self.assertTrue(d.isEqual(DataArrayInt([1,2,0,0,0,0,1,2,1,2,0,0],6,2)))
2441         # 5-2
2442         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2443         d[5,1]=[7]
2444         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,7],6,2)))
2445         # 6-2 false
2446         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2447         d[[3,5],1]=[7]
2448         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,7,0,0,0,7],6,2)))
2449         # 7-2 false
2450         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2451         d[:-1:2,1]=[7]
2452         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,7,0,0,0,7,0,0],6,2)))
2453         # 8-2 false
2454         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2455         d[DataArrayInt([0,3,4]),1]=[7]
2456         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,0,0,7,0,7,0,0],6,2)))
2457         # 9-2
2458         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2459         d[3,[1,0]]=[7,8]
2460         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,8,7,0,0,0,0],6,2)))
2461         # 10-2 false
2462         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2463         d[[1,3,4],[1,0]]=[7,8]
2464         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,8,7,0,0],6,2)))
2465         # 11-2 false
2466         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2467         d[1::2,[1,0]]=[7,8]
2468         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,0,0,8,7],6,2)))
2469         # 12-2 false
2470         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2471         d[DataArrayInt([1,4]),[1,0]]=[7,8]
2472         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,0,0,8,7,0,0],6,2)))
2473         # 13-2
2474         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2475         d[1,:-1]=[9]
2476         self.assertTrue(d.isEqual(DataArrayInt([0,0,9,0,0,0,0,0,0,0,0,0],6,2)))
2477         # 14-2 false
2478         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2479         d[[1,4,5],:]=[7,8]
2480         self.assertTrue(d.isEqual(DataArrayInt([0,0,7,8,0,0,0,0,7,8,7,8],6,2)))
2481         # 15-2 false
2482         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2483         d[1::2,:]=[3,9]
2484         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,9,0,0,3,9,0,0,3,9],6,2)))
2485         pass
2486
2487     def testSwig2ConvertLinearCellsToQuadratic1(self):
2488         coordsExp=DataArrayDouble([-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,-0.3,-0.05,-0.05,0.2,0.2,-0.05,-0.05,-0.3,0.45,-0.05,0.45,-0.3,0.45,0.2,0.7,-0.05,-0.05,0.7,0.2,0.45,-0.3,0.45,0.45,0.7,0.7,0.45],22,2)
2489         # 2D
2490         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
2491         m2D.convertLinearCellsToQuadratic(0)
2492         m2D.checkConsistency()
2493         self.assertEqual(m2D.getNodalConnectivity().getValues(),[8,0,3,4,1,9,10,11,12,6,1,4,2,11,13,14,6,4,5,2,15,16,13,8,6,7,4,3,17,18,10,19,8,7,8,5,4,20,21,15,18])
2494         self.assertEqual(m2D.getNodalConnectivityIndex().getValues(),[0,9,16,23,32,41])
2495         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
2496         # 1D
2497         m1D=MEDCouplingDataForTest.build2DTargetMesh_1().buildDescendingConnectivity()[0]
2498         m1D.convertLinearCellsToQuadratic(0)
2499         m1D.checkConsistency()
2500         self.assertEqual(m1D.getNodalConnectivity().getValues(),[2,0,3,9,2,3,4,10,2,4,1,11,2,1,0,12,2,4,2,13,2,2,1,14,2,4,5,15,2,5,2,16,2,6,7,17,2,7,4,18,2,3,6,19,2,7,8,20,2,8,5,21])
2501         self.assertEqual(m1D.getNodalConnectivityIndex().getValues(),[0,4,8,12,16,20,24,28,32,36,40,44,48,52])
2502         self.assertTrue(m1D.getCoords().isEqual(coordsExp,1e-14))
2503         # 3D
2504         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
2505         m2D.changeSpaceDimension(3)
2506         arr=DataArrayDouble(4);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
2507         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
2508         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
2509         cooTmp=m2D.getCoords()[:]
2510         m3D=m2D.buildExtrudedMesh(m1D,0)
2511         m3D.convertLinearCellsToQuadratic(0)
2512         m3D.checkConsistency()
2513         # check of new m3D content
2514         coordsExp2=[coordsExp.changeNbOfComponents(3,i) for i in xrange(4)]
2515         coordsExp3=[DataArrayDouble.Meld(cooTmp[:,[0,1]],cooTmp[:,2]+(0.5+float(i))) for i in xrange(3)]
2516         coordsExp4=DataArrayDouble.Aggregate([coordsExp2[0],coordsExp3[0],coordsExp2[1],coordsExp3[1],coordsExp2[2],coordsExp3[2],coordsExp2[3]])
2517         c=DataArrayDouble.Aggregate(m3D.getCoords(),coordsExp4)
2518         self.assertEqual(len(coordsExp4),115)
2519         self.assertEqual(len(m3D.getCoords()),115)
2520         a,b=c.findCommonTuples(1e-14)
2521         self.assertEqual(len(b),len(coordsExp4)+1)
2522         e,f=DataArrayInt.ConvertIndexArrayToO2N(2*115,a,b)
2523         self.assertEqual(f,115)
2524         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,0,1,2,3,4,5,6,7,8,36,37,38,39,48,49,53,54,58,59,60,66,67,44,47,52,45,46,57,64,65,70,9,10,11,12,13,14,15,16,17,40,41,42,43,50,51,55,56,61,62,63,68,69,75,78,81,76,77,84,88,89,92,18,19,20,21,22,23,24,25,26,71,72,73,74,79,80,82,83,85,86,87,90,91,97,100,103,98,99,106,110,111,114,27,28,29,30,31,32,33,34,35,93,94,95,96,101,102,104,105,107,108,109,112,113])))
2525         self.assertTrue(DataArrayInt([30,0,3,4,1,9,12,13,10,36,37,38,39,40,41,42,43,44,45,46,47,25,1,4,2,10,13,11,38,48,49,42,50,51,47,46,52,25,4,5,2,13,14,11,53,54,48,55,56,50,46,57,52,30,6,7,4,3,15,16,13,12,58,59,37,60,61,62,41,63,64,65,46,45,30,7,8,5,4,16,17,14,13,66,67,53,59,68,69,55,62,65,70,57,46,30,9,12,13,10,18,21,22,19,40,41,42,43,71,72,73,74,75,76,77,78,25,10,13,11,19,22,20,42,50,51,73,79,80,78,77,81,25,13,14,11,22,23,20,55,56,50,82,83,79,77,84,81,30,15,16,13,12,24,25,22,21,61,62,41,63,85,86,72,87,88,89,77,76,30,16,17,14,13,25,26,23,22,68,69,55,62,90,91,82,86,89,92,84,77,30,18,21,22,19,27,30,31,28,71,72,73,74,93,94,95,96,97,98,99,100,25,19,22,20,28,31,29,73,79,80,95,101,102,100,99,103,25,22,23,20,31,32,29,82,83,79,104,105,101,99,106,103,30,24,25,22,21,33,34,31,30,85,86,72,87,107,108,94,109,110,111,99,98,30,25,26,23,22,34,35,32,31,90,91,82,86,112,113,104,108,111,114,106,99]).isEqual(m3D.getNodalConnectivity()))
2526         self.assertTrue(DataArrayInt([0,21,37,53,74,95,116,132,148,169,190,211,227,243,264,285]).isEqual(m3D.getNodalConnectivityIndex()))
2527         # testing explode3DMeshTo1D
2528         m3DSlice0=m3D[:5]
2529         m3DSlice0.zipCoords()
2530         a,b,c,d,e=m3DSlice0.explode3DMeshTo1D()
2531         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,2,12,13,6,14,15,11,10,16,17,18,12,19,20,14,10,21,16,22,23,1,24,25,26,5,27,28,29,10,9,30,31,17,23,32,33,19,26,29,34,21,10])))
2532         self.assertTrue(c.isEqual(DataArrayInt([0,12,21,30,42,54])))
2533         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,0,1,0,0,0,3,0,1,0,0,0,3,0,1,2,3,4,0,1,1,2,1,1,2,1,1,2,2,4,2,2,4,2,2,4,3,3,4,3,3,3,4,3,3,3,4,4,4,4,4,4])))
2534         self.assertTrue(e.isEqual(DataArrayInt([0,1,3,5,6,7,9,11,12,13,15,20,22,24,25,27,28,30,32,33,35,36,38,39,41,42,43,45,46,47,49,50,51,52,53,54])))
2535         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([2,0,3,18,2,3,4,19,2,4,1,20,2,1,0,21,2,9,12,22,2,12,13,23,2,13,10,24,2,10,9,25,2,0,9,26,2,3,12,27,2,4,13,28,2,1,10,29,2,4,2,30,2,2,1,31,2,13,11,32,2,11,10,33,2,2,11,34,2,4,5,35,2,5,2,36,2,13,14,37,2,14,11,38,2,5,14,39,2,6,7,40,2,7,4,41,2,3,6,42,2,15,16,43,2,16,13,44,2,12,15,45,2,6,15,46,2,7,16,47,2,7,8,48,2,8,5,49,2,16,17,50,2,17,14,51,2,8,17,52])))
2536         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,84,88,92,96,100,104,108,112,116,120,124,128,132,136,140])))
2537         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([-0.3,-0.3,0.0,0.2,-0.3,0.0,0.7,-0.3,0.0,-0.3,0.2,0.0,0.2,0.2,0.0,0.7,0.2,0.0,-0.3,0.7,0.0,0.2,0.7,0.0,0.7,0.7,0.0,-0.3,-0.3,1.0,0.2,-0.3,1.0,0.7,-0.3,1.0,-0.3,0.2,1.0,0.2,0.2,1.0,0.7,0.2,1.0,-0.3,0.7,1.0,0.2,0.7,1.0,0.7,0.7,1.0,-0.3,-0.05,0.0,-0.05,0.2,0.0,0.2,-0.05,0.0,-0.05,-0.3,0.0,-0.3,-0.05,1.0,-0.05,0.2,1.0,0.2,-0.05,1.0,-0.05,-0.3,1.0,-0.3,-0.3,0.5,-0.3,0.2,0.5,0.2,0.2,0.5,0.2,-0.3,0.5,0.45,-0.05,0.0,0.45,-0.3,0.0,0.45,-0.05,1.0,0.45,-0.3,1.0,0.7,-0.3,0.5,0.45,0.2,0.0,0.7,-0.05,0.0,0.45,0.2,1.0,0.7,-0.05,1.0,0.7,0.2,0.5,-0.05,0.7,0.0,0.2,0.45,0.0,-0.3,0.45,0.0,-0.05,0.7,1.0,0.2,0.45,1.0,-0.3,0.45,1.0,-0.3,0.7,0.5,0.2,0.7,0.5,0.45,0.7,0.0,0.7,0.45,0.0,0.45,0.7,1.0,0.7,0.45,1.0,0.7,0.7,0.5],53,3),1e-14))
2538         pass
2539
2540     def testSwig2DataArrayPushBackValsSilent1(self):
2541         d=DataArrayDouble()
2542         d.pushBackValsSilent([4,5,6])
2543         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.]),1e-14))
2544         e=DataArrayDouble([1,2,3],1,3)
2545         for t in e: d.pushBackValsSilent(t)
2546         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.]),1e-14))
2547         d.pushBackValsSilent(DataArrayDouble([9,10.]))
2548         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
2549         d.pushBackValsSilent(DataArrayDouble(0,1))
2550         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
2551         e=DataArrayDouble([1,2,3],3,1)
2552         for t in e: d.pushBackValsSilent(t)
2553         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.]),1e-14))
2554         d.pushBackValsSilent(77)
2555         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.,77.]),1e-14))
2556         #
2557         d=DataArrayInt()
2558         d.pushBackValsSilent([4,5,6])
2559         self.assertTrue(d.isEqual(DataArrayInt([4,5,6])))
2560         e=DataArrayInt([1,2,3],1,3)
2561         for t in e: d.pushBackValsSilent(t)
2562         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3])))
2563         d.pushBackValsSilent(DataArrayInt([9,10]))
2564         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
2565         d.pushBackValsSilent(DataArrayInt(0,1))
2566         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
2567         e=DataArrayInt([1,2,3],3,1)
2568         for t in e: d.pushBackValsSilent(t)
2569         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3])))
2570         d.pushBackValsSilent(77)
2571         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3,77])))
2572         pass
2573
2574     def testSwig2ConvertLinearCellsToQuadratic2(self):
2575         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
2576         ret=m2D.convertLinearCellsToQuadratic(1)
2577         self.assertTrue(ret.isIota(5))
2578         m2D.checkConsistency()
2579         coordsExp=DataArrayDouble([-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,-0.3,-0.05,-0.05,0.2,0.2,-0.05,-0.05,-0.3,0.45,-0.05,0.45,-0.3,0.45,0.2,0.7,-0.05,-0.05,0.7,0.2,0.45,-0.3,0.45,0.45,0.7,0.7,0.45,-0.05,-0.05,0.3666666666666667,-0.1333333333333333,0.5333333333333332,0.03333333333333334,-0.05,0.45,0.45,0.45],27,2)
2580         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
2581         self.assertTrue(m2D.getNodalConnectivity().isEqual(DataArrayInt([9,0,3,4,1,9,10,11,12,22,7,1,4,2,11,13,14,23,7,4,5,2,15,16,13,24,9,6,7,4,3,17,18,10,19,25,9,7,8,5,4,20,21,15,18,26])))
2582         self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,10,18,26,36,46])))
2583         #
2584         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()[(0,3)] ; m2D.zipCoords()
2585         m2D.changeSpaceDimension(3)
2586         arr=DataArrayDouble(3);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
2587         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
2588         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
2589         cooTmp=m2D.getCoords()[:]
2590         m3D=m2D.buildExtrudedMesh(m1D,0)
2591         ret=m3D.convertLinearCellsToQuadratic(1)
2592         self.assertTrue(ret.isIota(4))
2593         m3D.checkConsistency()
2594         coordsExp2=DataArrayDouble([-0.3,-0.3,0.0,0.2,-0.3,0.0,-0.3,0.2,0.0,0.2,0.2,0.0,-0.3,0.7,0.0,0.2,0.7,0.0,-0.3,-0.3,1.0,0.2,-0.3,1.0,-0.3,0.2,1.0,0.2,0.2,1.0,-0.3,0.7,1.0,0.2,0.7,1.0,-0.3,-0.3,2.0,0.2,-0.3,2.0,-0.3,0.2,2.0,0.2,0.2,2.0,-0.3,0.7,2.0,0.2,0.7,2.0,-0.3,-0.05,0.0,-0.05,0.2,0.0,0.2,-0.05,0.0,-0.05,-0.3,0.0,-0.3,-0.05,1.0,-0.05,0.2,1.0,0.2,-0.05,1.0,-0.05,-0.3,1.0,-0.3,-0.3,0.5,-0.3,0.2,0.5,0.2,0.2,0.5,0.2,-0.3,0.5,-0.05,0.7,0.0,0.2,0.45,0.0,-0.3,0.45,0.0,-0.05,0.7,1.0,0.2,0.45,1.0,-0.3,0.45,1.0,-0.3,0.7,0.5,0.2,0.7,0.5,-0.3,-0.05,2.0,-0.05,0.2,2.0,0.2,-0.05,2.0,-0.05,-0.3,2.0,-0.3,-0.3,1.5,-0.3,0.2,1.5,0.2,0.2,1.5,0.2,-0.3,1.5,-0.05,0.7,2.0,0.2,0.45,2.0,-0.3,0.45,2.0,-0.3,0.7,1.5,0.2,0.7,1.5,-0.05,-0.05,0.0,-0.3,-0.05,0.5,-0.05,0.2,0.5,0.2,-0.05,0.5,-0.05,-0.3,0.5,-0.05,-0.05,1.0,-0.05,0.45,0.0,-0.05,0.7,0.5,0.2,0.45,0.5,-0.3,0.45,0.5,-0.05,0.45,1.0,-0.3,-0.05,1.5,-0.05,0.2,1.5,0.2,-0.05,1.5,-0.05,-0.3,1.5,-0.05,-0.05,2.0,-0.05,0.7,1.5,0.2,0.45,1.5,-0.3,0.45,1.5,-0.05,0.45,2.0,-0.05,-0.05,0.5,-0.05,0.45,0.5,-0.05,-0.05,1.5,-0.05,0.45,1.5],75,3)
2595         self.assertTrue(m3D.getCoords().isEqual(coordsExp2,1e-14))
2596         self.assertTrue(m3D.getNodalConnectivity().isEqual(DataArrayInt([27,0,2,3,1,6,8,9,7,18,19,20,21,22,23,24,25,26,27,28,29,51,52,53,54,55,56,71,27,4,5,3,2,10,11,9,8,30,31,19,32,33,34,23,35,36,37,28,27,57,58,59,53,60,61,72,27,6,8,9,7,12,14,15,13,22,23,24,25,38,39,40,41,42,43,44,45,56,62,63,64,65,66,73,27,10,11,9,8,16,17,15,14,33,34,23,35,46,47,39,48,49,50,44,43,61,67,68,63,69,70,74])))
2597         self.assertTrue(m3D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,28,56,84,112])))
2598         pass
2599
2600     def testSwig2GaussNEIntegral1(self):
2601         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
2602         m0=m2D[0] ; m0.zipCoords()
2603         m1=m2D[[1,2]] ; m1.zipCoords()
2604         m2=m2D[[3,4]] ; m2.zipCoords()
2605         m0.convertLinearCellsToQuadratic(1)
2606         m1.convertLinearCellsToQuadratic(0)
2607         m2.convertLinearCellsToQuadratic(1)
2608         m=MEDCouplingUMesh.MergeUMeshes([m0,m1,m2])
2609         m.mergeNodes(1e-12)
2610         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
2611         f.setMesh(m)
2612         arr=DataArrayDouble([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,
2613                              11.1,12.2,13.3,14.4,15.5,16.6,
2614                              21.1,22.2,23.3,24.4,25.5,26.6,
2615                              31.1,32.2,33.3,34.4,35.5,36.6,37.7,38.8,39.9,
2616                              41.1,42.2,43.3,44.4,45.5,46.6,47.7,48.8,49.9])
2617         arr2=DataArrayDouble(len(arr),2)
2618         arr2[:,0]=arr ; arr2[:,1]=arr+100
2619         f.setArray(arr2)
2620         f.checkConsistencyLight()
2621         res=f.integral(False)
2622         # a=25./81 ; b=40./81 ; c=64./81
2623         # p1=0.11169079483905 ; p2=0.0549758718227661
2624         # 1st compo
2625         # c0=(a*(1.1+2.2+3.3+4.4)+b*(5.5+6.6+7.7+8.8)+c*9.9)*0.25/3.9999999999999978 ; c0=1.5837962962962973
2626         # c1=(p2*(11.1+12.2+13.3)+p1*(14.4+15.5+16.6))*0.125/0.4999999999854482 ; c1=1.8014347172346943
2627         # c2=(p2*(21.1+22.2+23.3)+p1*(24.4+25.5+26.6))*0.125/0.4999999999854482 ; c2=3.0514347172346943
2628         # c3=(a*(31.1+32.2+33.3+34.4)+b*(35.5+36.6+37.7+38.8)+c*39.9)*0.25/3.9999999999999978 ; c3=9.0837962962963
2629         # c4=(a*(41.1+42.2+43.3+44.4)+b*(45.5+46.6+47.7+48.8)+c*49.9)*0.25/3.9999999999999978 ; c4=11.583796296296303
2630         # c0+c1+c2+c3+c4=27.104258323358287
2631         integExp0=27.104258323358287
2632         self.assertAlmostEqual(res[0],integExp0,13)
2633         # 2nd compo
2634         # c0=(a*(101.1+102.2+103.3+104.4)+b*(105.5+106.6+107.7+108.8)+c*109.9)*0.25/3.9999999999999978 ; c0=26.58379629629631
2635         # c1=(p2*(111.1+112.2+113.3)+p1*(114.4+115.5+116.6))*0.125/0.4999999999854482 ; c1=14.301434717234699
2636         # c2=(p2*(121.1+122.2+123.3)+p1*(124.4+125.5+126.6))*0.125/0.4999999999854482 ; c2=15.5514347172347
2637         # c3=(a*(131.1+132.2+133.3+134.4)+b*(135.5+136.6+137.7+138.8)+c*139.9)*0.25/3.9999999999999978 ; c3=34.08379629629631
2638         # c4=(a*(141.1+142.2+143.3+144.4)+b*(145.5+146.6+147.7+148.8)+c*149.9)*0.25/3.9999999999999978 ; c4=36.58379629629632
2639         # c0+c1+c2+c3+c4=127.10425832335835
2640         integExp1=127.10425832335835
2641         self.assertAlmostEqual(res[1],integExp1,12)
2642         meas=f.getDiscretization().getMeasureField(f.getMesh(),False)
2643         intPerTuple=meas*f
2644         res2=intPerTuple.accumulate()
2645         self.assertAlmostEqual(res2[0],integExp0,13)
2646         self.assertAlmostEqual(res2[1],integExp1,12)
2647         #
2648         meas2=f.buildMeasureField(False)
2649         intPerTuple=meas2*f
2650         res3=intPerTuple.accumulate()
2651         self.assertAlmostEqual(res3[0],integExp0,13)
2652         self.assertAlmostEqual(res3[1],integExp1,12)
2653         #
2654         res4=f.getWeightedAverageValue(False) # res4==res2 because sum of area of mesh is equal to 1
2655         self.assertAlmostEqual(res4[0],integExp0,13)
2656         self.assertAlmostEqual(res4[1],integExp1,12)
2657         #
2658         m.scale([0,0],2.)
2659         #
2660         res5=f.getWeightedAverageValue() # res4==res4 because weighted average is not sensitive to the scaling
2661         self.assertAlmostEqual(res5[0],integExp0,13)
2662         self.assertAlmostEqual(res5[1],integExp1,12)
2663         meas3=f.buildMeasureField(False)
2664         delta=4*meas2.getArray()-meas3.getArray()
2665         delta.abs()
2666         self.assertTrue(delta.isUniform(0.,1e-16))
2667         res6=f.integral(False)
2668         self.assertAlmostEqual(res6[0],4.*integExp0,12)
2669         self.assertAlmostEqual(res6[1],4.*integExp1,11)
2670         pass
2671
2672     def testSwig2SlowDADFindClosestTupleId(self):
2673         nbPts=[10,]
2674         for nbPt in nbPts:
2675             d=DataArrayDouble(nbPt) ; d.iota() ; d*=1./(nbPt-1)
2676             c=MEDCouplingCMesh() ; c.setCoords(d,d) ; m=c.buildUnstructured() ; pts=m.getCoords() ; del m
2677             #
2678             d0=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d0.iota() ; d0*=(3./((nbPt-1)*(nbPt-1))) ; d0=d0.applyFunc("exp(x)-1")
2679             d1=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d1.iota()
2680             d2=DataArrayDouble.Meld(d0,d1) ; d2=d2.fromPolarToCart() ; d2+=[0.32,0.73]
2681             ids=pts.findClosestTupleId(d2)
2682             #print "Start of costly computation"
2683             idsExpected=DataArrayInt(len(d2))
2684             tmp=1e300
2685             for i,elt in enumerate(d2):
2686                 l,m=(pts-elt).magnitude().getMinValue()
2687                 idsExpected.setIJSilent(i,0,m)
2688                 if l<tmp:
2689                     tmp=l ; tmp1=m ; tmp2=i
2690                     pass
2691                 pass
2692             #print "End of costly computation"
2693             self.assertTrue(idsExpected.isEqual(ids))
2694             a,b,c=pts.minimalDistanceTo(d2)
2695             self.assertEqual(tmp,a)
2696             self.assertEqual(tmp1,b)
2697             self.assertEqual(tmp2,c)
2698             #
2699             l=[d2[:,i] for i in [0,1]]
2700             for elt in l: elt.reverse()
2701             d2i=DataArrayDouble.Meld(l)
2702             ids1=pts.findClosestTupleId(d2i)
2703             idsExpectedI=idsExpected.deepCopy() ; idsExpectedI.reverse()
2704             self.assertTrue(idsExpectedI.isEqual(ids1))
2705             #
2706             l=[pts[:,i] for i in [0,1]]
2707             for elt in l: elt.reverse()
2708             ptsi=DataArrayDouble.Meld(l)
2709             ids2=ptsi.findClosestTupleId(d2)
2710             idsExpected2=nbPt*nbPt-1-ids
2711             self.assertTrue(idsExpected2.isEqual(ids2))
2712             #
2713             ids3=ptsi.findClosestTupleId(d2i)
2714             idsExpected3=idsExpected2.deepCopy() ; idsExpected3.reverse()
2715             self.assertTrue(idsExpected3.isEqual(ids3))
2716             pass
2717
2718     def testSwig2DataArrayAsciiChar1(self):
2719         alpha=DataArrayInt(26) ; alpha.iota(ord("A"))
2720         d=DataArrayAsciiChar(alpha.getValues(),2,13)
2721         d.setInfoOnComponents(["c%i"%(v) for v in xrange(13)])
2722         self.assertEqual('ABCDEFGHIJKLM',d.getTuple(0))
2723         self.assertEqual('NOPQRSTUVWXYZ',d.getTuple(1))
2724         self.assertEqual(2,d.getNumberOfTuples())
2725         self.assertEqual(26,d.getNbOfElems())
2726         self.assertEqual(13,d.getNumberOfComponents())
2727         dd=d.deepCopy()
2728         self.assertTrue(d.isEqual(dd))
2729         dd.setIJ(0,3,'d')
2730         self.assertTrue(not d.isEqual(dd))
2731         d.setIJ(0,3,ord('d'))
2732         self.assertTrue(d.isEqual(dd))
2733         d.rearrange(1)
2734         d.reserve(20)
2735         self.assertEqual(20,d.getNumberOfTuples())
2736         self.assertEqual(20,d.getNbOfElems())
2737         self.assertEqual(1,d.getNumberOfComponents())
2738         #
2739         d0=DataArrayAsciiChar([ord('a')],1,1)
2740         self.assertEqual('a',d0.asciiCharValue())
2741         self.assertTrue(not d0.empty())
2742         d0=DataArrayAsciiChar(0,3)
2743         self.assertTrue(d0.empty())
2744         d.pushBackSilent("U") ; d.pushBackSilent("V") ; d.pushBackSilent("W")
2745         self.assertEqual("W",d.popBackSilent())
2746         d.rearrange(2)
2747         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV'],d.toStrList())
2748         d.fillWithZero()
2749         self.assertEqual(11*[''],d.toStrList())
2750         d.fillWithValue('T')
2751         self.assertEqual(11*["TT"],d.toStrList())
2752         d.rearrange(1)
2753         self.assertTrue(d.isUniform("T"))
2754         d.rearrange(2)
2755         #
2756         dd.rearrange(2)
2757         dd2=dd.deepCopy()
2758         dd.renumberInPlace([3,1,2,4,0,11,10,9,8,7,5,12,6])
2759         self.assertEqual(dd.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
2760         dd.renumberInPlaceR([3,1,2,4,0,11,10,9,8,7,5,12,6])
2761         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV','WX','YZ'],dd.toStrList())
2762         e=dd.renumber([3,1,2,4,0,11,10,9,8,7,5,12,6])
2763         self.assertEqual(e.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
2764         e=dd.renumberR([3,1,2,4,0,11,10,9,8,7,5,12,6])
2765         self.assertEqual(e.toStrList(),['GH','Cd','EF','IJ','AB','WX','UV','ST','QR','OP','KL','YZ','MN'])
2766         e=dd.renumberAndReduce([1,1,1,1,1,1,1,2,0,0,0,0,0],3)
2767         self.assertEqual(['YZ','MN','OP'],e.toStrList())
2768         self.assertEqual(['GH','IJ'],dd.selectByTupleIdSafe([3,4]).toStrList())
2769         self.assertEqual(['AB','GH','MN','ST','YZ'],dd.selectByTupleIdSafeSlice(0,13,3).toStrList())
2770         dd3=dd.changeNbOfComponents(3,"G")
2771         self.assertEqual(['ABG','CdG','EFG','GHG','IJG','KLG','MNG','OPG','QRG','STG','UVG','WXG','YZG'],dd3.toStrList())
2772         dd3.rearrange(1) ; self.assertEqual("G",dd3.back()) ; dd3.rearrange(3)
2773         self.assertTrue(dd3.changeNbOfComponents(2,"\0").isEqual(dd))
2774         self.assertEqual(len(dd),13)
2775         d=DataArrayAsciiChar(13,2) ; d.fillWithValue('Y')
2776         dd3.meldWith(d)
2777         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','KLGYY','MNGYY','OPGYY','QRGYY','STGYY','UVGYY','WXGYY','YZGYY'],dd3.toStrList())
2778         self.assertEqual("d",dd3.getIJ(0,6))
2779         self.assertRaises(InterpKernelException,dd3.getIJSafe,0,6)
2780         self.assertEqual("d",dd3.getIJSafe(1,1))
2781         dd3.rearrange(1)
2782         e=dd3.findIdsEqual("Y")
2783         self.assertTrue(e.isEqual(DataArrayInt([3,4,8,9,13,14,18,19,23,24,28,29,33,34,38,39,43,44,48,49,53,54,58,59,60,63,64])))
2784         e=dd3.findIdsNotEqual("Y")
2785         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,5,6,7,10,11,12,15,16,17,20,21,22,25,26,27,30,31,32,35,36,37,40,41,42,45,46,47,50,51,52,55,56,57,61,62])))
2786         self.assertEqual(("d",6),dd3.getMaxValue())
2787         self.assertEqual(("A",0),dd3.getMinValue())
2788         self.assertEqual(26,dd3.findIdSequence("LGYYM"))
2789         self.assertEqual(-1,dd3.findIdSequence("LGYYN"))
2790         dd3.rearrange(5)
2791         self.assertEqual(7,dd3.findIdFirstEqualTuple("OPGYY"))
2792         self.assertTrue("OPGYY" in dd3)
2793         self.assertEqual(7,dd3.index("OPGYY"))
2794         self.assertEqual(-1,dd3.findIdFirstEqualTuple("OPGYP"))
2795         dd3.rearrange(1)
2796         self.assertEqual(2,dd3.findIdFirstEqual("OPGYY"))
2797         self.assertTrue(dd3.presenceOfValue("OPGYY"))
2798         self.assertTrue("O" in dd3)
2799         self.assertTrue(not dd3.presenceOfValue("z"))
2800         self.assertTrue("z" not in dd3)
2801         dd3.rearrange(5)
2802         l=list(dd3)
2803         self.assertEqual([e.buildDAAsciiChar().toStrList()[0] for e in list(dd3)],dd3.toStrList())
2804         dd3.reAlloc(5)
2805         dd4=DataArrayChar.Aggregate(dd3,dd3)
2806         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd4.toStrList())
2807         dd5=DataArrayChar.Aggregate([dd4,dd3,dd4])
2808         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd5.toStrList())
2809         # getitem,__iter__,__setitem__
2810         a=list(dd3)
2811         self.assertEqual("ABGYY",str(a[0]))
2812         dd4=dd3[::2]
2813         self.assertEqual(['ABGYY','EFGYY','IJGYY'],dd4.toStrList())
2814         dd4=dd3[(3,2,1)]
2815         self.assertEqual(['GHGYY','EFGYY','CdGYY'],dd4.toStrList())
2816         dd4=dd3[:]
2817         dd4[::2]=["12","345","67890"]
2818         self.assertEqual(['12   ','CdGYY','345  ','GHGYY','67890'],dd4.toStrList())
2819         dd4=dd3[:]
2820         dd4[[1,2]]=" "
2821         self.assertEqual(['ABGYY','     ','     ','GHGYY','IJGYY'],dd4.toStrList())
2822         dd4=dd3[:]
2823         dd4[4]='12345'
2824         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
2825         dd4[0]=dd4[1]
2826         self.assertEqual(['CdGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
2827         dd4=DataArrayAsciiChar(["abc","de","fghi"])
2828         self.assertEqual(['abc ','de  ','fghi'],dd4.toStrList())
2829         dd4=DataArrayAsciiChar(["abc","de","fghi"],"t")
2830         self.assertEqual(['abct','dett','fghi'],dd4.toStrList())
2831         pass
2832
2833     def testSwig2GaussNELocalizationOfDiscValues(self):
2834         m=MEDCouplingDataForTest.build2DTargetMesh_3()[[0,1,3,4,5,6,8,9]] # suppression of polygons
2835         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
2836         f.setMesh(m)
2837         loc=f.getLocalizationOfDiscr()
2838         self.assertEqual(42,len(loc))
2839         self.assertTrue(loc.isEqual(DataArrayDouble([0.,0.,1.,0.,0.5,1.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,1.,0.,0.5,1.,0.5,0.,0.75,0.5,0.25,0.5,0.,0.,1.,0.,1.,1.,0.,1.,0.5,0.,1.,0.5,0.5,1.,0.,0.5,0.,0.,0.5,1.,1.,0.,0.,0.,0.,1.,1.,1.,1.,0.,0.,0.,0.5,1.,1.,0.,0.25,0.5,0.75,0.5,0.5,0.,0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],42,2),1e-13))
2840         m.changeSpaceDimension(3)
2841         m.getCoords()[:,2]=7.
2842         loc=f.getLocalizationOfDiscr()
2843         self.assertEqual(42,len(loc))
2844         self.assertTrue(loc.isEqual(DataArrayDouble([0.,0.,7.,1.,0.,7.,0.5,1.,7.,0.,0.,7.,1.,0.,7.,1.,1.,7.,0.,1.,7.,0.,0.,7.,1.,0.,7.,0.5,1.,7.,0.5,0.,7.,0.75,0.5,7.,0.25,0.5,7.,0.,0.,7.,1.,0.,7.,1.,1.,7.,0.,1.,7.,0.5,0.,7.,1.,0.5,7.,0.5,1.,7.,0.,0.5,7.,0.,0.,7.,0.5,1.,7.,1.,0.,7.,0.,0.,7.,0.,1.,7.,1.,1.,7.,1.,0.,7.,0.,0.,7.,0.5,1.,7.,1.,0.,7.,0.25,0.5,7.,0.75,0.5,7.,0.5,0.,7.,0.,0.,7.,0.,1.,7.,1.,1.,7.,1.,0.,7.,0.,0.5,7.,0.5,1.,7.,1.,0.5,7.,0.5,0.,7.],42,3),1e-13))
2845         pass
2846
2847     def testSwig2GaussMeasureAndIntegral(self):
2848         ft=MEDCouplingDataForTest.buildFieldOnGauss_1()
2849         mea=ft.buildMeasureField(False)
2850         mea.checkConsistencyLight()
2851         self.assertTrue(mea.getArray().isEqual(DataArrayDouble([-0.08504076274779823,-0.06378057206084897,-0.08504076274779869,-0.10630095343474463,-0.12756114412169625,-0.10630095343474734,-0.0637805720608491,-0.0850407627477968,-0.1063009534347449,-0.0850407627477994,-0.10630095343474809,-0.1275611441216954,-0.037205333702161475,-0.037205333702161475,-0.037205333702161475,-0.037205333702161475,-0.047835429045636084,-0.047835429045636084,-0.047835429045636084,-0.047835429045636084,-0.05846552438911087,-0.05846552438911087,-0.05846552438911087,-0.05846552438911087,-0.037205333702161725,-0.037205333702161725,-0.037205333702161725,-0.037205333702161725,-0.047835429045635834,-0.047835429045635834,-0.047835429045635834,-0.047835429045635834,-0.05846552438911058,-0.05846552438911058,-0.05846552438911058,-0.05846552438911058,-0.03879154890291829,-0.03879154890291829,-0.03879154890291829,-0.04120270848015563,-0.04120270848015563,-0.04120270848015563,-0.03393028948486933,-0.03393028948486933,-0.03393028948486933,-0.03151955746491709,-0.03151955746491709,-0.03151955746491709,-0.02424752187358276,-0.02424752187358276,-0.02424752187358276,-0.026657914642918758,-0.026657914642918758,-0.026657914642918758,-0.04120270848015456,-0.04120270848015456,-0.04120270848015456,-0.03879154890291757,-0.03879154890291757,-0.03879154890291757,-0.031519557464916595,-0.031519557464916595,-0.031519557464916595,-0.03393028948487046,-0.03393028948487046,-0.03393028948487046,-0.0266579146429191,-0.0266579146429191,-0.0266579146429191,-0.024247521873582645,-0.024247521873582645,-0.024247521873582645,-0.01851718920904466,-0.01851718920904466,-0.01851718920904466,-0.01851718920904466,-0.029627502734471456,-0.029627502734471456,-0.029627502734471456,-0.029627502734471456,-0.04740400437515433,-0.015150427534672922,-0.015150427534672922,-0.015150427534672922,-0.015150427534672922,-0.024240684055476674,-0.024240684055476674,-0.024240684055476674,-0.024240684055476674,-0.038785094488762675,-0.011783665860301345,-0.011783665860301345,-0.011783665860301345,-0.011783665860301345,-0.018853865376482152,-0.018853865376482152,-0.018853865376482152,-0.018853865376482152,-0.030166184602371443,-0.018517189209044892,-0.018517189209044892,-0.018517189209044892,-0.018517189209044892,-0.029627502734471827,-0.029627502734471827,-0.029627502734471827,-0.029627502734471827,-0.04740400437515492,-0.015150427534672776,-0.015150427534672776,-0.015150427534672776,-0.015150427534672776,-0.02424068405547644,-0.02424068405547644,-0.02424068405547644,-0.02424068405547644,-0.03878509448876231,-0.011783665860301277,-0.011783665860301277,-0.011783665860301277,-0.011783665860301277,-0.01885386537648204,-0.01885386537648204,-0.01885386537648204,-0.01885386537648204,-0.030166184602371266]),1e-14))
2852         f=MEDCouplingFieldDouble(ft)
2853         arr=DataArrayDouble(126,2)
2854         arr[:,0]=range(126)
2855         arr[:,1]=range(126)
2856         arr[:,1]+=1000
2857         f.setArray(arr)
2858         f.checkConsistencyLight()
2859         self.assertTrue(DataArrayDouble(f.integral(False)).isEqual(DataArrayDouble([-211.66121638700983,-4863.9563007698835]),1e-11))
2860         self.assertTrue(DataArrayDouble(f.getWeightedAverageValue()).isEqual(DataArrayDouble([45.4960858131136,1045.496085813114]),1e-11))
2861         self.assertTrue(DataArrayDouble(f.normL1()).isEqual(DataArrayDouble([45.49608581311362,1045.496085813114]),1e-11))
2862         self.assertTrue(DataArrayDouble(f.normL2()).isEqual(DataArrayDouble([58.16846378340898,1046.1241521947334]),1e-11))
2863         pass
2864
2865     def testSwig2FieldDiscretizationComputeMeshRestrictionFromTupleIds1(self):
2866         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1()
2867         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
2868         f.setMesh(m)
2869         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4,5,6,8,9,10,14,15,16,17])
2870         self.assertTrue(a.isEqual(DataArrayInt([1,4])))
2871         self.assertTrue(b.isEqual(DataArrayInt([4,5,6,14,15,16,17])))
2872         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),DataArrayInt([0,1,2,3,5,7,8,9,10,11,12,18]))
2873         self.assertTrue(a.isEqual(DataArrayInt([0,2])))
2874         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,7,8,9])))
2875         #
2876         f=MEDCouplingFieldDouble(ON_CELLS)
2877         f.setMesh(m)
2878         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4])
2879         self.assertTrue(a.isEqual(DataArrayInt([3,4])))
2880         self.assertTrue(b.isEqual(DataArrayInt([3,4])))
2881         #
2882         f=MEDCouplingFieldDouble(ON_NODES)
2883         f.setMesh(m)
2884         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[1,2,3,4])
2885         self.assertTrue(a.isEqual(DataArrayInt([1])))
2886         self.assertTrue(b.isEqual(DataArrayInt([1,2,4])))
2887         #
2888         f=MEDCouplingDataForTest.buildFieldOnGauss_1()
2889         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[0,11,12,13,14,15,17,18,19,36,37,38,115,117,118,119,120,121,122,123,124,125])
2890         self.assertTrue(a.isEqual(DataArrayInt([0,11,12,18,35])))
2891         self.assertTrue(b.isEqual(DataArrayInt([0,11,12,13,14,15,36,37,38,117,118,119,120,121,122,123,124,125])))
2892         #
2893         d=DataArrayInt([0,3,7,9,15,18])
2894         e=DataArrayInt([0,1,2,3,7,8,15,16,17])
2895         a,b=d.findIdsRangesInListOfIds(e)
2896         self.assertTrue(a.isEqual(DataArrayInt([0,2,4])))
2897         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,7,8,15,16,17])))
2898         pass
2899
2900     @unittest.skipUnless(checkFreeMemory((223456789*16)/(1024)), "Not enough memory")
2901     def testSwig2BigMem(self):
2902         if MEDCouplingSizeOfVoidStar()==64:
2903             d=DataArrayAsciiChar(223456789,16)
2904             self.assertTrue(d.getNumberOfTuples(),223456789)
2905             self.assertTrue(d.getNumberOfComponents(),16)
2906             d.setIJ(223456788,5,"r")
2907             self.assertTrue(d.getIJ(223456788,5),'r')
2908             d[223456787]="1234567890123456"
2909             self.assertTrue(d[223456787],'1234567890123456')
2910             self.assertRaises(InterpKernelException,d.rearrange,1)# fails because it would lead to nb of tuples > 2147483647
2911             pass
2912         pass
2913
2914     def testSwig2DAReverseMultiCompo1(self):
2915         d=DataArrayDouble(6,2)
2916         d[:,0]=range(6)
2917         d[:,1]=range(10,16)
2918         d.reverse()
2919         self.assertTrue(d.isEqual(DataArrayDouble([5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],6,2),1e-14))
2920         d=DataArrayDouble(7,2)
2921         d[:,0]=range(7)
2922         d[:,1]=range(10,17)
2923         d.reverse()
2924         self.assertTrue(d.isEqual(DataArrayDouble([6.,16.,5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],7,2),1e-14))
2925         #
2926         d=DataArrayInt(6,2)
2927         d[:,0]=range(6)
2928         d[:,1]=range(10,16)
2929         d.reverse()
2930         self.assertTrue(d.isEqual(DataArrayInt([5,15,4,14,3,13,2,12,1,11,0,10],6,2)))
2931         d=DataArrayInt(7,2)
2932         d[:,0]=range(7)
2933         d[:,1]=range(10,17)
2934         d.reverse()
2935         self.assertTrue(d.isEqual(DataArrayInt([6,16,5,15,4,14,3,13,2,12,1,11,0,10],7,2)))
2936         pass
2937
2938     def testSwigDAPow1(self):
2939         d=DataArrayInt(10)
2940         d.iota(0)
2941         d1=d.deepCopy()
2942         d.setIJ(2,0,-2)
2943         self.assertTrue((d**2).isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
2944         self.assertTrue((d**3).isEqual(DataArrayInt([0,1,-8,27,64,125,216,343,512,729])))
2945         for elt in [d]:
2946             elt**=2
2947             pass
2948         self.assertTrue(d.isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
2949         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayInt([1,1,4,27])))
2950         self.assertTrue((3**d1[:4]).isEqual(DataArrayInt([1,3,9,27])))
2951         d2=d1[:4]
2952         d2**=d2
2953         self.assertTrue(d2.isEqual(DataArrayInt([1,1,4,27])))
2954         self.assertRaises(InterpKernelException,d2.__pow__,-1)#non supporting negative pow in DataArrayInt.__pow__
2955         self.assertRaises(InterpKernelException,d2.__ipow__,-1)#non supporting negative pow in DataArrayInt.__pow__
2956         #
2957         d=DataArrayDouble(10)
2958         d.iota(0)
2959         d1=d.deepCopy()
2960         d.setIJ(2,0,-2.)
2961         self.assertTrue((d**2).isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
2962         self.assertTrue((d**3).isEqual(DataArrayDouble([0,1,-8,27,64,125,216,343,512,729]),1e-12))
2963         self.assertRaises(InterpKernelException,d.__pow__,3.1)#3.1 is double not integer -> not supporting negative values in d
2964         for elt in [d]:
2965             elt**=2
2966             pass
2967         self.assertTrue(d.isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
2968         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayDouble([1,1,4,27]),1e-12))
2969         self.assertTrue((3**d1[:4]).isEqual(DataArrayDouble([1,3,9,27]),1e-12))
2970         d2=d1[:4]
2971         d2**=d2
2972         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,4,27]),1e-12))
2973         d2**=-0.5
2974         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,1./2,1./sqrt(27.)]),1e-14))
2975         d3=-1./d1[1:5]
2976         self.assertTrue((3**d3).isEqual(DataArrayDouble([0.3333333333333333,0.5773502691896257,0.6933612743506348,0.7598356856515925]),1e-14))
2977         d4=d3.deepCopy() ; d4.abs()
2978         self.assertTrue((d4**d3).isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
2979         d4**=d3
2980         self.assertTrue(d4.isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
2981         pass
2982
2983     def testSwig2Baryenter3DForCellsWithVolumeZero1(self):
2984         coo=DataArrayDouble([0.,0.,0.,1.,0.,0.,0.,1.,0.],3,3)
2985         m2=MEDCouplingUMesh("mesh",2)
2986         m2.allocateCells(0)
2987         m2.insertNextCell(NORM_POLYGON,[0,1,2])
2988         m2.setCoords(coo)
2989         m2.checkConsistency()
2990         #
2991         coo2=DataArrayDouble([0.,0.,0.,0.,0.,0.,0.,0.,2.],3,3)
2992         m1=MEDCouplingUMesh("mesh",1)
2993         m1.allocateCells(0)
2994         m1.insertNextCell(NORM_SEG2,[0,1])
2995         m1.insertNextCell(NORM_SEG2,[1,2])
2996         m1.setCoords(coo2)
2997         m1.checkConsistency()
2998         #
2999         m3=m2.buildExtrudedMesh(m1,0)
3000         m3.insertNextCell(NORM_POLYHED,[3,4,5,-1,8,7,6,-1,4,3,6,7,-1,5,4,7,8,-1,5,4,-1,3,5,8,6])# addition of face #4 with null surface
3001         self.assertTrue(m3.computeCellCenterOfMass().isEqual(DataArrayDouble([0.3333333333333333,0.3333333333333333,0.,0.3333333333333333,0.3333333333333333,1.,0.3333333333333333,0.3333333333333333,1.],3,3),1e-13))
3002         m4,a,b,c,d=m3.buildDescendingConnectivity()
3003         self.assertTrue(m4.computeCellCenterOfMass().isEqual(DataArrayDouble([0.3333333333333333,0.3333333333333333,0.,0.3333333333333333,0.3333333333333333,0.,0.5,0.,0.,0.5,0.5,0.,0.,0.5,0.,0.3333333333333333,0.3333333333333333,2.,0.5,0.,1.,0.5,0.5,1.,0.,0.5,1.,0.5,0.5,0.],10,3),1e-13))
3004         pass
3005
3006     def testSwigRepr1(self):
3007         d=DataArrayDouble()
3008         self.assertTrue(len(d.__repr__())<120)
3009         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
3010         for i in xrange(100):
3011             d.alloc(i,1) ; d.iota(1.1234567890123456) ; d*=1e123
3012             self.assertTrue(len(d.__repr__())<500)
3013             pass
3014         for i in xrange(50):
3015             d.alloc(i,2) ; d.rearrange(1) ; d.iota(1.1234567890123456) ; d.rearrange(2) ; d*=1e123
3016             self.assertTrue(len(d.__repr__())<500)
3017             pass
3018         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
3019         for i in xrange(2,4):
3020             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
3021             pass
3022         d.alloc(0,9)
3023         self.assertTrue(len(d.__repr__())<120)
3024         #
3025         d=DataArrayInt()
3026         self.assertTrue(len(d.__repr__())<100)
3027         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
3028         for i in xrange(100):
3029             d.alloc(i,1) ; d.iota(123456789)
3030             self.assertTrue(len(d.__repr__())<500)
3031             pass
3032         for i in xrange(50):
3033             d.alloc(i,2) ; d.rearrange(1) ; d.iota(123456789) ; d.rearrange(2)
3034             self.assertTrue(len(d.__repr__())<500)
3035             pass
3036         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
3037         for i in xrange(2,10):
3038             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
3039             pass
3040         d.alloc(0,9)
3041         self.assertTrue(len(d.__repr__())<100)
3042         #
3043         d=DataArrayAsciiChar()
3044         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
3045         d.alloc(2,16) ; d[:]='1234567890ABCDEF'
3046         self.assertTrue(len(d.__repr__())<500)
3047         d.alloc(2000,16) ; d[:]='1234567890ABCDEF'
3048         self.assertTrue(len(d.__repr__())<500)
3049         d.alloc(0,16) ; d[:]='1234567890ABCDEF'
3050         self.assertTrue(len(d.__repr__())<120)
3051         #
3052         d=DataArrayByte()
3053         self.assertTrue(len(d.__repr__())<100)
3054         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
3055         d.alloc(0,16) ; self.assertTrue(len(d.__repr__())<100)
3056         d.alloc(5,1) ; d.fillWithValue(127)
3057         self.assertTrue(len(d.__repr__())<200)
3058         d.alloc(1000,1) ; d.fillWithValue(127)
3059         self.assertTrue(len(d.__repr__())<500)
3060         d.alloc(1000,3) ; d.fillWithValue(127)
3061         self.assertTrue(len(d.__repr__())<500)
3062         pass
3063
3064     def testSwig2MeshComputeIsoBarycenterOfNodesPerCell1(self):
3065         coo=DataArrayDouble([26.17509821414239,5.0374,200.,26.175098214142388,-5.0374,200.,17.450065476094927,20.1496,200.,8.725032738047464,25.187,200.,43.62516369023732,5.0374,200.,34.90013095218986,10.0748,200.,34.900130952189855,-10.0748,200.,43.625163690237315,-5.0374,200.,26.175098214142402,25.187,200.,26.175098214142395,35.2618,200.,17.45006547609493,40.2992,200.,8.725032738047469,35.2618,200.,26.17509821414239,5.0374,200.,26.175098214142388,-5.0374,200.,17.450065476094927,20.1496,200.,8.725032738047464,25.187,200.,43.62516369023732,5.0374,200.,34.90013095218986,10.0748,200.,34.900130952189855,-10.0748,200.,43.625163690237315,-5.0374,200.,26.175098214142402,25.187,200.,26.175098214142395,35.2618,200.,17.45006547609493,40.2992,200.,8.725032738047469,35.2618,200.],24,3)
3066         m=MEDCouplingUMesh.New("toto",3)
3067         m.allocateCells(0)
3068         m.insertNextCell(NORM_POLYHED,[4,5,0,1,6,7,-1,19,18,13,12,17,16,-1,5,4,16,17,-1,0,5,17,12,-1,1,0,12,13,-1,6,1,13,18,-1,7,6,18,19,-1,4,7,19,16])
3069         m.insertNextCell(NORM_POLYHED,[9,10,11,3,2,8,-1,20,14,15,23,22,21,-1,10,9,21,22,-1,11,10,22,23,-1,3,11,23,15,-1,2,3,15,14,-1,8,2,14,20,-1,9,8,20,21])
3070         m.setCoords(coo)
3071         m.checkConsistency()
3072         #
3073         dReference=DataArrayDouble([(34.900130952189848,0.,200),(17.450065476094931,30.2244,200.)])
3074         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
3075         m.getNodalConnectivity().setIJ(87,0,24)
3076         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
3077         m.getNodalConnectivity().setIJ(87,0,-2)
3078         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
3079         m.getNodalConnectivity().setIJ(87,0,21)# put again 21 as at the beginning
3080         #
3081         self.assertTrue(m.unPolyze())
3082         self.assertEqual([NORM_HEXGP12],m.getAllGeoTypes())
3083         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
3084         m.getNodalConnectivity().setIJ(25,0,24)
3085         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
3086         m.getNodalConnectivity().setIJ(25,0,-1)
3087         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
3088         pass
3089
3090     def testSwig2NonRegressionBugDescHexa20(self):
3091         coo=DataArrayDouble([0.,0.,0.,1.23,0.,0.,0.615,0.,0.,0.,2.1,0.,0.615,2.1,0.,1.23,2.1,0.,1.23,1.05,0.,0.,1.05,0.,0.,0.,2.16,1.23,0.,2.16,1.23,2.1,2.16,0.,2.1,2.16,0.,0.,4.32,0.615,0.,4.32,1.23,0.,4.32,1.23,1.05,4.32,1.23,2.1,4.32,0.615,2.1,4.32,0.,2.1,4.32,0.,1.05,4.32],20,3)
3092         m=MEDCouplingUMesh('mesh',3)
3093         m.allocateCells(0)
3094         m.insertNextCell(NORM_HEXA20,[0,3,5,1,12,18,16,14,7,4,6,2,19,17,15,13,8,11,10,9])
3095         m.setCoords(coo)
3096         m.checkConsistency()
3097         #
3098         a,b,c,d,e=m.buildDescendingConnectivity()
3099         m2=MEDCouplingUMesh('mesh',2)
3100         m2.allocateCells(0)
3101         m2.setCoords(coo)
3102         conn2=[[0,3,5,1,7,4,6,2],[12,14,16,18,13,15,17,19],[0,12,18,3,8,19,11,7],[3,18,16,5,11,17,10,4],[5,16,14,1,10,15,9,6],[1,14,12,0,9,13,8,2]]
3103         for i in xrange(6):
3104             m2.insertNextCell(NORM_QUAD8,conn2[i])
3105             pass
3106         self.assertTrue(m2.isEqual(a,1e-12))
3107         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
3108         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
3109         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
3110         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
3111         #
3112         m.convertQuadraticCellsToLinear() ; m.zipCoords()
3113         m.convertLinearCellsToQuadratic(1)
3114         #
3115         coo2=DataArrayDouble([0.,0.,0.,1.23,0.,0.,0.,2.1,0.,1.23,2.1,0.,0.,0.,4.32,1.23,0.,4.32,1.23,2.1,4.32,0.,2.1,4.32,0.,1.05,0.,0.615,2.1,0.,1.23,1.05,0.,0.615,0.,0.,0.,1.05,4.32,0.615,2.1,4.32,1.23,1.05,4.32,0.615,0.,4.32,0.,0.,2.16,0.,2.1,2.16,1.23,2.1,2.16,1.23,0.,2.16,0.615,1.05,0.,0.,1.05,2.16,0.615,2.1,2.16,1.23,1.05,2.16,0.615,0.,2.16,0.615,1.05,4.32,0.615,1.05,2.16],27,3)
3116         m3=MEDCouplingUMesh("mesh",3)
3117         m3.allocateCells(1)
3118         m3.insertNextCell(NORM_HEXA27,[0,2,3,1,4,7,6,5,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26])
3119         m3.setCoords(coo2)
3120         self.assertTrue(m3.isEqual(m,1e-12))
3121         #
3122         a,b,c,d,e=m.buildDescendingConnectivity()
3123         conn4=[[0,2,3,1,8,9,10,11,20],[4,5,6,7,15,14,13,12,25],[0,4,7,2,16,12,17,8,21],[2,7,6,3,17,13,18,9,22],[3,6,5,1,18,14,19,10,23],[1,5,4,0,19,15,16,11,24]]
3124         m4=MEDCouplingUMesh("mesh",2)
3125         m4.allocateCells(0)
3126         for i in xrange(6):
3127             m4.insertNextCell(NORM_QUAD9,conn4[i])
3128             pass
3129         m4.setCoords(coo2)
3130         self.assertTrue(m4.isEqual(a,1e-12))
3131         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
3132         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
3133         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
3134         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
3135         pass
3136
3137     def testSwigAdvGauss(self):
3138         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
3139         f.setDiscretization(None)
3140         f.__repr__() ; f.__str__()
3141         #
3142         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
3143         d=f.getDiscretization()
3144         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
3145         d.setArrayOfDiscIds(i)
3146         f.__repr__() ; f.__str__()
3147         i2=d.getArrayOfDiscIds()
3148         self.assertEqual(i.__repr__(),i2.__repr__())
3149         #
3150         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
3151         f.setDiscretization(None)
3152         f.__repr__() ; f.__str__()
3153         #
3154         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
3155         d=f.getDiscretization()
3156         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
3157         d.setArrayOfDiscIds(i)
3158         f.__repr__() ; f.__str__()
3159         #
3160         gl=MEDCouplingGaussLocalization(NORM_SEG2,[0,1],[0.5],[1.])
3161         gl.setWeights([3.])
3162         gl.__repr__() ; gl.__str__()
3163         gl=MEDCouplingGaussLocalization(NORM_ERROR)
3164         gl.setWeights([3.])
3165         gl.__repr__() ; gl.__str__()
3166         pass
3167
3168     def testSwig2NonRegressionBugSubstractInPlaceDM(self):
3169         m0=MEDCouplingCMesh()
3170         arr=DataArrayDouble(5,1) ; arr.iota(0.)
3171         m0.setCoords(arr,arr)
3172         m0=m0.buildUnstructured()
3173         m00=m0[::2] ; m00.simplexize(0) ; m01=m0[1::2]
3174         m0=MEDCouplingUMesh.MergeUMeshes([m00,m01])
3175         m0.getCoords()[:]*=1/4.
3176         m0.setName("mesh")
3177         #
3178         NodeField=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; NodeField.setTime(5.6,5,6) ; NodeField.setMesh(m0)
3179         NodeField.setName("NodeField")
3180         NodeField.fillFromAnalytic(1,"exp(-((x-1)*(x-1)+(y-1)*(y-1)))") ; NodeField.getArray().setInfoOnComponent(0,"powernode [W]")
3181         proc0=m0.getCellsInBoundingBox([(0.,0.4),(0.,0.4)],1e-10)
3182         proc1=proc0.buildComplement(m0.getNumberOfCells())
3183         #
3184         NodeField0=NodeField[proc0] ; NodeField0.getMesh().setName(m0.getName())
3185         NodeField1=NodeField[proc1] ; NodeField1.getMesh().setName(m0.getName())
3186         #
3187         NodeField_read=MEDCouplingFieldDouble.MergeFields([NodeField0,NodeField1])
3188         NodeField_read.mergeNodes(1e-10)
3189         NodeFieldCpy=NodeField.deepCopy()
3190         NodeFieldCpy.mergeNodes(1e-10)
3191         NodeField.checkConsistencyLight()
3192         self.assertTrue(not NodeField.getArray().isUniform(0.,1e-12))
3193         NodeField.substractInPlaceDM(NodeField_read,10,1e-12)
3194         self.assertTrue(NodeField.getArray().isUniform(0.,1e-12))
3195         pass
3196
3197     def testSwigFieldOperationOpen1(self):
3198         ## MEDCouplingFieldDouble.__add__
3199         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3200         f=MEDCouplingFieldDouble(ON_CELLS)
3201         f.setMesh(m)
3202         arr=DataArrayDouble(5,2)
3203         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
3204         f2=f.clone(True)
3205         self.assertRaises(InterpKernelException,f.__add__,2)
3206         self.assertRaises(InterpKernelException,f.__add__,range(5))
3207         self.assertRaises(InterpKernelException,f.__add__,arr)
3208         self.assertRaises(InterpKernelException,f.__add__,f2)
3209         f.setArray(DataArrayDouble())
3210         self.assertRaises(InterpKernelException,f.__add__,2)
3211         self.assertRaises(InterpKernelException,f.__add__,range(5))
3212         self.assertRaises(InterpKernelException,f.__add__,arr)
3213         self.assertRaises(InterpKernelException,f.__add__,f2)
3214         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3215         f.getArray().alloc(5,2)
3216         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3217         ff=f+2
3218         ff.checkConsistencyLight()
3219         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
3220         ff=f+arr
3221         ff.checkConsistencyLight()
3222         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
3223         self.assertRaises(InterpKernelException,f.__add__,f2)
3224         f2.setArray(arr)
3225         ff=f+f2
3226         ff.checkConsistencyLight()
3227         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
3228         ff=f+[5,8]
3229         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
3230         ### MEDCouplingFieldDouble.__sub__
3231         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3232         f=MEDCouplingFieldDouble(ON_CELLS)
3233         f.setMesh(m)
3234         arr=DataArrayDouble(5,2)
3235         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
3236         f2=f.clone(True)
3237         self.assertRaises(InterpKernelException,f.__sub__,2)
3238         self.assertRaises(InterpKernelException,f.__sub__,range(5))
3239         self.assertRaises(InterpKernelException,f.__sub__,arr)
3240         self.assertRaises(InterpKernelException,f.__sub__,f2)
3241         f.setArray(DataArrayDouble())
3242         self.assertRaises(InterpKernelException,f.__sub__,2)
3243         self.assertRaises(InterpKernelException,f.__sub__,range(5))
3244         self.assertRaises(InterpKernelException,f.__sub__,arr)
3245         self.assertRaises(InterpKernelException,f.__sub__,f2)
3246         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3247         f.getArray().alloc(5,2)
3248         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3249         ff=f-2
3250         ff.checkConsistencyLight()
3251         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
3252         ff=f-arr
3253         ff.checkConsistencyLight()
3254         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
3255         self.assertRaises(InterpKernelException,f.__sub__,f2)
3256         f2.setArray(arr)
3257         ff=f-f2
3258         ff.checkConsistencyLight()
3259         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
3260         ff=f-[5,8]
3261         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-5,-1),(-4,0),(-3,1),(-2,2),(-1,3)]),1e-12))
3262         ### MEDCouplingFieldDouble.__mul__
3263         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3264         f=MEDCouplingFieldDouble(ON_CELLS)
3265         f.setMesh(m)
3266         arr=DataArrayDouble(5,2)
3267         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
3268         f2=f.clone(True)
3269         self.assertRaises(InterpKernelException,f.__mul__,2)
3270         self.assertRaises(InterpKernelException,f.__mul__,range(5))
3271         self.assertRaises(InterpKernelException,f.__mul__,arr)
3272         self.assertRaises(InterpKernelException,f.__mul__,f2)
3273         f.setArray(DataArrayDouble())
3274         self.assertRaises(InterpKernelException,f.__mul__,2)
3275         self.assertRaises(InterpKernelException,f.__mul__,range(5))
3276         self.assertRaises(InterpKernelException,f.__mul__,arr)
3277         self.assertRaises(InterpKernelException,f.__mul__,f2)
3278         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3279         f.getArray().alloc(5,2)
3280         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3281         ff=f*2
3282         ff.checkConsistencyLight()
3283         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
3284         ff=f*arr
3285         ff.checkConsistencyLight()
3286         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
3287         self.assertRaises(InterpKernelException,f.__mul__,f2)
3288         f2.setArray(arr)
3289         ff=f*f2
3290         ff.checkConsistencyLight()
3291         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
3292         ff=f*[5,8]
3293         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
3294         ### MEDCouplingFieldDouble.__div__
3295         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3296         f=MEDCouplingFieldDouble(ON_CELLS)
3297         f.setMesh(m)
3298         arr=DataArrayDouble(5,2)
3299         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
3300         f2=f.clone(True)
3301         self.assertRaises(InterpKernelException,f.__div__,2)
3302         self.assertRaises(InterpKernelException,f.__div__,range(5))
3303         self.assertRaises(InterpKernelException,f.__div__,arr)
3304         self.assertRaises(InterpKernelException,f.__div__,f2)
3305         f.setArray(DataArrayDouble())
3306         self.assertRaises(InterpKernelException,f.__div__,2)
3307         self.assertRaises(InterpKernelException,f.__div__,range(5))
3308         self.assertRaises(InterpKernelException,f.__div__,arr)
3309         self.assertRaises(InterpKernelException,f.__div__,f2)
3310         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3311         f.getArray().alloc(5,2)
3312         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3313         self.assertRaises(InterpKernelException,f.__div__,0)
3314         ff=f/2
3315         ff.checkConsistencyLight()
3316         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
3317         ff=f/arr
3318         ff.checkConsistencyLight()
3319         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,2),(0.6666666666666666,1.5),(0.75,1.25),(0.8,1.1)]),1e-12))
3320         self.assertRaises(InterpKernelException,f.__div__,f2)
3321         f2.setArray(arr)
3322         ff=f/f2
3323         ff.checkConsistencyLight()
3324         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,2),(0.6666666666666666,1.5),(0.75,1.25),(0.8,1.1)]),1e-12))
3325         ff=f/[5,8]
3326         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0.875),(0.2,1),(0.4,1.125),(0.6,1.25),(0.8,1.375)]),1e-12))
3327         ### MEDCouplingFieldDouble.__pow__
3328         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3329         f=MEDCouplingFieldDouble(ON_CELLS)
3330         f.setMesh(m)
3331         arr=DataArrayDouble(5)
3332         arr[:]=[1,1,3,2,0]
3333         f2=f.clone(True)
3334         self.assertRaises(InterpKernelException,f.__div__,2)
3335         self.assertRaises(InterpKernelException,f.__div__,range(5))
3336         self.assertRaises(InterpKernelException,f.__div__,arr)
3337         self.assertRaises(InterpKernelException,f.__div__,f2)
3338         f.setArray(DataArrayDouble())
3339         self.assertRaises(InterpKernelException,f.__div__,2)
3340         self.assertRaises(InterpKernelException,f.__div__,range(5))
3341         self.assertRaises(InterpKernelException,f.__div__,arr)
3342         self.assertRaises(InterpKernelException,f.__div__,f2)
3343         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3344         f.getArray().alloc(5,1)
3345         f.getArray()[:]=range(2,7)
3346         ff=f**2
3347         ff.checkConsistencyLight()
3348         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([4,9,16,25,36]),1e-12))
3349         ff=f**arr
3350         ff.checkConsistencyLight()
3351         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
3352         f2.setArray(arr)
3353         ff=f**f2
3354         ff.checkConsistencyLight()
3355         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
3356         ## MEDCouplingFieldDouble.__iadd__
3357         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3358         f=MEDCouplingFieldDouble(ON_CELLS)
3359         f.setMesh(m)
3360         arr=DataArrayDouble(5,2)
3361         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
3362         f2=f.clone(True)
3363         self.assertRaises(InterpKernelException,f.__iadd__,2)
3364         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
3365         self.assertRaises(InterpKernelException,f.__iadd__,arr)
3366         self.assertRaises(InterpKernelException,f.__iadd__,f2)
3367         f.setArray(DataArrayDouble())
3368         self.assertRaises(InterpKernelException,f.__iadd__,2)
3369         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
3370         self.assertRaises(InterpKernelException,f.__iadd__,arr)
3371         self.assertRaises(InterpKernelException,f.__iadd__,f2)
3372         f.getArray().alloc(5,2)
3373         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3374         f.checkConsistencyLight()
3375         f+=2
3376         f.checkConsistencyLight()
3377         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
3378         f+=arr
3379         f.checkConsistencyLight()
3380         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(4,12),(6,15),(8,18),(10,21)]),1e-12))
3381         f2.setArray(arr)
3382         f+=f2
3383         f.checkConsistencyLight()
3384         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(5,14),(8,19),(11,24),(14,29)]),1e-12))
3385         f+=[0.1,0.2]
3386         f.checkConsistencyLight()
3387         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2.1,9.2),(5.1,14.2),(8.1,19.2),(11.1,24.2),(14.1,29.2)]),1e-12))
3388         ## MEDCouplingFieldDouble.__isub__
3389         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3390         f=MEDCouplingFieldDouble(ON_CELLS)
3391         f.setMesh(m)
3392         arr=DataArrayDouble(5,2)
3393         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
3394         f2=f.clone(True)
3395         self.assertRaises(InterpKernelException,f.__isub__,2)
3396         self.assertRaises(InterpKernelException,f.__isub__,range(5))
3397         self.assertRaises(InterpKernelException,f.__isub__,arr)
3398         self.assertRaises(InterpKernelException,f.__isub__,f2)
3399         f.setArray(DataArrayDouble())
3400         self.assertRaises(InterpKernelException,f.__isub__,2)
3401         self.assertRaises(InterpKernelException,f.__isub__,range(5))
3402         self.assertRaises(InterpKernelException,f.__isub__,arr)
3403         self.assertRaises(InterpKernelException,f.__isub__,f2)
3404         f.getArray().alloc(5,2)
3405         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3406         f.checkConsistencyLight()
3407         f-=2
3408         f.checkConsistencyLight()
3409         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
3410         f-=arr
3411         f.checkConsistencyLight()
3412         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-2,4),(-2,3),(-2,2),(-2,1)]),1e-12))
3413         f2.setArray(arr)
3414         f-=f2
3415         f.checkConsistencyLight()
3416         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-3,2),(-4,-1),(-5,-4),(-6,-7)]),1e-12))
3417         f-=[0.1,0.2]
3418         f.checkConsistencyLight()
3419         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2.1,4.8),(-3.1,1.8),(-4.1,-1.2),(-5.1,-4.2),(-6.1,-7.2)]),1e-12))
3420         ## MEDCouplingFieldDouble.__imul__
3421         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3422         f=MEDCouplingFieldDouble(ON_CELLS)
3423         f.setMesh(m)
3424         arr=DataArrayDouble(5,2)
3425         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
3426         f2=f.clone(True)
3427         self.assertRaises(InterpKernelException,f.__imul__,2)
3428         self.assertRaises(InterpKernelException,f.__imul__,range(5))
3429         self.assertRaises(InterpKernelException,f.__imul__,arr)
3430         self.assertRaises(InterpKernelException,f.__imul__,f2)
3431         f.setArray(DataArrayDouble())
3432         self.assertRaises(InterpKernelException,f.__imul__,2)
3433         self.assertRaises(InterpKernelException,f.__imul__,range(5))
3434         self.assertRaises(InterpKernelException,f.__imul__,arr)
3435         self.assertRaises(InterpKernelException,f.__imul__,f2)
3436         f.getArray().alloc(5,2)
3437         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3438         f.checkConsistencyLight()
3439         f*=2
3440         f.checkConsistencyLight()
3441         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
3442         f*=arr
3443         f.checkConsistencyLight()
3444         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,32),(8,72),(18,120),(32,176)]),1e-12))
3445         f2.setArray(arr)
3446         f*=f2
3447         f.checkConsistencyLight()
3448         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,64),(16,288),(54,720),(128,1408)]),1e-12))
3449         f*=[0.1,0.2]
3450         f.checkConsistencyLight()
3451         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(0.2,12.8),(1.6,57.6),(5.4,144),(12.8,281.6)]),1e-12))
3452         ## MEDCouplingFieldDouble.__idiv__
3453         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3454         f=MEDCouplingFieldDouble(ON_CELLS)
3455         f.setMesh(m)
3456         arr=DataArrayDouble(5,2)
3457         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
3458         f2=f.clone(True)
3459         self.assertRaises(InterpKernelException,f.__idiv__,2)
3460         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
3461         self.assertRaises(InterpKernelException,f.__idiv__,arr)
3462         self.assertRaises(InterpKernelException,f.__idiv__,f2)
3463         f.setArray(DataArrayDouble())
3464         self.assertRaises(InterpKernelException,f.__idiv__,2)
3465         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
3466         self.assertRaises(InterpKernelException,f.__idiv__,arr)
3467         self.assertRaises(InterpKernelException,f.__idiv__,f2)
3468         f.getArray().alloc(5,2)
3469         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3470         f.checkConsistencyLight()
3471         f/=2
3472         f.checkConsistencyLight()
3473         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
3474         f/=arr
3475         f.checkConsistencyLight()
3476         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,1.75),(0.25,1),(0.3333333333333333,0.75),(0.375,0.625),(0.4,0.55)]),1e-12))
3477         f2.setArray(arr)
3478         f/=f2
3479         f.checkConsistencyLight()
3480         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0.875),(0.125,0.25),(0.1111111111111111,0.125),(0.09375,0.078125),(0.08,0.055)]),1e-12))
3481         f/=[0.1,0.2]
3482         f.checkConsistencyLight()
3483         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,4.375),(1.25,1.25),(1.1111111111111111,0.625),(0.9375,0.390625),(0.8,0.275)]),1e-12))
3484         ## MEDCouplingFieldDouble.__ipow__
3485         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3486         f=MEDCouplingFieldDouble(ON_CELLS)
3487         f.setMesh(m)
3488         arr=DataArrayDouble(5,2)
3489         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
3490         f2=f.clone(True)
3491         self.assertRaises(InterpKernelException,f.__ipow__,2)
3492         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
3493         self.assertRaises(InterpKernelException,f.__ipow__,arr)
3494         self.assertRaises(InterpKernelException,f.__ipow__,f2)
3495         f.setArray(DataArrayDouble())
3496         self.assertRaises(InterpKernelException,f.__ipow__,2)
3497         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
3498         self.assertRaises(InterpKernelException,f.__ipow__,arr)
3499         self.assertRaises(InterpKernelException,f.__ipow__,f2)
3500         f.getArray().alloc(5,2)
3501         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3502         f.checkConsistencyLight()
3503         f**=2
3504         f.checkConsistencyLight()
3505         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,49),(1,64),(4,81),(9,100),(16,121)]),1e-12))
3506          ## MEDCouplingFieldDouble.__radd__
3507         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3508         f=MEDCouplingFieldDouble(ON_CELLS)
3509         f.setMesh(m)
3510         arr=DataArrayDouble(5,2)
3511         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
3512         f2=f.clone(True)
3513         self.assertRaises(InterpKernelException,f.__radd__,2)
3514         self.assertRaises(InterpKernelException,f.__radd__,range(5))
3515         self.assertRaises(InterpKernelException,f.__radd__,arr)
3516         self.assertRaises(InterpKernelException,f.__radd__,f2)
3517         f.setArray(DataArrayDouble())
3518         self.assertRaises(InterpKernelException,f.__radd__,2)
3519         self.assertRaises(InterpKernelException,f.__radd__,range(5))
3520         self.assertRaises(InterpKernelException,f.__radd__,arr)
3521         self.assertRaises(InterpKernelException,f.__radd__,f2)
3522         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3523         f.getArray().alloc(5,2)
3524         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3525         ff=2+f
3526         ff.checkConsistencyLight()
3527         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
3528         ff=arr+f
3529         ff.checkConsistencyLight()
3530         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
3531         self.assertRaises(InterpKernelException,f.__radd__,f2)
3532         ff=[5,8]+f
3533         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
3534         ### MEDCouplingFieldDouble.__rsub__
3535         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3536         f=MEDCouplingFieldDouble(ON_CELLS)
3537         f.setMesh(m)
3538         arr=DataArrayDouble(5,2)
3539         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
3540         f2=f.clone(True)
3541         self.assertRaises(InterpKernelException,f.__rsub__,2)
3542         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
3543         self.assertRaises(InterpKernelException,f.__rsub__,arr)
3544         self.assertRaises(InterpKernelException,f.__rsub__,f2)
3545         f.setArray(DataArrayDouble())
3546         self.assertRaises(InterpKernelException,f.__rsub__,2)
3547         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
3548         self.assertRaises(InterpKernelException,f.__rsub__,arr)
3549         self.assertRaises(InterpKernelException,f.__rsub__,f2)
3550         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3551         f.getArray().alloc(5,2)
3552         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3553         ff=2-f
3554         ff.checkConsistencyLight()
3555         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,-5),(1,-6),(0,-7),(-1,-8),(-2,-9)]),1e-12))
3556         ff=arr-f
3557         ff.checkConsistencyLight()
3558         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,-7),(0,-6),(0,-5),(0,-4),(0,-3)]),1e-12))
3559         self.assertRaises(InterpKernelException,f.__rsub__,f2)
3560         ### MEDCouplingFieldDouble.__rmul__
3561         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3562         f=MEDCouplingFieldDouble(ON_CELLS)
3563         f.setMesh(m)
3564         arr=DataArrayDouble(5,2)
3565         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
3566         f2=f.clone(True)
3567         self.assertRaises(InterpKernelException,f.__rmul__,2)
3568         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
3569         self.assertRaises(InterpKernelException,f.__rmul__,arr)
3570         self.assertRaises(InterpKernelException,f.__rmul__,f2)
3571         f.setArray(DataArrayDouble())
3572         self.assertRaises(InterpKernelException,f.__rmul__,2)
3573         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
3574         self.assertRaises(InterpKernelException,f.__rmul__,arr)
3575         self.assertRaises(InterpKernelException,f.__rmul__,f2)
3576         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3577         f.getArray().alloc(5,2)
3578         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3579         ff=2*f
3580         ff.checkConsistencyLight()
3581         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
3582         ff=arr*f
3583         ff.checkConsistencyLight()
3584         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
3585         self.assertRaises(InterpKernelException,f.__rmul__,f2)
3586         ff=f*[5,8]
3587         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
3588         ### MEDCouplingFieldDouble.__rdiv__
3589         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3590         f=MEDCouplingFieldDouble(ON_CELLS)
3591         f.setMesh(m)
3592         arr=DataArrayDouble(5,2)
3593         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
3594         f2=f.clone(True)
3595         self.assertRaises(InterpKernelException,f.__rdiv__,2)
3596         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
3597         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
3598         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
3599         f.setArray(DataArrayDouble())
3600         self.assertRaises(InterpKernelException,f.__rdiv__,2)
3601         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
3602         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
3603         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
3604         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3605         f.getArray().alloc(5,2)
3606         f.getArray()[:,0]=range(1,6) ; f.getArray()[:,1]=f.getArray()[:,0]+7
3607         ff=2/f
3608         ff.checkConsistencyLight()
3609         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,0.25),(1,0.22222222222222221),(0.66666666666666663,0.20000000000000001),(0.5,0.18181818181818182),(0.40000000000000002,0.16666666666666666)]),1e-12))
3610         ff=arr/f
3611         ff.checkConsistencyLight()
3612         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(1,0.25),(1,0.44444444444444442),(1,0.59999999999999998),(1,0.72727272727272729),(1,0.83333333333333337)]),1e-12))
3613         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
3614         pass
3615
3616     pass
3617
3618 if __name__ == '__main__':
3619     unittest.main()
3620