1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2022 CEA/DEN, EDF R&D
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.
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.
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
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 from medcoupling import *
25 from math import pi,e,sqrt,cos,sin
26 from datetime import datetime
27 from MEDCouplingDataForTest import MEDCouplingDataForTest
28 import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@edf.fr
29 from sys import platform
31 def checkFreeMemory(size):
33 Get node total memory and memory usage
37 if platform not in ["win32"]:
38 with open('/proc/meminfo', 'r') as mem:
42 if str(sline[0]) == 'MemTotal:':
43 dic['total'] = int(sline[1])
44 elif str(sline[0]) in ('MemFree:', 'Buffers:', 'Cached:'):
47 dic['used'] = int(dic['total']) - int(dic['free'])
48 ret = dic['free'] > size
49 #TODO: extend this method for Windows OS
53 class MEDCouplingBasicsTest4(unittest.TestCase):
54 def testSwigDADOp4(self):
55 da = DataArrayDouble.New(list(range(6, 30)), 12, 2)
56 self.assertEqual(12,da.getNumberOfTuples());
57 self.assertEqual(2,da.getNumberOfComponents());
59 self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
63 self.assertEqual(2,da.getNumberOfTuples());
64 self.assertEqual(12,da.getNumberOfComponents());
66 self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
70 da2=DataArrayDouble.New(12,1)
74 self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
78 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.]
80 self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
84 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.]
85 self.assertEqual(12,da.getNumberOfTuples());
86 self.assertEqual(2,da.getNumberOfComponents());
88 self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
90 for pos,elt in enumerate(dabis):
93 self.assertEqual(12,da.getNumberOfTuples());
94 self.assertEqual(2,da.getNumberOfComponents());
97 self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
100 da = DataArrayDouble.New(list(range(6, 30)), 12, 2)
101 da2 = DataArrayDouble.New(list(range(12)), 12, 1)
104 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.]
106 self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
110 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.]
111 self.assertEqual(12,da.getNumberOfTuples());
112 self.assertEqual(2,da.getNumberOfComponents());
114 self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
116 for pos,elt in enumerate(dabis):
119 self.assertEqual(12,da.getNumberOfTuples());
120 self.assertEqual(2,da.getNumberOfComponents());
121 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.]
123 self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
126 da = DataArrayDouble.New(list(range(6, 30)), 12, 2)
127 da2 = DataArrayDouble.New(list(range(12)), 12, 1)
130 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.]
132 self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
136 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.]
137 self.assertEqual(12,da.getNumberOfTuples());
138 self.assertEqual(2,da.getNumberOfComponents());
140 self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
142 for pos,elt in enumerate(dabis):
145 self.assertEqual(12,da.getNumberOfTuples());
146 self.assertEqual(2,da.getNumberOfComponents());
147 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]
149 self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
152 da = DataArrayDouble.New(list(range(6, 30)), 12, 2)
153 da2 = DataArrayDouble.New(list(range(1, 13)), 12, 1)
156 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]
158 self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
162 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]
163 self.assertEqual(12,da.getNumberOfTuples());
164 self.assertEqual(2,da.getNumberOfComponents());
166 self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
168 for pos,elt in enumerate(dabis):
171 self.assertEqual(12,da.getNumberOfTuples());
172 self.assertEqual(2,da.getNumberOfComponents());
173 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]
175 self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
179 def testSwigDAIOp4(self):
180 da = DataArrayInt.New(list(range(6, 30)), 12, 2)
181 self.assertEqual(12,da.getNumberOfTuples());
182 self.assertEqual(2,da.getNumberOfComponents());
184 self.assertEqual(da.getIJ(0,i),i+6)
188 self.assertEqual(2,da.getNumberOfTuples());
189 self.assertEqual(12,da.getNumberOfComponents());
191 self.assertEqual(da.getIJ(0,i),i+6)
195 da2=DataArrayInt.New(12,1)
199 self.assertEqual(dabis.getIJ(0,i),-(i+6))
203 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]
205 self.assertEqual(da.getIJ(0,i),expected1[i])
209 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]
210 self.assertEqual(12,da.getNumberOfTuples());
211 self.assertEqual(2,da.getNumberOfComponents());
213 self.assertEqual(da.getIJ(0,i),expected2[i])
215 for pos,elt in enumerate(dabis):
218 self.assertEqual(12,da.getNumberOfTuples());
219 self.assertEqual(2,da.getNumberOfComponents());
222 self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
225 da = DataArrayInt.New(list(range(6, 30)), 12, 2)
226 da2 = DataArrayInt.New(list(range(12)), 12, 1)
229 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]
231 self.assertEqual(da.getIJ(0,i),expected1[i])
235 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]
236 self.assertEqual(12,da.getNumberOfTuples());
237 self.assertEqual(2,da.getNumberOfComponents());
239 self.assertEqual(da.getIJ(0,i),expected2[i])
241 for pos,elt in enumerate(dabis):
244 self.assertEqual(12,da.getNumberOfTuples());
245 self.assertEqual(2,da.getNumberOfComponents());
246 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]
248 self.assertEqual(da.getIJ(0,i),expected3[i])
251 da = DataArrayInt.New(list(range(6, 30)), 12, 2)
252 da2 = DataArrayInt.New(list(range(12)), 12, 1)
255 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]
257 self.assertEqual(da.getIJ(0,i),expected1[i])
261 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]
262 self.assertEqual(12,da.getNumberOfTuples());
263 self.assertEqual(2,da.getNumberOfComponents());
265 self.assertEqual(da.getIJ(0,i),expected2[i])
267 for pos,elt in enumerate(dabis):
270 self.assertEqual(12,da.getNumberOfTuples());
271 self.assertEqual(2,da.getNumberOfComponents());
272 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]
274 self.assertEqual(da.getIJ(0,i),expected3[i])
277 da = DataArrayInt.New(list(range(6, 30)), 12, 2)
278 da2 = DataArrayInt.New(list(range(1, 13)), 12, 1)
281 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]
283 self.assertEqual(da.getIJ(0,i),expected1[i])
286 da/=DataArrayInt.New([2,3],1,2)
287 self.assertEqual(12,da.getNumberOfTuples());
288 self.assertEqual(2,da.getNumberOfComponents());
289 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]
291 self.assertEqual(da.getIJ(0,i),expected2[i])
295 def testSwigDADOp5(self):
296 da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
298 da2=DataArrayDouble.New([5.,8.,10.,12])
299 self.assertEqual(4,da2.getNumberOfTuples());
300 self.assertEqual(1,da2.getNumberOfComponents());
302 self.assertEqual(4,da3.getNumberOfTuples());
303 self.assertEqual(3,da3.getNumberOfComponents());
304 expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
306 self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
309 self.assertEqual(4,da3.getNumberOfTuples());
310 self.assertEqual(3,da3.getNumberOfComponents());
312 self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
314 # Test new API of classmethod DataArrayDouble.New
315 vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
316 da=DataArrayDouble.New(vals)
317 self.assertEqual(12,da.getNumberOfTuples());
318 self.assertEqual(1,da.getNumberOfComponents());
320 self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
322 da=DataArrayDouble.New(vals,12)
323 self.assertEqual(12,da.getNumberOfTuples());
324 self.assertEqual(1,da.getNumberOfComponents());
326 self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
328 da=DataArrayDouble.New(vals,1,12)
329 self.assertEqual(1,da.getNumberOfTuples());
330 self.assertEqual(12,da.getNumberOfComponents());
332 self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
334 da=DataArrayDouble.New(vals,6,2)
335 self.assertEqual(6,da.getNumberOfTuples());
336 self.assertEqual(2,da.getNumberOfComponents());
338 self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
340 da=DataArrayDouble.New(vals,4,3)
341 self.assertEqual(4,da.getNumberOfTuples());
342 self.assertEqual(3,da.getNumberOfComponents());
344 self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
346 self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
347 self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
348 self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
349 self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
352 def testSwigDADOp6(self):
353 da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
355 da2=DataArrayInt.New([5,8,10,12])
356 self.assertEqual(4,da2.getNumberOfTuples());
357 self.assertEqual(1,da2.getNumberOfComponents());
359 self.assertEqual(4,da3.getNumberOfTuples());
360 self.assertEqual(3,da3.getNumberOfComponents());
361 expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
363 self.assertEqual(da3.getIJ(0,i),expected1[i])
366 self.assertEqual(4,da3.getNumberOfTuples());
367 self.assertEqual(3,da3.getNumberOfComponents());
369 self.assertEqual(da3.getIJ(0,i),expected1[i])
371 da3=da+DataArrayInt.New(da2.getValues())
372 # Test new API of classmethod DataArrayInt.New
373 vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
374 da=DataArrayDouble.New(vals)
375 self.assertEqual(12,da.getNumberOfTuples());
376 self.assertEqual(1,da.getNumberOfComponents());
378 self.assertEqual(da.getIJ(0,i),vals[i])
380 da=DataArrayDouble.New(vals,12)
381 self.assertEqual(12,da.getNumberOfTuples());
382 self.assertEqual(1,da.getNumberOfComponents());
384 self.assertEqual(da.getIJ(0,i),vals[i])
386 da=DataArrayDouble.New(vals,1,12)
387 self.assertEqual(1,da.getNumberOfTuples());
388 self.assertEqual(12,da.getNumberOfComponents());
390 self.assertEqual(da.getIJ(0,i),vals[i])
392 da=DataArrayDouble.New(vals,6,2)
393 self.assertEqual(6,da.getNumberOfTuples());
394 self.assertEqual(2,da.getNumberOfComponents());
396 self.assertEqual(da.getIJ(0,i),vals[i])
398 da=DataArrayDouble.New(vals,4,3)
399 self.assertEqual(4,da.getNumberOfTuples());
400 self.assertEqual(3,da.getNumberOfComponents());
402 self.assertEqual(da.getIJ(0,i),vals[i])
404 self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
405 self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
406 self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
407 self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
410 def testSwigDADOp9(self):
411 l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
412 da1=DataArrayDouble(l1,4,3)
413 self.assertEqual(4,da1.getNumberOfTuples());
414 self.assertEqual(3,da1.getNumberOfComponents());
415 da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
416 self.assertTrue(da2.isEqual(da1,1e-12))
417 self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
418 da3=DataArrayDouble(l1,4)
419 self.assertTrue(da3.isEqual(da1,1e-12))
420 self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
421 self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
422 l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
423 da1=DataArrayDouble(l1,4,3)
424 self.assertEqual(4,da1.getNumberOfTuples());
425 self.assertEqual(3,da1.getNumberOfComponents());
426 da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
427 self.assertTrue(da2.isEqual(da1,1e-12))
428 self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
429 da3=DataArrayDouble(l1,4)
430 self.assertTrue(da3.isEqual(da1,1e-12))
431 self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
432 self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
434 l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
435 da1=DataArrayInt(l1,4,3)
436 self.assertEqual(4,da1.getNumberOfTuples());
437 self.assertEqual(3,da1.getNumberOfComponents());
438 da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
439 self.assertTrue(da2.isEqual(da1))
440 self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
441 da3=DataArrayInt(l1,4)
442 self.assertTrue(da3.isEqual(da1))
443 self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
444 self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
445 l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
446 da1=DataArrayInt(l1,4,3)
447 self.assertEqual(4,da1.getNumberOfTuples());
448 self.assertEqual(3,da1.getNumberOfComponents());
449 da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
450 self.assertTrue(da2.isEqual(da1))
451 self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
452 da3=DataArrayInt(l1,4)
453 self.assertTrue(da3.isEqual(da1))
454 self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
455 self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
458 def testRenumberNodesInConn1(self):
459 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. ]
460 mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
461 mesh2D=MEDCouplingUMesh.New("mesh",2);
462 mesh2D.allocateCells(5);
463 mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
464 mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
465 mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
466 mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
467 mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
468 mesh2D.finishInsertingCells();
469 myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
470 mesh2D.setCoords(myCoords);
471 mesh2D.checkConsistencyLight();
473 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. ]
474 mesh3DConn=[0,1,2,3,4,5,6,7]
475 mesh3D=MEDCouplingUMesh.New("mesh",3);
476 mesh3D.allocateCells(1);
477 mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
478 mesh3D.finishInsertingCells();
479 myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
480 mesh3D.setCoords(myCoords3D);
481 mesh3D.checkConsistencyLight();
483 mesh3D_2=mesh3D.deepCopy();
484 mesh2D_2=mesh2D.deepCopy();
485 mesh3D_4=mesh3D.deepCopy();
486 mesh2D_4=mesh2D.deepCopy();
487 oldNbOf3DNodes=mesh3D.getNumberOfNodes();
488 renumNodes=DataArrayInt.New();
489 renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
490 renumNodes.iota(oldNbOf3DNodes);
491 coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
492 mesh3D.setCoords(coo);
493 mesh2D.setCoords(coo);
494 mesh2DCpy=mesh2D.deepCopy()
495 mesh2D_3=mesh2D.deepCopy();
496 mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
497 mesh2D.renumberNodesInConn(renumNodes);
498 mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
499 self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
500 self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
502 da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
503 self.assertTrue(da1==None);
504 self.assertEqual(8,da2.getNumberOfTuples());
505 self.assertEqual(1,da2.getNumberOfComponents());
506 expected1=[8,11,12,9,4,5,6,7]
508 self.assertEqual(expected1[i],da2.getIJ(i,0));
511 da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
512 self.assertTrue(da1==None);
513 self.assertEqual(9,da2.getNumberOfTuples());
514 self.assertEqual(1,da2.getNumberOfComponents());
516 self.assertEqual(8+i,da2.getIJ(i,0));
519 mesh2D_5=mesh2D_4.deepCopy();
520 mesh2D_5.translate([1.,0.,0.]);
521 meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
522 MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
523 self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
524 self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
525 mesh3D_4.checkConsistencyLight(); mesh2D_4.checkConsistencyLight(); mesh2D_5.checkConsistencyLight();
526 self.assertEqual(26,mesh3D_4.getNumberOfNodes());
527 self.assertEqual(3,mesh3D_4.getSpaceDimension());
528 self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
529 self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
530 self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
531 expected2=[18,0,1,2,3,4,5,6,7]
532 expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
533 expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
534 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]
535 self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
536 self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
537 self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
539 self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
542 MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
543 mesh3D_4.checkConsistencyLight(); mesh2D_4.checkConsistencyLight(); mesh2D_5.checkConsistencyLight();
544 self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
545 self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
546 self.assertEqual(19,mesh3D_4.getNumberOfNodes());
547 self.assertEqual(3,mesh3D_4.getSpaceDimension());
548 self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
549 self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
550 self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
551 expected6=[18,0,1,2,3,4,5,6,7]
552 expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
553 expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
554 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.,
555 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.,
556 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.]
557 self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
558 self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
559 self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
561 self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
566 def testComputeNeighborsOfCells1(self):
567 m=MEDCouplingDataForTest.build2DTargetMesh_1();
568 d1,d2=m.computeNeighborsOfCells();
569 self.assertEqual(6,d2.getNumberOfTuples());
570 self.assertEqual(10,d1.getNumberOfTuples());
571 expected1=[0,2,4,6,8,10]
572 expected2=[3,1,0,2,4,1,4,0,2,3]
573 self.assertEqual(expected1,d2.getValues());
574 self.assertEqual(expected2,d1.getValues());
577 def testCheckButterflyCellsBug1(self):
578 mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
579 mesh2DConn=[4,1,0,2,3]
580 mesh2D=MEDCouplingUMesh.New("mesh",2);
581 mesh2D.allocateCells(1);
582 mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
583 mesh2D.finishInsertingCells();
584 myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
585 mesh2D.setCoords(myCoords);
586 mesh2D.checkConsistencyLight();
588 v=mesh2D.checkButterflyCells();
589 self.assertTrue(v.empty());
592 def testDataArrayIntRange1(self):
593 d=DataArrayInt.Range(2,17,7);
595 self.assertEqual(3,d.getNumberOfTuples());
596 self.assertEqual(1,d.getNumberOfComponents());
597 self.assertEqual(expected1,d.getValues());
599 d=DataArrayInt.Range(2,23,7);
600 self.assertEqual(3,d.getNumberOfTuples());
601 self.assertEqual(1,d.getNumberOfComponents());
602 self.assertEqual(expected1,d.getValues());
604 d=DataArrayInt.Range(2,24,7);
605 expected2=[2,9,16,23]
606 self.assertEqual(4,d.getNumberOfTuples());
607 self.assertEqual(1,d.getNumberOfComponents());
608 self.assertEqual(expected2,d.getValues());
610 d=DataArrayInt.Range(24,2,-7);
611 expected3=[24,17,10,3]
612 self.assertEqual(4,d.getNumberOfTuples());
613 self.assertEqual(1,d.getNumberOfComponents());
614 self.assertEqual(expected3,d.getValues());
616 d=DataArrayInt.Range(23,2,-7);
618 self.assertEqual(3,d.getNumberOfTuples());
619 self.assertEqual(1,d.getNumberOfComponents());
620 self.assertEqual(expected4,d.getValues());
622 d=DataArrayInt.Range(23,22,-7);
623 self.assertEqual(1,d.getNumberOfTuples());
624 self.assertEqual(1,d.getNumberOfComponents());
625 self.assertEqual(23,d.getIJ(0,0));
627 d=DataArrayInt.Range(22,23,7);
628 self.assertEqual(1,d.getNumberOfTuples());
629 self.assertEqual(1,d.getNumberOfComponents());
630 self.assertEqual(22,d.getIJ(0,0));
632 d=DataArrayInt.Range(22,22,7);
633 self.assertEqual(0,d.getNumberOfTuples());
634 self.assertEqual(1,d.getNumberOfComponents());
636 d=DataArrayInt.Range(22,22,-7);
637 self.assertEqual(0,d.getNumberOfTuples());
638 self.assertEqual(1,d.getNumberOfComponents());
640 self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
641 self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
642 self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
643 self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
646 def testSwigUMeshGetItem1(self):
647 m=MEDCouplingDataForTest.build2DTargetMesh_1();
648 subMesh=m.buildPartOfMySelf([1,3],True);
649 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
651 self.assertTrue(isinstance(m1,MEDCouplingUMesh))
653 self.assertTrue(isinstance(m2,MEDCouplingUMesh))
655 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
656 m4=m[DataArrayInt.New([1,3])]
658 self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
660 self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
661 m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
662 m5.setName(subMesh.getName())
663 self.assertTrue(isinstance(m4,MEDCouplingUMesh))
664 self.assertTrue(subMesh.isEqual(m1,1e-12))
665 self.assertTrue(subMesh.isEqual(m2,1e-12))
666 self.assertTrue(subMesh.isEqual(m3,1e-12))
667 self.assertTrue(subMesh.isEqual(m4,1e-12))
668 self.assertTrue(subMesh.isEqual(m5,1e-12))
669 self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
672 def testSwigGetItem3(self):
673 da=DataArrayInt.New([4,5,6])
674 self.assertEqual(5,da[1])
675 self.assertEqual(6,da[-1])
676 self.assertRaises(InterpKernelException,da.__getitem__,3)
677 da=DataArrayInt.New([4,5,6,7,8,9],2,3)
678 self.assertEqual(9,da[1,2])
679 da=DataArrayDouble.New([4.1,5.2,6.3])
680 self.assertAlmostEqual(5.2,da[1],12)
681 self.assertAlmostEqual(6.3,da[-1],12)
682 self.assertRaises(InterpKernelException,da.__getitem__,3)
683 da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
684 self.assertAlmostEqual(9.12,da[1,2],12)
687 def testSwigDADISub1(self):
688 mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
689 bary=mesh3D.computeCellCenterOfMass()
691 pts=bary.getDifferentValues(1e-12)
692 expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
693 for pos,pt in enumerate(pts):
696 norm=bary2.magnitude()
697 self.assertEqual(expected[pos],norm.findIdsInRange(-1.,1e-5).getValues())
699 expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
700 for pos,pt in enumerate(pts):
703 self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
704 self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
706 expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
707 for pos,pt in enumerate(pts):
710 self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
711 self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
713 expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
714 for pos,pt in enumerate(pts):
717 self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
718 self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
721 d=DataArrayInt.New([1,2,0,1,0,2],3,2)
722 e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
723 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]]
724 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]]
725 for pos,tup in enumerate(d):
727 self.assertTrue(isinstance(f,DataArrayInt))
729 self.assertEqual(expected5[pos],f.getValues())
730 self.assertEqual(6*[77],f[tup].getValues())
733 self.assertEqual(expected6[pos],f.getValues())
734 self.assertEqual(8*[77],f[:,tup].getValues())
737 e=e.convertToDblArr()
738 for pos,tup in enumerate(d):
740 self.assertTrue(isinstance(f,DataArrayDouble))
742 self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
743 self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
746 self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
747 self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
751 def testDataArrayDoubleGetMinMaxPerComponent1(self):
752 values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
753 d1=DataArrayDouble.New();
754 self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
755 d1=DataArrayDouble.New(values1,4,3);
756 res=d1.getMinMaxPerComponent();
757 self.assertTrue(isinstance(res,list))
758 self.assertEqual(3,len(res))
760 self.assertTrue(isinstance(res[i],tuple))
761 self.assertEqual(2,len(res[i]))
763 expected1=[-0.9,1.3,1.7,2.1,3.,3.]
765 self.assertAlmostEqual(expected1[i], res[i // 2][i % 2], 14)
769 res=d1.getMinMaxPerComponent();
770 self.assertTrue(isinstance(res,list))
771 self.assertEqual(2,len(res))
773 self.assertTrue(isinstance(res[i],tuple))
774 self.assertEqual(2,len(res[i]))
776 expected2=[1.,3.,-0.9,3.]
778 self.assertAlmostEqual(expected2[i], res[i // 2][i % 2], 14)
782 res=d1.getMinMaxPerComponent();
783 self.assertTrue(isinstance(res,list))
784 self.assertEqual(1,len(res))
786 self.assertTrue(isinstance(res[i],tuple))
787 self.assertEqual(2,len(res[i]))
791 self.assertAlmostEqual(expected3[i], res[i // 2][i % 2], 14)
795 def testDataArrayIntGetHashCode1(self):
796 d1 = DataArrayInt.New(list(range(3545)))
797 d2 = DataArrayInt.New(list(range(3545)))
798 self.assertEqual(d2.getHashCode(),d1.getHashCode())
799 self.assertEqual(232341068,d1.getHashCode())
801 self.assertEqual(232340188,d1.getHashCode())
804 def testZipConnectivityPol1(self):
805 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
807 m2_1=m1.buildPartOfMySelf(cells1,True);
809 self.assertTrue(isinstance(m2,MEDCouplingUMesh))
810 # no permutation policy 0
811 isOk,arr=m1.areCellsIncludedIn(m2,0)
812 self.assertTrue(isOk);
813 self.assertEqual(3,arr.getNumberOfTuples());
814 self.assertEqual(1,arr.getNumberOfComponents());
815 self.assertEqual(cells1,arr.getValues())
816 # no permutation policy 1
817 isOk,arr=m1.areCellsIncludedIn(m2,1)
818 self.assertTrue(isOk);
819 self.assertEqual(3,arr.getNumberOfTuples());
820 self.assertEqual(1,arr.getNumberOfComponents());
821 self.assertEqual(cells1,arr.getValues())
822 # no permutation policy 2
823 isOk,arr=m1.areCellsIncludedIn(m2,2)
824 self.assertTrue(isOk);
825 self.assertEqual(3,arr.getNumberOfTuples());
826 self.assertEqual(1,arr.getNumberOfComponents());
827 self.assertEqual(cells1,arr.getValues())
828 # some modification into m2
830 m2.getNodalConnectivity()[1:4]=modif1
831 #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
833 isOk,arr=m1.areCellsIncludedIn(m2,0)
834 self.assertTrue(not isOk);
835 self.assertEqual(3,arr.getNumberOfTuples());
836 self.assertEqual(1,arr.getNumberOfComponents());
837 self.assertEqual(expected1,arr.getValues())
838 #policy 1 succeeds because cell0 in m2 has not exactly the same conn
839 isOk,arr=m1.areCellsIncludedIn(m2,1)
840 self.assertTrue(isOk);
841 self.assertEqual(3,arr.getNumberOfTuples());
842 self.assertEqual(1,arr.getNumberOfComponents());
843 self.assertEqual(cells1,arr.getValues())
844 #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
845 isOk,arr=m1.areCellsIncludedIn(m2,2)
846 self.assertTrue(isOk);
847 self.assertEqual(3,arr.getNumberOfTuples());
848 self.assertEqual(1,arr.getNumberOfComponents());
849 self.assertEqual(cells1,arr.getValues())
850 #some new modification into m2
852 m2.getNodalConnectivity()[1:4]=modif2
853 #policy 0 fails because cell0 in m2 has not exactly the same conn
854 isOk,arr=m1.areCellsIncludedIn(m2,0)
855 self.assertTrue(not isOk);
856 self.assertEqual(3,arr.getNumberOfTuples());
857 self.assertEqual(1,arr.getNumberOfComponents());
858 self.assertEqual(expected1,arr.getValues())
859 #policy 1 fails too because cell0 in m2 has not same orientation
860 isOk,arr=m1.areCellsIncludedIn(m2,1)
861 self.assertTrue(not isOk);
862 self.assertEqual(3,arr.getNumberOfTuples());
863 self.assertEqual(1,arr.getNumberOfComponents());
864 self.assertEqual(expected1,arr.getValues())
865 #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
866 isOk,arr=m1.areCellsIncludedIn(m2,2)
867 self.assertTrue(isOk);
868 self.assertEqual(3,arr.getNumberOfTuples());
869 self.assertEqual(1,arr.getNumberOfComponents());
870 self.assertEqual(cells1,arr.getValues())
873 m1=MEDCouplingDataForTest.build1DSourceMesh_2();
874 m2_1=m1.buildPartOfMySelf(cells2,True);
876 self.assertTrue(isinstance(m2,MEDCouplingUMesh))
877 # no permutation policy 0
878 isOk,arr=m1.areCellsIncludedIn(m2,0)
879 self.assertTrue(isOk);
880 self.assertEqual(2,arr.getNumberOfTuples());
881 self.assertEqual(1,arr.getNumberOfComponents());
882 self.assertEqual(cells2,arr.getValues())
883 # no permutation policy 1
884 isOk,arr=m1.areCellsIncludedIn(m2,1)
885 self.assertTrue(isOk);
886 self.assertEqual(2,arr.getNumberOfTuples());
887 self.assertEqual(1,arr.getNumberOfComponents());
888 self.assertEqual(cells2,arr.getValues())
889 # no permutation policy 2
890 isOk,arr=m1.areCellsIncludedIn(m2,2)
891 self.assertTrue(isOk);
892 self.assertEqual(2,arr.getNumberOfTuples());
893 self.assertEqual(1,arr.getNumberOfComponents());
894 self.assertEqual(cells2,arr.getValues())
895 # some modification into m2
897 m2.getNodalConnectivity()[1:3]=modif3
898 #policy 0 fails because cell0 in m2 has not exactly the same conn
900 isOk,arr=m1.areCellsIncludedIn(m2,0)
901 self.assertTrue(not isOk);
902 self.assertEqual(2,arr.getNumberOfTuples());
903 self.assertEqual(1,arr.getNumberOfComponents());
904 self.assertEqual(expected2,arr.getValues())
905 #policy 1 fails too because cell0 in m2 has not same orientation
906 isOk,arr=m1.areCellsIncludedIn(m2,1)
907 self.assertTrue(not isOk);
908 self.assertEqual(2,arr.getNumberOfTuples());
909 self.assertEqual(1,arr.getNumberOfComponents());
910 self.assertEqual(expected2,arr.getValues())
911 #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
912 isOk,arr=m1.areCellsIncludedIn(m2,2)
913 self.assertTrue(isOk);
914 self.assertEqual(2,arr.getNumberOfTuples());
915 self.assertEqual(1,arr.getNumberOfComponents());
916 self.assertEqual(cells2,arr.getValues())
919 def toSeeIfDaIIopsAreOK(self,d):
927 def testSwigDAIOp5(self):
928 d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
929 self.toSeeIfDaIIopsAreOK(d)
930 dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
931 self.assertTrue(d.isEqual(dExp));
934 def toSeeIfDaDIopsAreOK(self,d):
941 def testSwigDADOp7(self):
942 d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
943 self.toSeeIfDaDIopsAreOK(d)
944 dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
945 self.assertTrue(d.isEqual(dExp,1e-14));
948 def testConvexEnvelop2D1(self):
949 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]
950 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]
951 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]
953 m=MEDCouplingUMesh.New("convexhull",2);
954 m.allocateCells(331);
956 m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
958 m.finishInsertingCells();
959 coordsDa=DataArrayDouble.New(coords,331,2);
960 m.setCoords(coordsDa);
961 m.checkConsistencyLight();
963 da=m.convexEnvelop2D();
964 m.checkConsistencyLight()
965 self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
966 daC=da.buildComplement(m.getNumberOfCells());
967 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]);
968 self.assertTrue(expected2.isEqual(daC));
970 vals=m.getMeasureField(False).getArray()
971 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]
972 vals-=DataArrayDouble.New(ref)
974 theTest=vals.findIdsInRange(-1.,1e-7)
975 self.assertTrue(theTest.isIota(331))
978 def testSwigDAIOp8(self):
979 da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
980 self.assertTrue(7 in da)
981 self.assertTrue(47 in da)
982 self.assertTrue(15 in da)
983 self.assertEqual(0,da.index(7))
984 self.assertEqual(10,da.index(47))
985 self.assertTrue(14 not in da)
986 self.assertEqual(5,da.findIdSequence([9,9]))
987 self.assertEqual(-1,da.findIdSequence([5,8]))
989 self.assertTrue([47,16] not in da)
990 self.assertTrue([5,6] not in da)
991 self.assertTrue([6,7] in da)
992 self.assertEqual(4,da.index([12,13]))
995 def testDataArraySort1(self):
996 arr=DataArrayInt.New();
997 self.assertRaises(InterpKernelException,arr.sort,True)
998 self.assertRaises(InterpKernelException,arr.sort,False)
1001 self.assertRaises(InterpKernelException,arr.sort,True)
1002 self.assertRaises(InterpKernelException,arr.sort,False)
1004 arr.setValues(values,6,1)
1005 arr1=arr.deepCopy();
1006 arr2=arr.deepCopy();
1008 expected1=[1,2,4,5,6,7]
1009 self.assertEqual(6,arr1.getNumberOfTuples());
1010 self.assertEqual(1,arr1.getNumberOfComponents());
1011 self.assertEqual(expected1,arr1.getValues());
1013 expected2=[7,6,5,4,2,1]
1014 self.assertEqual(6,arr2.getNumberOfTuples());
1015 self.assertEqual(1,arr2.getNumberOfComponents());
1016 self.assertTrue(expected2,arr2.getValues());
1018 ard=DataArrayDouble.New();
1019 self.assertRaises(InterpKernelException,ard.sort,True)
1020 self.assertRaises(InterpKernelException,ard.sort,False)
1021 valuesD=[2.,1.,6.,5.,4.,7.]
1023 self.assertRaises(InterpKernelException,ard.sort,True)
1024 self.assertRaises(InterpKernelException,ard.sort,False)
1026 ard.setValues(valuesD,6,1)
1027 ard1=ard.deepCopy();
1028 ard2=ard.deepCopy();
1030 expected3=[1.,2.,4.,5.,6.,7.]
1031 self.assertEqual(6,ard1.getNumberOfTuples());
1032 self.assertEqual(1,ard1.getNumberOfComponents());
1034 self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
1037 expected4=[7.,6.,5.,4.,2.,1.]
1038 self.assertEqual(6,ard2.getNumberOfTuples());
1039 self.assertEqual(1,ard2.getNumberOfComponents());
1041 self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
1045 def testPartitionBySpreadZone1(self):
1046 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1047 m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
1048 m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
1050 v2=m4.partitionBySpreadZone();
1051 self.assertTrue(3,len(v2));
1052 self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
1053 self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
1054 self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
1056 m5=m4.buildSpreadZonesWithPoly();
1057 self.assertEqual(3,m5.getNumberOfCells());
1058 self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
1059 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())
1060 self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
1064 def testGiveCellsWithType1(self):
1067 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1068 da=m.giveCellsWithType(NORM_TRI3);
1069 self.assertEqual(2,da.getNumberOfTuples());
1070 self.assertEqual(1,da.getNumberOfComponents());
1071 self.assertEqual(expected0,da.getValues())
1073 da=m.giveCellsWithType(NORM_QUAD4);
1074 self.assertEqual(3,da.getNumberOfTuples());
1075 self.assertEqual(1,da.getNumberOfComponents());
1076 self.assertEqual(expected1,da.getValues())
1078 da=m.giveCellsWithType(NORM_TRI6);
1079 self.assertEqual(0,da.getNumberOfTuples());
1080 self.assertEqual(1,da.getNumberOfComponents());
1082 self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
1083 self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
1086 def testSwigDAOp1(self):
1087 d=DataArrayDouble.New(5,2)
1088 d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
1089 d.setInfoOnComponents(["X [m]","Y [m]"])
1093 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))
1094 d1bis=DataArrayDouble.New([8,9],1,2)+d
1095 self.assertTrue(d1bis.isEqual(d1,1e-12))
1097 self.assertTrue(d1ter.isEqual(d1,1e-12))
1100 self.assertTrue(d2.isEqual(d,1e-12))
1101 self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
1104 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))
1105 d3bis=DataArrayDouble.New([8,9],1,2)*d
1106 self.assertTrue(d3bis.isEqual(d3,1e-12))
1108 self.assertTrue(d3ter.isEqual(d3,1e-12))
1111 self.assertTrue(d4.isEqual(d,1e-12))
1113 d=DataArrayInt.New(5,2)
1114 d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
1115 d.setInfoOnComponents(["X [m]","Y [m]"])
1119 self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
1120 d1bis=DataArrayInt.New([8,9],1,2)+d
1121 self.assertTrue(d1bis.isEqual(d1))
1123 self.assertTrue(d1ter.isEqual(d1))
1126 self.assertTrue(d2.isEqual(d))
1127 self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
1130 self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
1131 d3bis=DataArrayInt.New([8,9],1,2)*d
1132 self.assertTrue(d3bis.isEqual(d3))
1134 self.assertTrue(d3ter.isEqual(d3))
1137 self.assertTrue(d4.isEqual(d))
1140 self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
1143 def testSwigSelectTupleId2DAIBug1(self):
1144 da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
1145 self.assertEqual([2,6,10],da[2::6].getValues())
1146 self.assertEqual([0,4,8],da[::6].getValues())
1147 self.assertEqual([5,9],da[7::6].getValues())
1148 self.assertEqual([5],da[7:-5:6].getValues())
1151 def testSwigCpp5Safe1(self):
1152 m=MEDCouplingUMesh.New("toto",2)
1153 coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
1155 vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
1156 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]]
1157 for pos,vec in enumerate(vecs):
1160 self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
1162 for pos,vec in enumerate(vecs):
1164 m2.translate(vec.buildDADouble())
1165 self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
1169 def testSwigBugNonRegressionZipDA(self):
1170 angles = [pi / 3 * x for x in range(6)]
1173 dad=DataArrayDouble.New(6, 2)
1177 dad2=dad.fromPolarToCart()
1178 dads=[dad2.deepCopy() for elt in 7*[None]]
1180 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.)]]
1181 for d,t in zip(dads,translationToPerform):
1185 self.assertTrue(not dad2.isEqual(elt,1e-12))
1187 for d,t in zip(dads,translationToPerform):
1191 self.assertTrue(dad2.isEqual(elt,1e-12))
1195 def testBuildSlice3D2(self):
1196 mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1197 vec1=[-0.07,1.,0.07]
1198 origin1=[1.524,1.4552,1.74768]
1199 slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
1200 f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
1201 f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
1202 arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
1203 arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
1205 f.checkConsistencyLight()
1206 expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
1207 self.assertTrue(expected1.isEqual(ids))
1210 f2=f.extractSlice3D(origin1,vec1,1e-10)
1211 self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
1212 self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
1213 self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
1214 self.assertAlmostEqual(4.5,f2.getTime()[0],12);
1217 def testComputeTupleIdsToSelectFromCellIds1(self):
1218 m=MEDCouplingDataForTest.build2DTargetMesh_3()
1219 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
1221 arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
1224 f2=f.buildSubPart([1,5,9])
1225 f2.checkConsistencyLight()
1226 cI=m.computeNbOfNodesPerCell()
1227 cI.computeOffsetsFull()
1228 sel=DataArrayInt([1,5,9])
1229 res=sel.buildExplicitArrByRanges(cI)
1231 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))
1232 self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
1235 def testComputeSkin1(self):
1236 arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
1237 cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
1238 umesh=cmesh.buildUnstructured()
1240 skin=umesh.computeSkin()
1241 self.assertEqual(18,skin.getNumberOfCells())
1242 self.assertEqual(1,skin.getMeshDimension())
1243 self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
1244 self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
1245 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())
1246 ids=skin.computeFetchedNodeIds()
1247 self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
1248 part=umesh.buildFacePartOfMySelfNode(ids,True)
1249 part.setName(skin.getName());
1250 self.assertTrue(part.isEqual(skin,1e-12))
1253 self.assertTrue(not part.isEqual(skin,1e-12))
1254 trad=part.zipConnectivityTraducer(0)
1255 self.assertEqual(9,part.getNumberOfCells())
1256 self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
1259 def testUMeshSetPartOfMySelf2(self):
1260 # resize with explicit ids list
1261 m=MEDCouplingDataForTest.build2DTargetMesh_1()
1262 self.assertEqual([3,4],m.getAllGeoTypes())
1267 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())
1268 self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
1269 self.assertEqual([3],m.getAllGeoTypes())
1270 # no resize with explicit ids list
1271 m=MEDCouplingDataForTest.build2DTargetMesh_1()
1273 part.convertAllToPoly()
1275 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())
1276 self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
1277 self.assertEqual([3,4,5],m.getAllGeoTypes())
1278 # resize with range ids
1279 m=MEDCouplingDataForTest.build2DTargetMesh_1()
1282 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())
1283 self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
1284 self.assertEqual([4],m.getAllGeoTypes())
1285 # no resize with range ids
1286 m=MEDCouplingDataForTest.build2DTargetMesh_1()
1288 part.convertAllToPoly()
1290 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())
1291 self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
1292 self.assertEqual([3,4,5],m.getAllGeoTypes())
1293 # no resize with range ids negative direction
1294 m=MEDCouplingDataForTest.build2DTargetMesh_1()
1296 part.convertAllToPoly()
1298 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())
1299 self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
1300 self.assertEqual([3,4,5],m.getAllGeoTypes())
1303 def testUnPolyze3(self):
1304 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]
1305 conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
1306 m=MEDCouplingUMesh.New("a mesh",3);
1308 m.insertNextCell(NORM_POLYHED,22,conn[0:22])
1309 m.finishInsertingCells();
1310 coords=DataArrayDouble(coord,6,3);
1311 m.setCoords(coords);
1312 m.checkConsistencyLight();
1314 vol=m.getMeasureField(False);
1315 self.assertEqual(1,vol.getArray().getNumberOfTuples());
1316 self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
1320 self.assertEqual([NORM_PENTA6],m.getAllGeoTypes())
1321 self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
1322 self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
1324 vol=m.getMeasureField(False);
1325 self.assertEqual(1,vol.getArray().getNumberOfTuples());
1326 self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
1329 def testKrSpatialDiscretization1(self):
1330 srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
1331 srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
1332 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]
1333 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]
1334 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])
1337 f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
1338 srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
1339 cmesh=MEDCouplingCMesh.New("aMesh");
1340 cmesh.setCoordsAt(0,srcArrX);
1341 umesh=cmesh.buildUnstructured();
1343 srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
1344 f.setArray(srcVals);
1345 f.checkConsistencyLight();
1347 res0=f.getValueOn(targetPointCoordsX[:1]);
1348 self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
1350 valuesToTest=f.getValueOnMulti(targetPointCoordsX);
1351 self.assertEqual(40,valuesToTest.getNumberOfTuples());
1352 self.assertEqual(1,valuesToTest.getNumberOfComponents());
1354 self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
1356 fd=f.getDiscretization()
1358 self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
1359 coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
1360 self.assertEqual(2,isDrift)
1361 self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
1365 def testDuplicateEachTupleNTimes1(self):
1366 d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
1367 d2=d.duplicateEachTupleNTimes(3)
1368 self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
1369 self.assertEqual("aname",d2.getName())
1370 self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
1372 d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
1373 d2=d.duplicateEachTupleNTimes(3)
1374 self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
1375 self.assertEqual("aname",d2.getName())
1376 self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
1379 def testSwigComputeTupleIdsNearTuples1(self):
1380 da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
1381 arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
1382 self.assertEqual([2,0,4,1],arr.getValues())
1383 self.assertEqual([0,1,3,4],arrI.getValues())
1384 arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
1385 self.assertEqual([2,0,4,1],arr.getValues())
1386 self.assertEqual([0,1,3,4],arrI.getValues())
1387 expected0=[[2],[0,4],[1]]
1388 expected1=[[0,1],[0,2],[0,1]]
1389 for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
1390 arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
1391 self.assertEqual(expected0[pos],arr.getValues())
1392 self.assertEqual(expected1[pos],arrI.getValues())
1396 def testSwigDataTupleIOp1(self):
1397 d=DataArrayDouble(10,1)
1402 toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
1403 self.assertTrue(toTest.isEqual(d,1e-12))
1407 toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
1408 self.assertTrue(toTest.isEqual(d,1e-12))
1412 toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
1413 self.assertTrue(toTest.isEqual(d,1e-12))
1417 toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
1418 self.assertTrue(toTest.isEqual(d,1e-12))
1420 d=DataArrayInt(10,1)
1425 self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
1429 self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
1433 self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
1437 self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
1441 self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
1444 def testDAIBuildUnique1(self):
1445 d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
1447 self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
1450 def testDAIPartitionByDifferentValues1(self):
1451 d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
1452 expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
1453 for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
1454 self.assertEqual(expected[i][0],elt[1])
1455 self.assertEqual(expected[i][1],elt[0].getValues())
1459 def testFieldGaussMultiDiscPerType1(self):
1460 coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
1461 mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
1462 mQ8.allocateCells(1)
1463 mQ8.insertNextCell(NORM_QUAD8, list(range(8)))
1464 mQ8.finishInsertingCells()
1465 mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
1466 mQ4.allocateCells(1)
1467 mQ4.insertNextCell(NORM_QUAD4, list(range(4)))
1468 mQ4.finishInsertingCells()
1469 mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
1470 mT3.allocateCells(1)
1471 mT3.insertNextCell(NORM_TRI3, list(range(3)))
1472 mT3.finishInsertingCells()
1474 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.]]
1475 ms=2*[mQ4]+7*[mQ8]+11*[mT3]
1476 ms[:]=(elt.deepCopy() for elt in ms)
1477 for m,t in zip(ms,tr):
1478 d=m.getCoords() ; d+= t
1480 m=MEDCouplingUMesh.MergeUMeshes(ms)
1481 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
1483 # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
1484 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])
1485 f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
1486 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])
1487 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])
1488 f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
1489 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])
1490 self.assertEqual(46,f.getNumberOfTuplesExpected())
1491 vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
1493 f.checkConsistencyLight()
1494 #f.getLocalizationOfDiscr()
1495 self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
1496 self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
1497 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())
1499 fc.checkConsistencyLight()
1500 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))
1501 fc.renumberCells([3,2,0,1])
1502 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))
1506 def testSwigRotate(self):
1507 d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
1508 MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
1509 self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
1510 d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
1511 MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
1512 self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
1515 def testSwigCMeshProtection(self):
1516 cm=MEDCouplingCMesh()
1517 self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
1518 self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
1521 def testSwigCellsInBoundingBox1(self):
1522 m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
1523 self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
1524 self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
1527 def testDAICheckMonotonic1(self):
1528 data1=[-1,0,2,2,4,5]
1529 data2=[6,2,0,-8,-9,-56]
1530 data3=[-1,0,3,2,4,6]
1531 data4=[7,5,2,3,0,-6]
1532 d=DataArrayInt.New(data1);
1533 self.assertTrue(d.isMonotonic(True));
1534 self.assertTrue(not d.isMonotonic(False));
1535 d.checkMonotonic(True);
1536 self.assertRaises(InterpKernelException,d.checkMonotonic,False)
1537 d=DataArrayInt.New(data2);
1538 self.assertTrue(d.isMonotonic(False));
1539 self.assertTrue(not d.isMonotonic(True));
1540 d.checkMonotonic(False);
1541 self.assertRaises(InterpKernelException,d.checkMonotonic,True)
1542 d=DataArrayInt.New(data3);
1543 self.assertTrue(not d.isMonotonic(False));
1544 self.assertTrue(not d.isMonotonic(True));
1545 self.assertRaises(InterpKernelException,d.checkMonotonic,True)
1546 self.assertRaises(InterpKernelException,d.checkMonotonic,False)
1547 d=DataArrayInt.New(data4);
1548 self.assertTrue(not d.isMonotonic(False));
1549 self.assertTrue(not d.isMonotonic(True));
1550 self.assertRaises(InterpKernelException,d.checkMonotonic,True)
1551 self.assertRaises(InterpKernelException,d.checkMonotonic,False)
1552 d=DataArrayInt.New(0,1)
1553 self.assertTrue(d.isMonotonic(True));
1554 self.assertTrue(d.isMonotonic(False));
1555 d.checkMonotonic(True);
1556 d.checkMonotonic(False);
1557 d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
1558 self.assertRaises(InterpKernelException,d.isMonotonic,True)
1559 self.assertRaises(InterpKernelException,d.isMonotonic,False)
1560 self.assertRaises(InterpKernelException,d.checkMonotonic,True)
1561 self.assertRaises(InterpKernelException,d.checkMonotonic,False)
1564 def testSwigDASetItemOnEmpty1(self):
1569 except InterpKernelException as e:
1572 self.assertTrue(isThrow)
1576 d=DataArrayDouble(0,1)
1580 except InterpKernelException as e:
1583 self.assertTrue(isThrow)
1586 d=DataArrayInt([],0,1)
1588 self.assertTrue(d2.isEqual(d))
1589 d=DataArrayDouble([],0,1)
1590 d2=DataArrayDouble(0)
1591 self.assertTrue(d2.isEqual(d,1e-12))
1594 def testSwigDAITransformWithIndArr1(self):
1595 arr=DataArrayInt([0,4,5,1])
1596 d=DataArrayInt([7,8,9,10])
1597 self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
1600 def testIntersect2DMeshesTmp6(self):
1602 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);
1604 conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
1605 connI=DataArrayInt.New([0,9]);
1606 m1=MEDCouplingUMesh.New("Fixe",2);
1607 m1.setCoords(coords);
1608 m1.setConnectivity(conn,connI,True);
1610 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);
1612 conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
1613 connI=DataArrayInt.New([0,9,18]);
1615 m2=MEDCouplingUMesh.New("Mobile",2);
1616 m2.setCoords(coords);
1617 m2.setConnectivity(conn,connI,True);
1619 m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
1620 self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
1621 self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
1622 self.assertEqual(4,m3.getNumberOfCells());
1623 self.assertEqual(4,d1.getNumberOfTuples());
1624 self.assertEqual(4,d2.getNumberOfTuples());
1625 self.assertEqual(43,m3.getNumberOfNodes());
1626 dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
1627 self.assertEqual(35,m3.getNumberOfNodes());
1629 self.assertEqual(23,m3.getNumberOfNodes());
1631 f=m3.getMeasureField(True);
1632 valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
1633 self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
1636 def testDAPushBack(self):
1637 d=DataArrayDouble(0,1)
1641 self.assertEqual(d.getNumberOfTuples(),8)
1642 self.assertEqual(d.getNbOfElemAllocated(),8)
1643 d.pushBackSilent(4.44)
1644 self.assertEqual(d.getNumberOfTuples(),9)
1645 self.assertEqual(d.getNbOfElemAllocated(),16)
1646 self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
1648 self.assertEqual(e.getNumberOfTuples(),9)
1649 self.assertEqual(e.getNbOfElemAllocated(),9)
1650 self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
1651 self.assertAlmostEqual(d.popBackSilent(),4.44,12)
1652 self.assertEqual(d.getNumberOfTuples(),8)
1653 self.assertEqual(d.getNbOfElemAllocated(),16)
1654 self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
1657 f.pushBackSilent(4.)
1658 self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
1659 self.assertEqual(f.getNumberOfTuples(),1)
1660 self.assertEqual(f.getNbOfElemAllocated(),1000)
1662 self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
1663 self.assertEqual(ff.getNumberOfTuples(),1)
1664 self.assertEqual(ff.getNbOfElemAllocated(),1)
1666 d.pushBackSilent(4.44)
1667 d.pushBackSilent(5.55)
1668 d.pushBackSilent(6.66)
1669 self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
1675 self.assertEqual(d.getNumberOfTuples(),8)
1676 self.assertEqual(d.getNbOfElemAllocated(),8)
1677 d.pushBackSilent(444)
1678 self.assertEqual(d.getNumberOfTuples(),9)
1679 self.assertEqual(d.getNbOfElemAllocated(),16)
1680 self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
1682 self.assertEqual(e.getNumberOfTuples(),9)
1683 self.assertEqual(e.getNbOfElemAllocated(),9)
1684 self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
1685 self.assertEqual(d.popBackSilent(),444)
1686 self.assertEqual(d.getNumberOfTuples(),8)
1687 self.assertEqual(d.getNbOfElemAllocated(),16)
1688 self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
1692 self.assertTrue(f.isEqual(DataArrayInt([4])))
1693 self.assertEqual(f.getNumberOfTuples(),1)
1694 self.assertEqual(f.getNbOfElemAllocated(),1000)
1696 self.assertTrue(ff.isEqual(DataArrayInt([4])))
1697 self.assertEqual(ff.getNumberOfTuples(),1)
1698 self.assertEqual(ff.getNbOfElemAllocated(),1)
1700 d.pushBackSilent(444)
1701 d.pushBackSilent(555)
1702 d.pushBackSilent(666)
1703 self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
1707 d.setInfoOnComponent(0,"ABC")
1710 e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1711 self.assertEqual(10,d.getNbOfElemAllocated())
1712 d.pushBackSilent(55)
1713 e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1714 self.assertEqual(20,d.getNbOfElemAllocated())
1716 e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1717 self.assertEqual(4,d.getNbOfElemAllocated())
1719 e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1720 self.assertEqual(8,d.getNbOfElemAllocated())
1721 self.assertEqual(5,d.popBackSilent())
1722 e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1723 self.assertEqual(8,d.getNbOfElemAllocated())
1724 self.assertRaises(OverflowError,d.reserve,-1)
1725 e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
1726 self.assertEqual(8,d.getNbOfElemAllocated())
1728 e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
1729 self.assertEqual(0,d.getNbOfElemAllocated())
1733 d.setInfoOnComponent(0,"ABC")
1736 e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1737 self.assertEqual(10,d.getNbOfElemAllocated())
1738 d.pushBackSilent(55)
1739 e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1740 self.assertEqual(20,d.getNbOfElemAllocated())
1742 e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1743 self.assertEqual(4,d.getNbOfElemAllocated())
1745 e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1746 self.assertEqual(8,d.getNbOfElemAllocated())
1747 self.assertEqual(5.,d.popBackSilent())
1748 e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1749 self.assertEqual(8,d.getNbOfElemAllocated())
1750 self.assertRaises(OverflowError,d.reserve,-1)
1751 e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
1752 self.assertEqual(8,d.getNbOfElemAllocated())
1754 e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
1755 self.assertEqual(0,d.getNbOfElemAllocated())
1758 def testDAIBuildSubstractionOptimized1(self):
1759 da1=DataArrayInt.New([1,3,5,6,7,9,13])
1760 da2=DataArrayInt.New([3,5,9])
1761 da3=DataArrayInt.New([1,3,5])
1762 da4=DataArrayInt.New([1,3,5,6,7,9,13])
1764 a=da1.buildSubstractionOptimized(da2);
1765 self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
1767 a=da1.buildSubstractionOptimized(da3);
1768 self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
1770 a=da1.buildSubstractionOptimized(da4);
1771 self.assertTrue(a.isEqual(DataArrayInt([])));
1774 def testDAIIsStrictlyMonotonic1(self):
1775 da1=DataArrayInt.New([1,3,5,6,7,9,13])
1776 self.assertTrue(da1.isStrictlyMonotonic(True));
1777 da1.checkStrictlyMonotonic(True);
1778 self.assertTrue(da1.isMonotonic(True));
1779 da1.checkMonotonic(True);
1780 self.assertTrue(not da1.isStrictlyMonotonic(False));
1781 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1782 self.assertTrue(not da1.isMonotonic(False));
1783 self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
1785 da1=DataArrayInt.New([1,3,5,6,6,9,13])
1786 self.assertTrue(not da1.isStrictlyMonotonic(True));
1787 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1788 self.assertTrue(da1.isMonotonic(True));
1789 da1.checkMonotonic(True);
1790 self.assertTrue(not da1.isStrictlyMonotonic(False));
1791 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1792 self.assertTrue(not da1.isMonotonic(False));
1793 self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
1795 da1=DataArrayInt.New([1,3,5,6,5,9,13])
1796 self.assertTrue(not da1.isStrictlyMonotonic(True));
1797 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1798 self.assertTrue(not da1.isMonotonic(True));
1799 self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
1800 self.assertTrue(not da1.isStrictlyMonotonic(False));
1801 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1802 self.assertTrue(not da1.isMonotonic(False));
1803 self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
1805 da1=DataArrayInt.New([13,9,7,6,5,3,1])
1806 self.assertTrue(not da1.isStrictlyMonotonic(True));
1807 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1808 self.assertTrue(not da1.isMonotonic(True));
1809 self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
1810 self.assertTrue(da1.isStrictlyMonotonic(False));
1811 da1.checkStrictlyMonotonic(False);
1812 self.assertTrue(da1.isMonotonic(False));
1813 da1.checkMonotonic(False);
1815 da1=DataArrayInt.New([13,9,6,6,5,3,1])
1816 self.assertTrue(not da1.isStrictlyMonotonic(True));
1817 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1818 self.assertTrue(not da1.isMonotonic(True));
1819 self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
1820 self.assertTrue(not da1.isStrictlyMonotonic(False));
1821 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1822 self.assertTrue(da1.isMonotonic(False));
1823 da1.checkMonotonic(False);
1825 da1=DataArrayInt.New([13,9,5,6,5,3,1])
1826 self.assertTrue(not da1.isStrictlyMonotonic(True));
1827 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
1828 self.assertTrue(not da1.isMonotonic(True));
1829 self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
1830 self.assertTrue(not da1.isStrictlyMonotonic(False));
1831 self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
1832 self.assertTrue(not da1.isMonotonic(False));
1833 self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
1835 da1=DataArrayInt.New([])
1836 self.assertTrue(da1.isStrictlyMonotonic(True));
1837 da1.checkStrictlyMonotonic(True);
1838 self.assertTrue(da1.isMonotonic(True));
1839 da1.checkMonotonic(True);
1840 self.assertTrue(da1.isStrictlyMonotonic(False));
1841 da1.checkStrictlyMonotonic(False);
1842 self.assertTrue(da1.isMonotonic(False));
1843 da1.checkMonotonic(False);
1845 da1=DataArrayInt.New([13])
1846 self.assertTrue(da1.isStrictlyMonotonic(True));
1847 da1.checkStrictlyMonotonic(True);
1848 self.assertTrue(da1.isMonotonic(True));
1849 da1.checkMonotonic(True);
1850 self.assertTrue(da1.isStrictlyMonotonic(False));
1851 da1.checkStrictlyMonotonic(False);
1852 self.assertTrue(da1.isMonotonic(False));
1853 da1.checkMonotonic(False);
1856 def testFindAndCorrectBadOriented3DCells1(self):
1858 vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
1860 m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
1861 m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
1862 m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
1863 m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
1864 m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
1865 self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
1866 m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
1867 c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
1868 c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
1869 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)
1870 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)
1871 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)
1872 m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
1873 expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
1875 for i in range(nbOfDisc):
1877 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
1879 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1880 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
1881 self.assertTrue(mm.isEqual(mm2,1e-14))
1882 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1883 mm.convertAllToPoly()
1884 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1889 m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
1890 m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
1891 m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
1892 m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
1893 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
1894 m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
1895 m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
1896 expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
1898 for i in range(nbOfDisc):
1900 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
1901 mm2=mm.deepCopy() ; mm3=mm.deepCopy() ; mm3.convertAllToPoly()
1902 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
1903 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
1904 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
1905 mOK.setCoords(mm.getCoords())
1906 self.assertTrue(mm.isEqual(mOK,1e-14))
1907 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1909 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
1910 mm.convertAllToPoly()
1911 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1915 m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
1916 m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented
1917 m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented
1918 m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
1919 m4 = MEDCouplingUMesh("m", 3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12, list(range(12))); # Well oriented
1920 m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
1921 m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
1922 expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
1924 for i in range(nbOfDisc):
1926 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
1927 mm2=mm.deepCopy() ; mm3=mm.deepCopy() ; mm3.convertAllToPoly()
1928 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
1929 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
1930 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
1931 mOK.setCoords(mm.getCoords())
1932 self.assertTrue(mm.isEqual(mOK,1e-14))
1933 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1935 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
1936 mm.convertAllToPoly()
1937 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
1942 def testSwig2CellOrientation1(self):
1943 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)
1944 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]]
1945 for i in range(256):
1946 mesh=MEDCouplingUMesh("FluidMesh_1",3);
1947 mesh.allocateCells(0)
1948 conn2=[elt[:] for elt in conn]
1949 code=bin(i)[2:] ; code='0'*(8-len(code))+code
1950 for face,rev in zip(conn2,code):
1955 conn3=[elt+[-1] for elt in conn2]
1956 conn3=sum(conn3,[])[:-1]
1957 mesh.insertNextCell(NORM_POLYHED,conn3)
1958 mesh.setCoords(coords)
1959 mesh.orientCorrectlyPolyhedrons()
1960 self.assertTrue(mesh.computeCellCenterOfMass().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
1964 def testSwig2CheckConsecutiveCellTypesForMEDFileFrmt1(self):
1965 m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
1966 m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
1967 m1.insertNextCell(NORM_TRI3,[0,1,2])
1968 d=DataArrayDouble(4,3) ; d[:]=0.
1970 self.assertTrue(m1.checkConsecutiveCellTypes())
1971 self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
1972 m1.renumberCells([1,0])
1973 self.assertTrue(m1.checkConsecutiveCellTypes())
1974 self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
1977 def testSwig2DAAccumulate1(self):
1978 d=DataArrayInt(10) ; d.iota(0)
1979 self.assertEqual([45],d.accumulate())
1980 self.assertEqual(45,d.accumulate(0))
1981 d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
1982 self.assertEqual([135,145,155],d.accumulate())
1983 self.assertEqual(135,d.accumulate(0))
1984 self.assertEqual(145,d.accumulate(1))
1985 self.assertEqual(155,d.accumulate(2))
1986 d=DataArrayDouble(10) ; d.iota(0.)
1987 self.assertEqual([45.],d.accumulate())
1988 self.assertEqual(45.,d.accumulate(0))
1989 d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
1990 self.assertEqual([135.,145.,155.],d.accumulate())
1991 self.assertEqual(135.,d.accumulate(0))
1992 self.assertEqual(145.,d.accumulate(1))
1993 self.assertEqual(155.,d.accumulate(2))
1996 def testSwig2UMeshDistanceToMesh1(self):
1997 m=MEDCouplingUMesh("toto",2)
1998 coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
2001 m.insertNextCell(NORM_TRI3,[0,1,2])
2002 a,b=m.distanceToPoint([-0.335,2.27,1.21])
2003 self.assertEqual(0,b)
2004 self.assertAlmostEqual(0.0223609881003,a,12);
2005 a,b=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
2006 self.assertEqual(0,b)
2007 self.assertAlmostEqual(0.0223609881003,a,12);
2008 a,b=coords.distanceToTuple([-0.335,2.27,1.21])
2009 self.assertAlmostEqual(5.243302871282566,a,14)
2010 self.assertEqual(0,b)
2012 m=MEDCouplingUMesh("toto",2)
2013 coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
2016 m.insertNextCell(NORM_QUAD4,[0,1,2,3])
2017 m.checkConsistency()
2018 self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
2019 a,b=m.distanceToPoint([5.,2.,0.1])
2020 self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b)
2021 a,b=m.distanceToPoint([5.,-2.,4.])
2022 self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b)
2024 m.insertNextCell(NORM_POLYGON,[0,1,2,3])
2025 m.checkConsistency()
2026 self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
2027 a,b=m.distanceToPoint([11.,3.,4.])
2028 self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b)
2029 a,b=m.distanceToPoint([4.,12.,5.])
2030 self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b)
2031 d=DataArrayDouble([-1.2,3.,2.],1,3)
2033 a,b=m.distanceToPoint(d)
2034 self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b)
2037 m=MEDCouplingUMesh("toto",1)
2038 coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
2039 m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
2040 a,b=m.distanceToPoint([-0.1,4.1])
2041 self.assertAlmostEqual(0.14142135623730925,a,14) # b==1 self.assertEqual(2,c)
2042 a,b=m.distanceToPoint([0.,3.9])
2043 self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) # self.assertEqual(2,c)
2046 def testSwig2UMeshDistanceToMesh2(self):
2047 mesh = MEDCouplingUMesh('Solid_3', 2)
2048 coo = DataArrayDouble([(99.75,-1.42109e-14,102.75),(99.75,200,102.75),(2.5,0,200),(2.5,200,200),(197,0,200),(197,200,200)])
2050 c = DataArrayInt([3, 4, 0, 1, 3, 4, 1, 5, 3, 1, 0, 3, 3, 3, 0, 2])
2051 cI = DataArrayInt([0, 4, 8, 12, 16])
2052 mesh.setConnectivity(c, cI)
2053 mesh.checkConsistency()
2054 pt = [125.0, 175.0, 175.0]
2055 # Values computed from GEOM:
2056 exp1, exp2, exp3, exp4 = 54.0633707597, 33.2340187158, 68.9429111657, 99.5221476482
2057 d1, _ = mesh[0].distanceToPoint(pt)
2058 d2, _ = mesh[1].distanceToPoint(pt)
2059 d3, _ = mesh[2].distanceToPoint(pt)
2060 d4, _ = mesh[3].distanceToPoint(pt)
2061 self.assertAlmostEqual(exp1,d1,10)
2062 self.assertAlmostEqual(exp2,d2,10)
2063 self.assertAlmostEqual(exp3,d3,10)
2064 self.assertAlmostEqual(exp4,d4,10)
2067 def testSwig2NonRegressionPartitionBySpreadZone1(self):
2068 m=MEDCouplingCMesh()
2069 arr=DataArrayDouble(6) ; arr.iota(0.)
2070 m.setCoords(arr,arr,arr)
2071 m=m.buildUnstructured()
2072 mPart=m[50,80,85,87,92,122]
2073 zones=mPart.partitionBySpreadZone()
2074 self.assertEqual(4,len(zones))
2075 self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
2076 self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
2077 self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
2078 self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
2080 n,ni=m.computeNeighborsOfCells()
2081 a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
2082 self.assertEqual(13,b) ; self.assertTrue(a.isIota(125))
2083 a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
2084 self.assertEqual(12,b) ; self.assertTrue(a.isIota(125))
2085 a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
2086 self.assertEqual(11,b) ; self.assertTrue(a.isIota(125))
2087 a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
2088 self.assertEqual(12,b) ; self.assertTrue(a.isIota(125))
2091 def testSwigUMeshInsertNextCell1(self):
2092 m=MEDCouplingUMesh("toto",2)
2094 coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
2095 da=DataArrayInt([0,1,2])
2098 m.insertNextCell(NORM_TRI3,da)
2100 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])))
2101 self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
2103 da=DataArrayInt([0,1,2,3])
2106 m.insertNextCell(NORM_TRI3,3,da)
2108 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])))
2109 self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
2111 da=DataArrayInt([0,1])
2113 self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
2115 da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
2118 m.insertNextCell(NORM_TRI3,t)
2120 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])))
2121 self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
2122 self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
2125 def testSwigCurveLinearMesh1(self):
2126 m=MEDCouplingCurveLinearMesh("toto")
2127 m.setNodeGridStructure([2,3])
2128 coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
2130 m.checkConsistencyLight()
2132 self.assertTrue(m0.isEqual(m,1e-12))
2133 m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
2134 self.assertTrue(not m0.isEqual(m,1e-12))
2136 self.assertTrue(m0.isEqual(m,1e-12))
2137 self.assertEqual(m.getNodeGridStructure(),(2,3))
2140 def testSimplexize3(self):
2141 m=MEDCouplingUMesh("toto",3)
2143 m.insertNextCell(NORM_TETRA4,[0,1,2,3])
2144 self.assertEqual([NORM_TETRA4],m.getAllGeoTypesSorted())
2145 m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
2146 self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted())
2147 m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
2148 self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted())
2149 m.insertNextCell(NORM_TETRA4,[20,21,22,23])
2150 self.assertEqual([NORM_TETRA4,NORM_HEXA8,NORM_TETRA4],m.getAllGeoTypesSorted())
2151 c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
2152 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.]
2155 c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
2157 m.checkConsistency()
2160 d1=m1.simplexize(PLANAR_FACE_5)
2161 m1.checkConsistency()
2162 vol1=m1.getMeasureField(False).getArray()
2163 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))
2164 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])
2165 self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
2166 self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
2169 d2=m2.simplexize(PLANAR_FACE_6)
2170 m2.checkConsistency()
2171 vol2=m2.getMeasureField(False).getArray()
2172 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))
2173 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])
2174 self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
2175 self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
2178 def testSwig2CurveLinearMesh2(self):
2179 c=MEDCouplingCMesh()
2181 arr1=DataArrayDouble([0,1,3,7])
2182 arr2=DataArrayDouble([0,1,1.5])
2183 c.setCoords(arr1,arr2)
2184 u=c.buildUnstructured()
2186 cl=MEDCouplingCurveLinearMesh()
2188 cl.setNodeGridStructure([4,3])
2189 cl.checkConsistency()
2190 li1=[1.,2.,4.,0.5,1.,2.]
2191 self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
2192 self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
2193 li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
2194 self.assertTrue(cl.computeCellCenterOfMass().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
2195 self.assertTrue(u.computeCellCenterOfMass().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
2197 c.setCoords(arr1,arr2,arr2)
2198 u=c.buildUnstructured()
2200 cl=MEDCouplingCurveLinearMesh()
2202 cl.setNodeGridStructure([4,3,3])
2203 cl.checkConsistency()
2204 li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
2205 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]
2206 self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
2207 self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
2208 self.assertTrue(cl.computeCellCenterOfMass().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
2209 self.assertTrue(u.computeCellCenterOfMass().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
2211 coo=DataArrayDouble(5) ; coo.iota(0.)
2214 cl.setNodeGridStructure([5])
2215 cl.checkConsistency()
2217 li3_1=[0.5,2.5,6.5,12.5]
2218 self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
2219 self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
2220 self.assertTrue(cl.computeCellCenterOfMass().isEqual(DataArrayDouble(li3_1),1e-14))
2221 self.assertTrue(cl.buildUnstructured().computeCellCenterOfMass().isEqual(DataArrayDouble(li3_1),1e-14))
2223 coo=DataArrayDouble.Meld(coo,coo)
2225 cl.checkConsistency()
2226 li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
2227 li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
2228 self.assertEqual(2,cl.getSpaceDimension())
2229 self.assertEqual(1,cl.getMeshDimension())
2230 self.assertEqual(4,cl.getNumberOfCells())
2231 self.assertEqual(5,cl.getNumberOfNodes())
2232 self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
2233 self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
2234 self.assertTrue(cl.computeCellCenterOfMass().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
2235 self.assertTrue(cl.buildUnstructured().computeCellCenterOfMass().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
2238 def testSwig2CurveLinearMeshNonRegression1(self):
2239 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)
2240 m=MEDCouplingCurveLinearMesh("toto")
2242 m.setNodeGridStructure([3,3,3])
2244 vol=m.getMeasureField(False).getArray()
2245 self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
2246 self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
2248 self.assertTrue(m.computeCellCenterOfMass().isEqual(m.buildUnstructured().computeCellCenterOfMass(),1e-12))
2251 def testSwig2NonRegressionDASetSelectedComponents1(self):
2252 da=DataArrayDouble.New([1.,2.,3.,4.,5.,6.],3,2)
2253 dv=DataArrayDouble.New();
2256 # da has less tuples than dv
2257 dv.setSelectedComponents(da,[1,0])
2259 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))
2261 da=DataArrayInt.New([1,2,3,4,5,6],3,2)
2262 dv=DataArrayInt.New();
2265 # da has less tuples than dv
2266 dv.setSelectedComponents(da,[1,0])
2268 self.assertTrue(dv.isEqual(DataArrayInt([2,1,0,0,4,3,0,0,6,5,0,0,0,0,0,0],4,4)))
2271 def testSwigSetItem3(self):
2273 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2275 self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,1,2,0,0,0,0],6,2),1e-14))
2277 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2279 self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,1,2,1,2,0,0,1,2],6,2),1e-14))
2281 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2283 self.assertTrue(d.isEqual(DataArrayDouble([1,2,1,2,1,2,1,2,1,2,1,2],6,2),1e-14))
2285 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2286 d[DataArrayInt([0,3,4])]=[1,2]
2287 self.assertTrue(d.isEqual(DataArrayDouble([1,2,0,0,0,0,1,2,1,2,0,0],6,2),1e-14))
2289 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2291 self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,7],6,2),1e-14))
2293 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2295 self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,7,0,0,0,7],6,2),1e-14))
2297 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2299 self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,7,0,0,0,7,0,0],6,2),1e-14))
2301 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2302 d[DataArrayInt([0,3,4]),1]=[7]
2303 self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,0,0,7,0,7,0,0],6,2),1e-14))
2305 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2307 self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,8,7,0,0,0,0],6,2),1e-14))
2309 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2310 d[[1,3,4],[1,0]]=[7,8]
2311 self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,8,7,0,0],6,2),1e-14))
2313 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2315 self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,0,0,8,7],6,2),1e-14))
2317 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2318 d[DataArrayInt([1,4]),[1,0]]=[7,8]
2319 self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,0,0,8,7,0,0],6,2),1e-14))
2321 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2323 self.assertTrue(d.isEqual(DataArrayDouble([0,0,9,0,0,0,0,0,0,0,0,0],6,2),1e-14))
2325 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2327 self.assertTrue(d.isEqual(DataArrayDouble([0,0,7,8,0,0,0,0,7,8,7,8],6,2),1e-14))
2329 d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2331 self.assertTrue(d.isEqual(DataArrayDouble([0,0,3,9,0,0,3,9,0,0,3,9],6,2),1e-14))
2333 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2335 self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,1,2,0,0,0,0],6,2)))
2337 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2339 self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,1,2,1,2,0,0,1,2],6,2)))
2341 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2343 self.assertTrue(d.isEqual(DataArrayInt([1,2,1,2,1,2,1,2,1,2,1,2],6,2)))
2345 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2346 d[DataArrayInt([0,3,4])]=[1,2]
2347 self.assertTrue(d.isEqual(DataArrayInt([1,2,0,0,0,0,1,2,1,2,0,0],6,2)))
2349 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2351 self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,7],6,2)))
2353 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2355 self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,7,0,0,0,7],6,2)))
2357 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2359 self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,7,0,0,0,7,0,0],6,2)))
2361 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2362 d[DataArrayInt([0,3,4]),1]=[7]
2363 self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,0,0,7,0,7,0,0],6,2)))
2365 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2367 self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,8,7,0,0,0,0],6,2)))
2369 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2370 d[[1,3,4],[1,0]]=[7,8]
2371 self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,8,7,0,0],6,2)))
2373 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2375 self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,0,0,8,7],6,2)))
2377 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2378 d[DataArrayInt([1,4]),[1,0]]=[7,8]
2379 self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,0,0,8,7,0,0],6,2)))
2381 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2383 self.assertTrue(d.isEqual(DataArrayInt([0,0,9,0,0,0,0,0,0,0,0,0],6,2)))
2385 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2387 self.assertTrue(d.isEqual(DataArrayInt([0,0,7,8,0,0,0,0,7,8,7,8],6,2)))
2389 d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
2391 self.assertTrue(d.isEqual(DataArrayInt([0,0,3,9,0,0,3,9,0,0,3,9],6,2)))
2394 def testSwig2ConvertLinearCellsToQuadratic1(self):
2395 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)
2397 m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
2398 m2D.convertLinearCellsToQuadratic(0)
2399 m2D.checkConsistency()
2400 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])
2401 self.assertEqual(m2D.getNodalConnectivityIndex().getValues(),[0,9,16,23,32,41])
2402 self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
2404 m1D=MEDCouplingDataForTest.build2DTargetMesh_1().buildDescendingConnectivity()[0]
2405 m1D.convertLinearCellsToQuadratic(0)
2406 m1D.checkConsistency()
2407 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])
2408 self.assertEqual(m1D.getNodalConnectivityIndex().getValues(),[0,4,8,12,16,20,24,28,32,36,40,44,48,52])
2409 self.assertTrue(m1D.getCoords().isEqual(coordsExp,1e-14))
2411 m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
2412 m2D.changeSpaceDimension(3)
2413 arr=DataArrayDouble(4); arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
2414 m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
2415 m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
2416 cooTmp=m2D.getCoords()[:]
2417 m3D=m2D.buildExtrudedMesh(m1D,0)
2418 m3D.convertLinearCellsToQuadratic(0)
2419 m3D.checkConsistency()
2420 # check of new m3D content
2421 coordsExp2 = [coordsExp.changeNbOfComponents(3, i) for i in range(4)]
2422 coordsExp3 = [DataArrayDouble.Meld(cooTmp[:, [0, 1]], cooTmp[:, 2] + (0.5 + float(i))) for i in range(3)]
2423 coordsExp4=DataArrayDouble.Aggregate([coordsExp2[0],coordsExp3[0],coordsExp2[1],coordsExp3[1],coordsExp2[2],coordsExp3[2],coordsExp2[3]])
2424 c=DataArrayDouble.Aggregate(m3D.getCoords(),coordsExp4)
2425 self.assertEqual(len(coordsExp4),115)
2426 self.assertEqual(len(m3D.getCoords()),115)
2427 a,b=c.findCommonTuples(1e-14)
2428 self.assertEqual(len(b),len(coordsExp4)+1)
2429 e,f=DataArrayInt.ConvertIndexArrayToO2N(2*115,a,b)
2430 self.assertEqual(f,115)
2431 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])))
2432 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()))
2433 self.assertTrue(DataArrayInt([0,21,37,53,74,95,116,132,148,169,190,211,227,243,264,285]).isEqual(m3D.getNodalConnectivityIndex()))
2434 # testing explode3DMeshTo1D
2436 m3DSlice0.zipCoords()
2437 a,b,c,d,e=m3DSlice0.explode3DMeshTo1D()
2438 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])))
2439 self.assertTrue(c.isEqual(DataArrayInt([0,12,21,30,42,54])))
2440 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])))
2441 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])))
2442 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])))
2443 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])))
2444 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))
2447 def testSwig2DataArrayPushBackValsSilent1(self):
2449 d.pushBackValsSilent([4,5,6])
2450 self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.]),1e-14))
2451 e=DataArrayDouble([1,2,3],1,3)
2452 for t in e: d.pushBackValsSilent(t)
2453 self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.]),1e-14))
2454 d.pushBackValsSilent(DataArrayDouble([9,10.]))
2455 self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
2456 d.pushBackValsSilent(DataArrayDouble(0,1))
2457 self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
2458 e=DataArrayDouble([1,2,3],3,1)
2459 for t in e: d.pushBackValsSilent(t)
2460 self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.]),1e-14))
2461 d.pushBackValsSilent(77)
2462 self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.,77.]),1e-14))
2465 d.pushBackValsSilent([4,5,6])
2466 self.assertTrue(d.isEqual(DataArrayInt([4,5,6])))
2467 e=DataArrayInt([1,2,3],1,3)
2468 for t in e: d.pushBackValsSilent(t)
2469 self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3])))
2470 d.pushBackValsSilent(DataArrayInt([9,10]))
2471 self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
2472 d.pushBackValsSilent(DataArrayInt(0,1))
2473 self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
2474 e=DataArrayInt([1,2,3],3,1)
2475 for t in e: d.pushBackValsSilent(t)
2476 self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3])))
2477 d.pushBackValsSilent(77)
2478 self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3,77])))
2481 def testSwig2ConvertLinearCellsToQuadratic2(self):
2482 m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
2483 ret=m2D.convertLinearCellsToQuadratic(1)
2484 self.assertTrue(ret.isIota(5))
2485 m2D.checkConsistency()
2486 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)
2487 self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
2488 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])))
2489 self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,10,18,26,36,46])))
2491 m2D=MEDCouplingDataForTest.build2DTargetMesh_1()[(0,3)] ; m2D.zipCoords()
2492 m2D.changeSpaceDimension(3)
2493 arr=DataArrayDouble(3); arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
2494 m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
2495 m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
2496 cooTmp=m2D.getCoords()[:]
2497 m3D=m2D.buildExtrudedMesh(m1D,0)
2498 ret=m3D.convertLinearCellsToQuadratic(1)
2499 self.assertTrue(ret.isIota(4))
2500 m3D.checkConsistency()
2501 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)
2502 self.assertTrue(m3D.getCoords().isEqual(coordsExp2,1e-14))
2503 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])))
2504 self.assertTrue(m3D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,28,56,84,112])))
2507 def testSwig2GaussNEIntegral1(self):
2508 m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
2509 m0=m2D[0] ; m0.zipCoords()
2510 m1=m2D[[1,2]] ; m1.zipCoords()
2511 m2=m2D[[3,4]] ; m2.zipCoords()
2512 m0.convertLinearCellsToQuadratic(1)
2513 m1.convertLinearCellsToQuadratic(0)
2514 m2.convertLinearCellsToQuadratic(1)
2515 m=MEDCouplingUMesh.MergeUMeshes([m0,m1,m2])
2517 f=MEDCouplingFieldDouble(ON_GAUSS_NE)
2519 arr=DataArrayDouble([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,
2520 11.1,12.2,13.3,14.4,15.5,16.6,
2521 21.1,22.2,23.3,24.4,25.5,26.6,
2522 31.1,32.2,33.3,34.4,35.5,36.6,37.7,38.8,39.9,
2523 41.1,42.2,43.3,44.4,45.5,46.6,47.7,48.8,49.9])
2524 arr2=DataArrayDouble(len(arr),2)
2525 arr2[:,0]=arr ; arr2[:,1]=arr+100
2527 f.checkConsistencyLight()
2528 res=f.integral(False)
2529 # a=25./81 ; b=40./81 ; c=64./81
2530 # p1=0.11169079483905 ; p2=0.0549758718227661
2532 # 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
2533 # c1=(p2*(11.1+12.2+13.3)+p1*(14.4+15.5+16.6))*0.125/0.4999999999854482 ; c1=1.8014347172346943
2534 # c2=(p2*(21.1+22.2+23.3)+p1*(24.4+25.5+26.6))*0.125/0.4999999999854482 ; c2=3.0514347172346943
2535 # 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
2536 # 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
2537 # c0+c1+c2+c3+c4=27.104258323358287
2538 integExp0=27.104258323358287
2539 self.assertAlmostEqual(res[0],integExp0,13)
2541 # 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
2542 # c1=(p2*(111.1+112.2+113.3)+p1*(114.4+115.5+116.6))*0.125/0.4999999999854482 ; c1=14.301434717234699
2543 # c2=(p2*(121.1+122.2+123.3)+p1*(124.4+125.5+126.6))*0.125/0.4999999999854482 ; c2=15.5514347172347
2544 # 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
2545 # 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
2546 # c0+c1+c2+c3+c4=127.10425832335835
2547 integExp1=127.10425832335835
2548 self.assertAlmostEqual(res[1],integExp1,12)
2549 meas=f.getDiscretization().getMeasureField(f.getMesh(),False)
2551 res2=intPerTuple.accumulate()
2552 self.assertAlmostEqual(res2[0],integExp0,13)
2553 self.assertAlmostEqual(res2[1],integExp1,12)
2555 meas2=f.buildMeasureField(False)
2557 res3=intPerTuple.accumulate()
2558 self.assertAlmostEqual(res3[0],integExp0,13)
2559 self.assertAlmostEqual(res3[1],integExp1,12)
2561 res4=f.getWeightedAverageValue(False) # res4==res2 because sum of area of mesh is equal to 1
2562 self.assertAlmostEqual(res4[0],integExp0,13)
2563 self.assertAlmostEqual(res4[1],integExp1,12)
2567 res5=f.getWeightedAverageValue() # res4==res4 because weighted average is not sensitive to the scaling
2568 self.assertAlmostEqual(res5[0],integExp0,13)
2569 self.assertAlmostEqual(res5[1],integExp1,12)
2570 meas3=f.buildMeasureField(False)
2571 delta=4*meas2.getArray()-meas3.getArray()
2573 self.assertTrue(delta.isUniform(0.,1e-16))
2574 res6=f.integral(False)
2575 self.assertAlmostEqual(res6[0],4.*integExp0,12)
2576 self.assertAlmostEqual(res6[1],4.*integExp1,11)
2579 def testSwig2SlowDADFindClosestTupleId(self):
2582 d=DataArrayDouble(nbPt) ; d.iota() ; d*=1./(nbPt-1)
2583 c=MEDCouplingCMesh() ; c.setCoords(d,d) ; m=c.buildUnstructured() ; pts=m.getCoords() ; del m
2585 d0=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d0.iota() ; d0*=(3./((nbPt-1)*(nbPt-1))) ; d0=d0.applyFunc("exp(x)-1")
2586 d1=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d1.iota()
2587 d2=DataArrayDouble.Meld(d0,d1) ; d2=d2.fromPolarToCart() ; d2+=[0.32,0.73]
2588 ids=pts.findClosestTupleId(d2)
2589 #print "Start of costly computation"
2590 idsExpected=DataArrayInt(len(d2))
2592 for i,elt in enumerate(d2):
2593 l,m=(pts-elt).magnitude().getMinValue()
2594 idsExpected.setIJSilent(i,0,m)
2596 tmp=l ; tmp1=m ; tmp2=i
2599 #print "End of costly computation"
2600 self.assertTrue(idsExpected.isEqual(ids))
2601 a,b,c=pts.minimalDistanceTo(d2)
2602 self.assertEqual(tmp,a)
2603 self.assertEqual(tmp1,b)
2604 self.assertEqual(tmp2,c)
2606 l=[d2[:,i] for i in [0,1]]
2607 for elt in l: elt.reverse()
2608 d2i=DataArrayDouble.Meld(l)
2609 ids1=pts.findClosestTupleId(d2i)
2610 idsExpectedI=idsExpected.deepCopy() ; idsExpectedI.reverse()
2611 self.assertTrue(idsExpectedI.isEqual(ids1))
2613 l=[pts[:,i] for i in [0,1]]
2614 for elt in l: elt.reverse()
2615 ptsi=DataArrayDouble.Meld(l)
2616 ids2=ptsi.findClosestTupleId(d2)
2617 idsExpected2=nbPt*nbPt-1-ids
2618 self.assertTrue(idsExpected2.isEqual(ids2))
2620 ids3=ptsi.findClosestTupleId(d2i)
2621 idsExpected3=idsExpected2.deepCopy() ; idsExpected3.reverse()
2622 self.assertTrue(idsExpected3.isEqual(ids3))
2627 d3=DataArrayDouble.Meld( DataArrayDouble(ones), DataArrayDouble(twos) )
2628 d4=DataArrayDouble.Meld( DataArrayDouble(ones), DataArrayDouble(ones) )
2629 idsExpected4 = DataArrayInt([0]*nbPt)
2630 ids4 = d3.findClosestTupleId(d4)
2631 self.assertTrue(idsExpected.isEqual(ids))
2635 def testSwig2DataArrayAsciiChar1(self):
2636 alpha=DataArrayInt(26) ; alpha.iota(ord("A"))
2637 d=DataArrayAsciiChar(alpha.getValues(),2,13)
2638 d.setInfoOnComponents(["c%i" % (v) for v in range(13)])
2639 self.assertEqual('ABCDEFGHIJKLM',d.getTuple(0))
2640 self.assertEqual('NOPQRSTUVWXYZ',d.getTuple(1))
2641 self.assertEqual(2,d.getNumberOfTuples())
2642 self.assertEqual(26,d.getNbOfElems())
2643 self.assertEqual(13,d.getNumberOfComponents())
2645 self.assertTrue(d.isEqual(dd))
2647 self.assertTrue(not d.isEqual(dd))
2648 d.setIJ(0,3,ord('d'))
2649 self.assertTrue(d.isEqual(dd))
2652 self.assertEqual(20,d.getNumberOfTuples())
2653 self.assertEqual(20,d.getNbOfElems())
2654 self.assertEqual(1,d.getNumberOfComponents())
2656 d0=DataArrayAsciiChar([ord('a')],1,1)
2657 self.assertEqual('a',d0.asciiCharValue())
2658 self.assertTrue(not d0.empty())
2659 d0=DataArrayAsciiChar(0,3)
2660 self.assertTrue(d0.empty())
2661 d.pushBackSilent("U") ; d.pushBackSilent("V") ; d.pushBackSilent("W")
2662 self.assertEqual("W",d.popBackSilent())
2664 self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV'],d.toStrList())
2666 self.assertEqual(11*[''],d.toStrList())
2667 d.fillWithValue('T')
2668 self.assertEqual(11*["TT"],d.toStrList())
2670 self.assertTrue(d.isUniform("T"))
2675 dd.renumberInPlace([3,1,2,4,0,11,10,9,8,7,5,12,6])
2676 self.assertEqual(dd.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
2677 dd.renumberInPlaceR([3,1,2,4,0,11,10,9,8,7,5,12,6])
2678 self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV','WX','YZ'],dd.toStrList())
2679 e=dd.renumber([3,1,2,4,0,11,10,9,8,7,5,12,6])
2680 self.assertEqual(e.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
2681 e=dd.renumberR([3,1,2,4,0,11,10,9,8,7,5,12,6])
2682 self.assertEqual(e.toStrList(),['GH','Cd','EF','IJ','AB','WX','UV','ST','QR','OP','KL','YZ','MN'])
2683 e=dd.renumberAndReduce([1,1,1,1,1,1,1,2,0,0,0,0,0],3)
2684 self.assertEqual(['YZ','MN','OP'],e.toStrList())
2685 self.assertEqual(['GH','IJ'],dd.selectByTupleIdSafe([3,4]).toStrList())
2686 self.assertEqual(['AB','GH','MN','ST','YZ'],dd.selectByTupleIdSafeSlice(0,13,3).toStrList())
2687 dd3=dd.changeNbOfComponents(3,"G")
2688 self.assertEqual(['ABG','CdG','EFG','GHG','IJG','KLG','MNG','OPG','QRG','STG','UVG','WXG','YZG'],dd3.toStrList())
2689 dd3.rearrange(1) ; self.assertEqual("G",dd3.back()) ; dd3.rearrange(3)
2690 self.assertTrue(dd3.changeNbOfComponents(2,"\0").isEqual(dd))
2691 self.assertEqual(len(dd),13)
2692 d=DataArrayAsciiChar(13,2) ; d.fillWithValue('Y')
2694 self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','KLGYY','MNGYY','OPGYY','QRGYY','STGYY','UVGYY','WXGYY','YZGYY'],dd3.toStrList())
2695 self.assertEqual("d",dd3.getIJ(0,6))
2696 self.assertRaises(InterpKernelException,dd3.getIJSafe,0,6)
2697 self.assertEqual("d",dd3.getIJSafe(1,1))
2699 e=dd3.findIdsEqual("Y")
2700 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])))
2701 e=dd3.findIdsNotEqual("Y")
2702 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])))
2703 self.assertEqual(("d",6),dd3.getMaxValue())
2704 self.assertEqual(("A",0),dd3.getMinValue())
2705 self.assertEqual(26,dd3.findIdSequence("LGYYM"))
2706 self.assertEqual(-1,dd3.findIdSequence("LGYYN"))
2708 self.assertEqual(7,dd3.findIdFirstEqualTuple("OPGYY"))
2709 self.assertTrue("OPGYY" in dd3)
2710 self.assertEqual(7,dd3.index("OPGYY"))
2711 self.assertEqual(-1,dd3.findIdFirstEqualTuple("OPGYP"))
2713 self.assertEqual(2,dd3.findIdFirstEqual("OPGYY"))
2714 self.assertTrue(dd3.presenceOfValue("OPGYY"))
2715 self.assertTrue("O" in dd3)
2716 self.assertTrue(not dd3.presenceOfValue("z"))
2717 self.assertTrue("z" not in dd3)
2720 self.assertEqual([e.buildDAAsciiChar().toStrList()[0] for e in list(dd3)],dd3.toStrList())
2722 dd4=DataArrayChar.Aggregate(dd3,dd3)
2723 self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd4.toStrList())
2724 dd5=DataArrayChar.Aggregate([dd4,dd3,dd4])
2725 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())
2726 # getitem,__iter__,__setitem__
2728 self.assertEqual("ABGYY",str(a[0]))
2730 self.assertEqual(['ABGYY','EFGYY','IJGYY'],dd4.toStrList())
2732 self.assertEqual(['GHGYY','EFGYY','CdGYY'],dd4.toStrList())
2734 dd4[::2]=["12","345","67890"]
2735 self.assertEqual(['12 ','CdGYY','345 ','GHGYY','67890'],dd4.toStrList())
2738 self.assertEqual(['ABGYY',' ',' ','GHGYY','IJGYY'],dd4.toStrList())
2741 self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
2743 self.assertEqual(['CdGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
2744 dd4=DataArrayAsciiChar(["abc","de","fghi"])
2745 self.assertEqual(['abc ','de ','fghi'],dd4.toStrList())
2746 dd4=DataArrayAsciiChar(["abc","de","fghi"],"t")
2747 self.assertEqual(['abct','dett','fghi'],dd4.toStrList())
2750 def testSwig2GaussNELocalizationOfDiscValues(self):
2751 m=MEDCouplingDataForTest.build2DTargetMesh_3()[[0,1,3,4,5,6,8,9]] # suppression of polygons
2752 f=MEDCouplingFieldDouble(ON_GAUSS_NE)
2754 loc=f.getLocalizationOfDiscr()
2755 self.assertEqual(42,len(loc))
2756 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))
2757 m.changeSpaceDimension(3)
2758 m.getCoords()[:,2]=7.
2759 loc=f.getLocalizationOfDiscr()
2760 self.assertEqual(42,len(loc))
2761 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))
2764 def testSwig2GaussMeasureAndIntegral(self):
2765 ft=MEDCouplingDataForTest.buildFieldOnGauss_1()
2766 mea=ft.buildMeasureField(False)
2767 mea.checkConsistencyLight()
2768 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.034136689498128064, 0.04027397790619449, 0.04027397790619487, 0.034136689498128446, 0.04476678484160338, 0.05090407324967005, 0.050904073249668745, 0.04476678484160208, 0.05539688018507733, 0.061534168593143805, 0.06153416859314442, 0.055396880185077955, 0.03413668949812847, 0.04027397790619517, 0.04027397790619497, 0.03413668949812827, 0.04476678484160235, 0.05090407324966857, 0.05090407324966929, 0.044766784841603076, 0.05539688018507761, 0.06153416859314382, 0.06153416859314359, 0.05539688018507738, 0.04109914601299856, 0.03748636227195687, 0.03771775769378482, 0.03872147624188224, 0.042334259982919814, 0.04261193448911228, 0.03507783977793162, 0.031465056036892154, 0.0353092351997554, 0.03041505840443063, 0.030229942066968697, 0.03384272580800827, 0.02658630560301859, 0.022973521861980706, 0.02311235911507622, 0.02420863583190326, 0.027821419572943488, 0.02800653591040381, 0.04233425998291915, 0.038721476241882075, 0.04261193448911155, 0.0377177576937831, 0.03748636227195874, 0.041099146012996766, 0.03384272580800756, 0.030229942066968624, 0.030415058404430012, 0.03146505603689226, 0.035077839777932385, 0.035309235199757406, 0.0278214195729437, 0.024208635831903073, 0.02800653591040439, 0.023112359115075753, 0.02297352186197992, 0.026586305603019535, 0.019921063519116766, 0.01730003285741078, 0.017300032857410663, 0.019921063519115587, 0.029776877101222114, 0.027364571036248495, 0.0297768771012211, 0.03151042326217079, 0.04709999543873555, 0.016537327484887662, 0.013916296823180364, 0.0139162968231802, 0.01653732748488678, 0.024362899446454346, 0.022012298827300398, 0.02436289944645354, 0.026158151053224943, 0.038536359904420205, 0.013153591450657661, 0.01053256078895069, 0.010532560788950497, 0.013153591450657937, 0.018948921791686592, 0.016660026618353183, 0.01894892179168666, 0.020805878844278196, 0.029972724370104942, 0.01992106351911645, 0.017300032857410823, 0.017300032857409463, 0.01992106351911769, 0.029776877101221757, 0.027364571036247978, 0.029776877101221573, 0.03151042326217261, 0.047099995438736386, 0.016537327484886743, 0.013916296823180036, 0.013916296823180596, 0.0165373274848873, 0.024362899446453434, 0.022012298827300106, 0.024362899446454343, 0.026158151053224426, 0.038536359904419636, 0.013153591450657875, 0.010532560788950653, 0.010532560788951054, 0.013153591450656942, 0.018948921791686835, 0.016660026618353606, 0.01894892179168645, 0.020805878844277627, 0.029972724370105074]),1e-8))
2769 f=MEDCouplingFieldDouble(ft)
2770 arr=DataArrayDouble(126,2)
2771 arr[:, 0] = list(range(126))
2772 arr[:, 1] = list(range(126))
2775 f.checkConsistencyLight()
2776 self.assertTrue(DataArrayDouble(f.integral(False)).isEqual(DataArrayDouble([211.67679879443182, 4863.855680512835]),1e-11))
2777 self.assertTrue(DataArrayDouble(f.getWeightedAverageValue()).isEqual(DataArrayDouble([45.50057170549804, 1045.5005717054983]),1e-11))
2778 self.assertTrue(DataArrayDouble(f.normL1()).isEqual(DataArrayDouble([45.50057170549804, 1045.5005717054983]),1e-11))
2779 self.assertTrue(DataArrayDouble(f.normL2()).isEqual(DataArrayDouble([58.175073473810194, 1046.1288078361474]),1e-11))
2782 def testSwig2FieldDiscretizationComputeMeshRestrictionFromTupleIds1(self):
2783 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1()
2784 f=MEDCouplingFieldDouble(ON_GAUSS_NE)
2786 a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4,5,6,8,9,10,14,15,16,17])
2787 self.assertTrue(a.isEqual(DataArrayInt([1,4])))
2788 self.assertTrue(b.isEqual(DataArrayInt([4,5,6,14,15,16,17])))
2789 a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),DataArrayInt([0,1,2,3,5,7,8,9,10,11,12,18]))
2790 self.assertTrue(a.isEqual(DataArrayInt([0,2])))
2791 self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,7,8,9])))
2793 f=MEDCouplingFieldDouble(ON_CELLS)
2795 a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4])
2796 self.assertTrue(a.isEqual(DataArrayInt([3,4])))
2797 self.assertTrue(b.isEqual(DataArrayInt([3,4])))
2799 f=MEDCouplingFieldDouble(ON_NODES)
2801 a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[1,2,3,4])
2802 self.assertTrue(a.isEqual(DataArrayInt([1])))
2803 self.assertTrue(b.isEqual(DataArrayInt([1,2,4])))
2805 f=MEDCouplingDataForTest.buildFieldOnGauss_1()
2806 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])
2807 self.assertTrue(a.isEqual(DataArrayInt([0,11,12,18,35])))
2808 self.assertTrue(b.isEqual(DataArrayInt([0,11,12,13,14,15,36,37,38,117,118,119,120,121,122,123,124,125])))
2810 d=DataArrayInt([0,3,7,9,15,18])
2811 e=DataArrayInt([0,1,2,3,7,8,15,16,17])
2812 a,b=d.findIdsRangesInListOfIds(e)
2813 self.assertTrue(a.isEqual(DataArrayInt([0,2,4])))
2814 self.assertTrue(b.isEqual(DataArrayInt([0,1,2,7,8,15,16,17])))
2817 @unittest.skipUnless(checkFreeMemory((223456789*16)/(1024)), "Not enough memory")
2818 def testSwig2BigMem(self):
2819 if MEDCouplingSizeOfVoidStar()==64 and MEDCouplingSizeOfIDs()==32:
2820 d=DataArrayAsciiChar(223456789,16)
2821 self.assertTrue(d.getNumberOfTuples(),223456789)
2822 self.assertTrue(d.getNumberOfComponents(),16)
2823 d.setIJ(223456788,5,"r")
2824 self.assertTrue(d.getIJ(223456788,5),'r')
2825 d[223456787]="1234567890123456"
2826 self.assertTrue(d[223456787],'1234567890123456')
2827 self.assertRaises(InterpKernelException,d.rearrange,1)# fails because it would lead to nb of tuples > 2147483647
2831 def testSwig2DAReverseMultiCompo1(self):
2832 d=DataArrayDouble(6,2)
2833 d[:, 0] = list(range(6))
2834 d[:, 1] = list(range(10, 16))
2836 self.assertTrue(d.isEqual(DataArrayDouble([5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],6,2),1e-14))
2837 d=DataArrayDouble(7,2)
2838 d[:, 0] = list(range(7))
2839 d[:, 1] = list(range(10, 17))
2841 self.assertTrue(d.isEqual(DataArrayDouble([6.,16.,5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],7,2),1e-14))
2844 d[:, 0] = list(range(6))
2845 d[:, 1] = list(range(10, 16))
2847 self.assertTrue(d.isEqual(DataArrayInt([5,15,4,14,3,13,2,12,1,11,0,10],6,2)))
2849 d[:, 0] = list(range(7))
2850 d[:, 1] = list(range(10, 17))
2852 self.assertTrue(d.isEqual(DataArrayInt([6,16,5,15,4,14,3,13,2,12,1,11,0,10],7,2)))
2855 def testSwigDAPow1(self):
2860 self.assertTrue((d**2).isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
2861 self.assertTrue((d**3).isEqual(DataArrayInt([0,1,-8,27,64,125,216,343,512,729])))
2865 self.assertTrue(d.isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
2866 self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayInt([1,1,4,27])))
2867 self.assertTrue((3**d1[:4]).isEqual(DataArrayInt([1,3,9,27])))
2870 self.assertTrue(d2.isEqual(DataArrayInt([1,1,4,27])))
2871 self.assertRaises(InterpKernelException,d2.__pow__,-1)#non supporting negative pow in DataArrayInt.__pow__
2872 self.assertRaises(InterpKernelException,d2.__ipow__,-1)#non supporting negative pow in DataArrayInt.__pow__
2874 d=DataArrayDouble(10)
2878 self.assertTrue((d**2).isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
2879 self.assertTrue((d**3).isEqual(DataArrayDouble([0,1,-8,27,64,125,216,343,512,729]),1e-12))
2880 self.assertRaises(InterpKernelException,d.__pow__,3.1)#3.1 is double not integer -> not supporting negative values in d
2884 self.assertTrue(d.isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
2885 self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayDouble([1,1,4,27]),1e-12))
2886 self.assertTrue((3**d1[:4]).isEqual(DataArrayDouble([1,3,9,27]),1e-12))
2889 self.assertTrue(d2.isEqual(DataArrayDouble([1,1,4,27]),1e-12))
2891 self.assertTrue(d2.isEqual(DataArrayDouble([1,1,1./2,1./sqrt(27.)]),1e-14))
2893 self.assertTrue((3**d3).isEqual(DataArrayDouble([0.3333333333333333,0.5773502691896257,0.6933612743506348,0.7598356856515925]),1e-14))
2894 d4=d3.deepCopy() ; d4.abs()
2895 self.assertTrue((d4**d3).isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
2897 self.assertTrue(d4.isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
2900 def testSwig2Baryenter3DForCellsWithVolumeZero1(self):
2901 coo=DataArrayDouble([0.,0.,0.,1.,0.,0.,0.,1.,0.],3,3)
2902 m2=MEDCouplingUMesh("mesh",2)
2904 m2.insertNextCell(NORM_POLYGON,[0,1,2])
2906 m2.checkConsistency()
2908 coo2=DataArrayDouble([0.,0.,0.,0.,0.,0.,0.,0.,2.],3,3)
2909 m1=MEDCouplingUMesh("mesh",1)
2911 m1.insertNextCell(NORM_SEG2,[0,1])
2912 m1.insertNextCell(NORM_SEG2,[1,2])
2914 m1.checkConsistency()
2916 m3=m2.buildExtrudedMesh(m1,0)
2917 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
2918 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))
2919 m4,a,b,c,d=m3.buildDescendingConnectivity()
2920 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))
2923 def testSwigRepr1(self):
2925 self.assertTrue(len(d.__repr__())<120)
2926 d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
2927 for i in range(100):
2928 d.alloc(i,1) ; d.iota(1.1234567890123456) ; d*=1e123
2929 self.assertTrue(len(d.__repr__())<500)
2932 d.alloc(i,2) ; d.rearrange(1) ; d.iota(1.1234567890123456) ; d.rearrange(2) ; d*=1e123
2933 self.assertTrue(len(d.__repr__())<500)
2935 d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
2936 for i in range(2, 4):
2937 d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
2940 self.assertTrue(len(d.__repr__())<120)
2943 self.assertTrue(len(d.__repr__())<100)
2944 d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
2945 for i in range(100):
2946 d.alloc(i,1) ; d.iota(123456789)
2947 self.assertTrue(len(d.__repr__())<500)
2950 d.alloc(i,2) ; d.rearrange(1) ; d.iota(123456789) ; d.rearrange(2)
2951 self.assertTrue(len(d.__repr__())<500)
2953 d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
2954 for i in range(2, 10):
2955 d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
2958 self.assertTrue(len(d.__repr__())<100)
2960 d=DataArrayAsciiChar()
2961 d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
2962 d.alloc(2,16) ; d[:]='1234567890ABCDEF'
2963 self.assertTrue(len(d.__repr__())<500)
2964 d.alloc(2000,16) ; d[:]='1234567890ABCDEF'
2965 self.assertTrue(len(d.__repr__())<500)
2966 d.alloc(0,16) ; d[:]='1234567890ABCDEF'
2967 self.assertTrue(len(d.__repr__())<120)
2970 self.assertTrue(len(d.__repr__())<100)
2971 d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
2972 d.alloc(0,16) ; self.assertTrue(len(d.__repr__())<100)
2973 d.alloc(5,1) ; d.fillWithValue(127)
2974 self.assertTrue(len(d.__repr__())<200)
2975 d.alloc(1000,1) ; d.fillWithValue(127)
2976 self.assertTrue(len(d.__repr__())<500)
2977 d.alloc(1000,3) ; d.fillWithValue(127)
2978 self.assertTrue(len(d.__repr__())<500)
2981 def testSwig2MeshComputeIsoBarycenterOfNodesPerCell1(self):
2982 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)
2983 m=MEDCouplingUMesh.New("toto",3)
2985 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])
2986 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])
2988 m.checkConsistency()
2990 dReference=DataArrayDouble([(34.900130952189848,0.,200),(17.450065476094931,30.2244,200.)])
2991 self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
2992 m.getNodalConnectivity().setIJ(87,0,24)
2993 self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
2994 m.getNodalConnectivity().setIJ(87,0,-2)
2995 self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
2996 m.getNodalConnectivity().setIJ(87,0,21)# put again 21 as at the beginning
2998 self.assertTrue(m.unPolyze())
2999 self.assertEqual([NORM_HEXGP12],m.getAllGeoTypes())
3000 self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
3001 m.getNodalConnectivity().setIJ(25,0,24)
3002 self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
3003 m.getNodalConnectivity().setIJ(25,0,-1)
3004 self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
3007 def testSwig2NonRegressionBugDescHexa20(self):
3008 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)
3009 m=MEDCouplingUMesh('mesh',3)
3011 m.insertNextCell(NORM_HEXA20,[0,3,5,1,12,18,16,14,7,4,6,2,19,17,15,13,8,11,10,9])
3013 m.checkConsistency()
3015 a,b,c,d,e=m.buildDescendingConnectivity()
3016 m2=MEDCouplingUMesh('mesh',2)
3019 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]]
3021 m2.insertNextCell(NORM_QUAD8,conn2[i])
3023 self.assertTrue(m2.isEqual(a,1e-12))
3024 self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
3025 self.assertTrue(c.isEqual(DataArrayInt([0,6])))
3026 self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
3027 self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
3029 m.convertQuadraticCellsToLinear() ; m.zipCoords()
3030 m.convertLinearCellsToQuadratic(1)
3032 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)
3033 m3=MEDCouplingUMesh("mesh",3)
3035 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])
3037 self.assertTrue(m3.isEqual(m,1e-12))
3039 a,b,c,d,e=m.buildDescendingConnectivity()
3040 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]]
3041 m4=MEDCouplingUMesh("mesh",2)
3044 m4.insertNextCell(NORM_QUAD9,conn4[i])
3047 self.assertTrue(m4.isEqual(a,1e-12))
3048 self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
3049 self.assertTrue(c.isEqual(DataArrayInt([0,6])))
3050 self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
3051 self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
3054 def testSwigAdvGauss(self):
3055 f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
3056 f.setDiscretization(None)
3057 f.__repr__() ; f.__str__()
3059 f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
3060 d=f.getDiscretization()
3061 i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
3062 d.setArrayOfDiscIds(i)
3063 f.__repr__() ; f.__str__()
3064 i2=d.getArrayOfDiscIds()
3065 self.assertEqual(i.__repr__(),i2.__repr__())
3067 f=MEDCouplingFieldDouble(ON_GAUSS_PT)
3068 f.setDiscretization(None)
3069 f.__repr__() ; f.__str__()
3071 f=MEDCouplingFieldDouble(ON_GAUSS_PT)
3072 d=f.getDiscretization()
3073 i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
3074 d.setArrayOfDiscIds(i)
3075 f.__repr__() ; f.__str__()
3077 gl=MEDCouplingGaussLocalization(NORM_SEG2,[0,1],[0.5],[1.])
3079 gl.__repr__() ; gl.__str__()
3080 gl=MEDCouplingGaussLocalization(NORM_ERROR)
3082 gl.__repr__() ; gl.__str__()
3085 def testSwig2NonRegressionBugSubstractInPlaceDM(self):
3086 m0=MEDCouplingCMesh()
3087 arr=DataArrayDouble(5,1) ; arr.iota(0.)
3088 m0.setCoords(arr,arr)
3089 m0=m0.buildUnstructured()
3090 m00=m0[::2] ; m00.simplexize(0) ; m01=m0[1::2]
3091 m0=MEDCouplingUMesh.MergeUMeshes([m00,m01])
3092 m0.getCoords()[:]*=1/4.
3095 NodeField=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; NodeField.setTime(5.6,5,6) ; NodeField.setMesh(m0)
3096 NodeField.setName("NodeField")
3097 NodeField.fillFromAnalytic(1,"exp(-((x-1)*(x-1)+(y-1)*(y-1)))") ; NodeField.getArray().setInfoOnComponent(0,"powernode [W]")
3098 proc0=m0.getCellsInBoundingBox([(0.,0.4),(0.,0.4)],1e-10)
3099 proc1=proc0.buildComplement(m0.getNumberOfCells())
3101 NodeField0=NodeField[proc0] ; NodeField0.getMesh().setName(m0.getName())
3102 NodeField1=NodeField[proc1] ; NodeField1.getMesh().setName(m0.getName())
3104 NodeField_read=MEDCouplingFieldDouble.MergeFields([NodeField0,NodeField1])
3105 NodeField_read.mergeNodes(1e-10)
3106 NodeFieldCpy=NodeField.deepCopy()
3107 NodeFieldCpy.mergeNodes(1e-10)
3108 NodeField.checkConsistencyLight()
3109 self.assertTrue(not NodeField.getArray().isUniform(0.,1e-12))
3110 NodeField.substractInPlaceDM(NodeField_read,10,1e-12)
3111 self.assertTrue(NodeField.getArray().isUniform(0.,1e-12))
3114 def testSwigFieldOperationOpen1(self):
3115 ## MEDCouplingFieldDouble.__add__
3116 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3117 f=MEDCouplingFieldDouble(ON_CELLS)
3119 arr=DataArrayDouble(5,2)
3120 arr[:, 0] = list(range(5)) ; arr[:, 1] = 2 * arr[:, 0]
3122 self.assertRaises(InterpKernelException,f.__add__,2)
3123 self.assertRaises(InterpKernelException, f.__add__, list(range(5)))
3124 self.assertRaises(InterpKernelException,f.__add__,arr)
3125 self.assertRaises(InterpKernelException,f.__add__,f2)
3126 f.setArray(DataArrayDouble())
3127 self.assertRaises(InterpKernelException,f.__add__,2)
3128 self.assertRaises(InterpKernelException, f.__add__, list(range(5)))
3129 self.assertRaises(InterpKernelException,f.__add__,arr)
3130 self.assertRaises(InterpKernelException,f.__add__,f2)
3131 self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3132 f.getArray().alloc(5,2)
3133 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3135 ff.checkConsistencyLight()
3136 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
3138 ff.checkConsistencyLight()
3139 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
3140 self.assertRaises(InterpKernelException,f.__add__,f2)
3143 ff.checkConsistencyLight()
3144 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
3146 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
3147 ### MEDCouplingFieldDouble.__sub__
3148 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3149 f=MEDCouplingFieldDouble(ON_CELLS)
3151 arr=DataArrayDouble(5,2)
3152 arr[:, 0] = list(range(5)) ; arr[:, 1] = 2 * arr[:, 0]
3154 self.assertRaises(InterpKernelException,f.__sub__,2)
3155 self.assertRaises(InterpKernelException, f.__sub__, list(range(5)))
3156 self.assertRaises(InterpKernelException,f.__sub__,arr)
3157 self.assertRaises(InterpKernelException,f.__sub__,f2)
3158 f.setArray(DataArrayDouble())
3159 self.assertRaises(InterpKernelException,f.__sub__,2)
3160 self.assertRaises(InterpKernelException, f.__sub__, list(range(5)))
3161 self.assertRaises(InterpKernelException,f.__sub__,arr)
3162 self.assertRaises(InterpKernelException,f.__sub__,f2)
3163 self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3164 f.getArray().alloc(5,2)
3165 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3167 ff.checkConsistencyLight()
3168 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
3170 ff.checkConsistencyLight()
3171 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
3172 self.assertRaises(InterpKernelException,f.__sub__,f2)
3175 ff.checkConsistencyLight()
3176 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
3178 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-5,-1),(-4,0),(-3,1),(-2,2),(-1,3)]),1e-12))
3179 ### MEDCouplingFieldDouble.__mul__
3180 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3181 f=MEDCouplingFieldDouble(ON_CELLS)
3183 arr=DataArrayDouble(5,2)
3184 arr[:, 0] = list(range(5)) ; arr[:, 1] = 2 * arr[:, 0]
3186 self.assertRaises(InterpKernelException,f.__mul__,2)
3187 self.assertRaises(InterpKernelException, f.__mul__, list(range(5)))
3188 self.assertRaises(InterpKernelException,f.__mul__,arr)
3189 self.assertRaises(InterpKernelException,f.__mul__,f2)
3190 f.setArray(DataArrayDouble())
3191 self.assertRaises(InterpKernelException,f.__mul__,2)
3192 self.assertRaises(InterpKernelException, f.__mul__, list(range(5)))
3193 self.assertRaises(InterpKernelException,f.__mul__,arr)
3194 self.assertRaises(InterpKernelException,f.__mul__,f2)
3195 self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3196 f.getArray().alloc(5,2)
3197 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3199 ff.checkConsistencyLight()
3200 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
3202 ff.checkConsistencyLight()
3203 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
3204 self.assertRaises(InterpKernelException,f.__mul__,f2)
3207 ff.checkConsistencyLight()
3208 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
3210 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
3211 ### MEDCouplingFieldDouble.__div__
3212 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3213 f=MEDCouplingFieldDouble(ON_CELLS)
3215 arr=DataArrayDouble(5,2)
3216 arr[:, 0] = list(range(1, 6)) ; arr[:, 1] = 2 * arr[:, 0]
3218 self.assertRaises(InterpKernelException,f.__div__,2)
3219 self.assertRaises(InterpKernelException, f.__div__, list(range(5)))
3220 self.assertRaises(InterpKernelException,f.__div__,arr)
3221 self.assertRaises(InterpKernelException,f.__div__,f2)
3222 f.setArray(DataArrayDouble())
3223 self.assertRaises(InterpKernelException,f.__div__,2)
3224 self.assertRaises(InterpKernelException, f.__div__, list(range(5)))
3225 self.assertRaises(InterpKernelException,f.__div__,arr)
3226 self.assertRaises(InterpKernelException,f.__div__,f2)
3227 self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3228 f.getArray().alloc(5,2)
3229 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3230 self.assertRaises(InterpKernelException,f.__div__,0)
3232 ff.checkConsistencyLight()
3233 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
3235 ff.checkConsistencyLight()
3236 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))
3237 self.assertRaises(InterpKernelException,f.__div__,f2)
3240 ff.checkConsistencyLight()
3241 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))
3243 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))
3244 ### MEDCouplingFieldDouble.__pow__
3245 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3246 f=MEDCouplingFieldDouble(ON_CELLS)
3248 arr=DataArrayDouble(5)
3251 self.assertRaises(InterpKernelException,f.__div__,2)
3252 self.assertRaises(InterpKernelException, f.__div__, list(range(5)))
3253 self.assertRaises(InterpKernelException,f.__div__,arr)
3254 self.assertRaises(InterpKernelException,f.__div__,f2)
3255 f.setArray(DataArrayDouble())
3256 self.assertRaises(InterpKernelException,f.__div__,2)
3257 self.assertRaises(InterpKernelException, f.__div__, list(range(5)))
3258 self.assertRaises(InterpKernelException,f.__div__,arr)
3259 self.assertRaises(InterpKernelException,f.__div__,f2)
3260 self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3261 f.getArray().alloc(5,1)
3262 f.getArray()[:] = list(range(2, 7))
3264 ff.checkConsistencyLight()
3265 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([4,9,16,25,36]),1e-12))
3267 ff.checkConsistencyLight()
3268 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
3271 ff.checkConsistencyLight()
3272 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
3273 ## MEDCouplingFieldDouble.__iadd__
3274 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3275 f=MEDCouplingFieldDouble(ON_CELLS)
3277 arr=DataArrayDouble(5,2)
3278 arr[:, 0] = list(range(5)) ; arr[:, 1] = 2 * arr[:, 0]
3280 self.assertRaises(InterpKernelException,f.__iadd__,2)
3281 self.assertRaises(InterpKernelException, f.__iadd__, list(range(5)))
3282 self.assertRaises(InterpKernelException,f.__iadd__,arr)
3283 self.assertRaises(InterpKernelException,f.__iadd__,f2)
3284 f.setArray(DataArrayDouble())
3285 self.assertRaises(InterpKernelException,f.__iadd__,2)
3286 self.assertRaises(InterpKernelException, f.__iadd__, list(range(5)))
3287 self.assertRaises(InterpKernelException,f.__iadd__,arr)
3288 self.assertRaises(InterpKernelException,f.__iadd__,f2)
3289 f.getArray().alloc(5,2)
3290 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3291 f.checkConsistencyLight()
3293 f.checkConsistencyLight()
3294 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
3296 f.checkConsistencyLight()
3297 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(4,12),(6,15),(8,18),(10,21)]),1e-12))
3300 f.checkConsistencyLight()
3301 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(5,14),(8,19),(11,24),(14,29)]),1e-12))
3303 f.checkConsistencyLight()
3304 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))
3305 ## MEDCouplingFieldDouble.__isub__
3306 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3307 f=MEDCouplingFieldDouble(ON_CELLS)
3309 arr=DataArrayDouble(5,2)
3310 arr[:, 0] = list(range(5)) ; arr[:, 1] = 2 * arr[:, 0]
3312 self.assertRaises(InterpKernelException,f.__isub__,2)
3313 self.assertRaises(InterpKernelException, f.__isub__, list(range(5)))
3314 self.assertRaises(InterpKernelException,f.__isub__,arr)
3315 self.assertRaises(InterpKernelException,f.__isub__,f2)
3316 f.setArray(DataArrayDouble())
3317 self.assertRaises(InterpKernelException,f.__isub__,2)
3318 self.assertRaises(InterpKernelException, f.__isub__, list(range(5)))
3319 self.assertRaises(InterpKernelException,f.__isub__,arr)
3320 self.assertRaises(InterpKernelException,f.__isub__,f2)
3321 f.getArray().alloc(5,2)
3322 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3323 f.checkConsistencyLight()
3325 f.checkConsistencyLight()
3326 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
3328 f.checkConsistencyLight()
3329 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-2,4),(-2,3),(-2,2),(-2,1)]),1e-12))
3332 f.checkConsistencyLight()
3333 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-3,2),(-4,-1),(-5,-4),(-6,-7)]),1e-12))
3335 f.checkConsistencyLight()
3336 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))
3337 ## MEDCouplingFieldDouble.__imul__
3338 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3339 f=MEDCouplingFieldDouble(ON_CELLS)
3341 arr=DataArrayDouble(5,2)
3342 arr[:, 0] = list(range(5)) ; arr[:, 1] = 2 * arr[:, 0]
3344 self.assertRaises(InterpKernelException,f.__imul__,2)
3345 self.assertRaises(InterpKernelException, f.__imul__, list(range(5)))
3346 self.assertRaises(InterpKernelException,f.__imul__,arr)
3347 self.assertRaises(InterpKernelException,f.__imul__,f2)
3348 f.setArray(DataArrayDouble())
3349 self.assertRaises(InterpKernelException,f.__imul__,2)
3350 self.assertRaises(InterpKernelException, f.__imul__, list(range(5)))
3351 self.assertRaises(InterpKernelException,f.__imul__,arr)
3352 self.assertRaises(InterpKernelException,f.__imul__,f2)
3353 f.getArray().alloc(5,2)
3354 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3355 f.checkConsistencyLight()
3357 f.checkConsistencyLight()
3358 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
3360 f.checkConsistencyLight()
3361 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,32),(8,72),(18,120),(32,176)]),1e-12))
3364 f.checkConsistencyLight()
3365 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,64),(16,288),(54,720),(128,1408)]),1e-12))
3367 f.checkConsistencyLight()
3368 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))
3369 ## MEDCouplingFieldDouble.__idiv__
3370 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3371 f=MEDCouplingFieldDouble(ON_CELLS)
3373 arr=DataArrayDouble(5,2)
3374 arr[:, 0] = list(range(1, 6)) ; arr[:, 1] = 2 * arr[:, 0]
3376 self.assertRaises(InterpKernelException,f.__idiv__,2)
3377 self.assertRaises(InterpKernelException, f.__idiv__, list(range(5)))
3378 self.assertRaises(InterpKernelException,f.__idiv__,arr)
3379 self.assertRaises(InterpKernelException,f.__idiv__,f2)
3380 f.setArray(DataArrayDouble())
3381 self.assertRaises(InterpKernelException,f.__idiv__,2)
3382 self.assertRaises(InterpKernelException, f.__idiv__, list(range(5)))
3383 self.assertRaises(InterpKernelException,f.__idiv__,arr)
3384 self.assertRaises(InterpKernelException,f.__idiv__,f2)
3385 f.getArray().alloc(5,2)
3386 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3387 f.checkConsistencyLight()
3389 f.checkConsistencyLight()
3390 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
3392 f.checkConsistencyLight()
3393 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))
3396 f.checkConsistencyLight()
3397 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))
3399 f.checkConsistencyLight()
3400 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))
3401 ## MEDCouplingFieldDouble.__ipow__
3402 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3403 f=MEDCouplingFieldDouble(ON_CELLS)
3405 arr=DataArrayDouble(5,2)
3406 arr[:, 0] = list(range(1, 6)) ; arr[:, 1] = 2 * arr[:, 0]
3408 self.assertRaises(InterpKernelException,f.__ipow__,2)
3409 self.assertRaises(InterpKernelException, f.__ipow__, list(range(5)))
3410 self.assertRaises(InterpKernelException,f.__ipow__,arr)
3411 self.assertRaises(InterpKernelException,f.__ipow__,f2)
3412 f.setArray(DataArrayDouble())
3413 self.assertRaises(InterpKernelException,f.__ipow__,2)
3414 self.assertRaises(InterpKernelException, f.__ipow__, list(range(5)))
3415 self.assertRaises(InterpKernelException,f.__ipow__,arr)
3416 self.assertRaises(InterpKernelException,f.__ipow__,f2)
3417 f.getArray().alloc(5,2)
3418 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3419 f.checkConsistencyLight()
3421 f.checkConsistencyLight()
3422 self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,49),(1,64),(4,81),(9,100),(16,121)]),1e-12))
3423 ## MEDCouplingFieldDouble.__radd__
3424 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3425 f=MEDCouplingFieldDouble(ON_CELLS)
3427 arr=DataArrayDouble(5,2)
3428 arr[:, 0] = list(range(5)) ; arr[:, 1] = 2 * arr[:, 0]
3430 self.assertRaises(InterpKernelException,f.__radd__,2)
3431 self.assertRaises(InterpKernelException, f.__radd__, list(range(5)))
3432 self.assertRaises(InterpKernelException,f.__radd__,arr)
3433 self.assertRaises(InterpKernelException,f.__radd__,f2)
3434 f.setArray(DataArrayDouble())
3435 self.assertRaises(InterpKernelException,f.__radd__,2)
3436 self.assertRaises(InterpKernelException, f.__radd__, list(range(5)))
3437 self.assertRaises(InterpKernelException,f.__radd__,arr)
3438 self.assertRaises(InterpKernelException,f.__radd__,f2)
3439 self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3440 f.getArray().alloc(5,2)
3441 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3443 ff.checkConsistencyLight()
3444 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
3446 ff.checkConsistencyLight()
3447 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
3448 self.assertRaises(InterpKernelException,f.__radd__,f2)
3450 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
3451 ### MEDCouplingFieldDouble.__rsub__
3452 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3453 f=MEDCouplingFieldDouble(ON_CELLS)
3455 arr=DataArrayDouble(5,2)
3456 arr[:, 0] = list(range(5)) ; arr[:, 1] = 2 * arr[:, 0]
3458 self.assertRaises(InterpKernelException,f.__rsub__,2)
3459 self.assertRaises(InterpKernelException, f.__rsub__, list(range(5)))
3460 self.assertRaises(InterpKernelException,f.__rsub__,arr)
3461 self.assertRaises(InterpKernelException,f.__rsub__,f2)
3462 f.setArray(DataArrayDouble())
3463 self.assertRaises(InterpKernelException,f.__rsub__,2)
3464 self.assertRaises(InterpKernelException, f.__rsub__, list(range(5)))
3465 self.assertRaises(InterpKernelException,f.__rsub__,arr)
3466 self.assertRaises(InterpKernelException,f.__rsub__,f2)
3467 self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3468 f.getArray().alloc(5,2)
3469 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3471 ff.checkConsistencyLight()
3472 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,-5),(1,-6),(0,-7),(-1,-8),(-2,-9)]),1e-12))
3474 ff.checkConsistencyLight()
3475 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,-7),(0,-6),(0,-5),(0,-4),(0,-3)]),1e-12))
3476 self.assertRaises(InterpKernelException,f.__rsub__,f2)
3477 ### MEDCouplingFieldDouble.__rmul__
3478 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3479 f=MEDCouplingFieldDouble(ON_CELLS)
3481 arr=DataArrayDouble(5,2)
3482 arr[:, 0] = list(range(5)) ; arr[:, 1] = 2 * arr[:, 0]
3484 self.assertRaises(InterpKernelException,f.__rmul__,2)
3485 self.assertRaises(InterpKernelException, f.__rmul__, list(range(5)))
3486 self.assertRaises(InterpKernelException,f.__rmul__,arr)
3487 self.assertRaises(InterpKernelException,f.__rmul__,f2)
3488 f.setArray(DataArrayDouble())
3489 self.assertRaises(InterpKernelException,f.__rmul__,2)
3490 self.assertRaises(InterpKernelException, f.__rmul__, list(range(5)))
3491 self.assertRaises(InterpKernelException,f.__rmul__,arr)
3492 self.assertRaises(InterpKernelException,f.__rmul__,f2)
3493 self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3494 f.getArray().alloc(5,2)
3495 f.getArray()[:, 0] = list(range(5)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3497 ff.checkConsistencyLight()
3498 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
3500 ff.checkConsistencyLight()
3501 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
3502 self.assertRaises(InterpKernelException,f.__rmul__,f2)
3504 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
3505 ### MEDCouplingFieldDouble.__rdiv__
3506 m=MEDCouplingDataForTest.build2DTargetMesh_1()
3507 f=MEDCouplingFieldDouble(ON_CELLS)
3509 arr=DataArrayDouble(5,2)
3510 arr[:, 0] = list(range(1, 6)) ; arr[:, 1] = 2 * arr[:, 0]
3512 self.assertRaises(InterpKernelException,f.__rdiv__,2)
3513 self.assertRaises(InterpKernelException, f.__rdiv__, list(range(5)))
3514 self.assertRaises(InterpKernelException,f.__rdiv__,arr)
3515 self.assertRaises(InterpKernelException,f.__rdiv__,f2)
3516 f.setArray(DataArrayDouble())
3517 self.assertRaises(InterpKernelException,f.__rdiv__,2)
3518 self.assertRaises(InterpKernelException, f.__rdiv__, list(range(5)))
3519 self.assertRaises(InterpKernelException,f.__rdiv__,arr)
3520 self.assertRaises(InterpKernelException,f.__rdiv__,f2)
3521 self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
3522 f.getArray().alloc(5,2)
3523 f.getArray()[:, 0] = list(range(1, 6)) ; f.getArray()[:, 1] = f.getArray()[:, 0] + 7
3525 ff.checkConsistencyLight()
3526 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))
3528 ff.checkConsistencyLight()
3529 self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(1,0.25),(1,0.44444444444444442),(1,0.59999999999999998),(1,0.72727272727272729),(1,0.83333333333333337)]),1e-12))
3530 self.assertRaises(InterpKernelException,f.__rdiv__,f2)
3535 if __name__ == '__main__':