X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling_Swig%2FMEDCouplingBasicsTest.py;h=0f7e74cf0787044b4ce83628eef6ba0ab701c653;hb=e440c33e8d9c04788fe848fe58d1e17cbea27e54;hp=b0523db87ecd7c3fb226f5da262b1fa2be5856da;hpb=48e298dbf14059e3392eb522cfdb634bfefeaf1b;p=tools%2Fmedcoupling.git

diff --git a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py
index b0523db87..0f7e74cf0 100644
--- a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py
+++ b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py
@@ -21,7 +21,9 @@
 from MEDCoupling import *
 import unittest
 from math import pi,e,sqrt,cos,sin
+from datetime import datetime
 from MEDCouplingDataForTest import MEDCouplingDataForTest
+import rlcompleter,readline # this line has to be here, ot ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@cea.fr
 
 class MEDCouplingBasicsTest(unittest.TestCase):
     def testArray2(self):
@@ -89,6 +91,21 @@ class MEDCouplingBasicsTest(unittest.TestCase):
                  -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863, 
                  0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
                  0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
+        self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI3),3)
+        self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI3))
+        self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_TRI3))
+        self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI3),2)
+        self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI3),"NORM_TRI3")
+        self.assertRaises(InterpKernelException,MEDCouplingMesh.GetNumberOfNodesOfGeometricType,NORM_POLYGON)
+        self.assertTrue(not MEDCouplingMesh.IsStaticGeometricType(NORM_POLYGON))
+        self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_POLYGON))
+        self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_POLYGON),2)
+        self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_POLYGON),"NORM_POLYGON")
+        self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI6),6)
+        self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI6))
+        self.assertTrue(not MEDCouplingMesh.IsLinearGeometricType(NORM_TRI6))
+        self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI6),2)
+        self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI6),"NORM_TRI6")
         mesh=MEDCouplingUMesh.New()
         mesh.setMeshDimension(2)
         mesh.allocateCells(8);
@@ -582,6 +599,7 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
         #
         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
+        self.assertEqual(fieldOnCells2.getMesh(),None) # to check that convertMesh wrapping do not raise but return Py_None
         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
@@ -1814,11 +1832,8 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         self.assertEqual(1, len(dis));
         self.assertEqual(NORM_HEXA8, dis[0][0]);
         self.assertEqual(27, dis[0][1]);
-        self.assertEqual(0, dis[0][2]);
+        self.assertEqual(-1, dis[0][2]);
         
-        idsPerType=[]
-        self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
-        dis[0][2]=-1;
         idsPerType=[]
         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
         dis[0][0]=NORM_QUAD4;
@@ -1827,20 +1842,20 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         dis[0][2]=0;
         ids=DataArrayInt.New();
         ids.alloc(10, 1);
-        ids.fillWithValue(111);
+        ids.fillWithValue(23);
         idsPerType=[ids];
         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
         self.assertTrue(check);
         self.assertTrue(check.isEqual(ids));
         
         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
-        self.assertEqual(3, len(code));
-        self.assertEqual(NORM_HEXA8, code[0]);
-        self.assertEqual(27, code[1]);
-        self.assertEqual(0, code[2]);
+        self.assertEqual(1, len(code));
+        self.assertEqual(NORM_HEXA8, code[0][0]);
+        self.assertEqual(27, code[0][1]);
+        self.assertEqual(0, code[0][2]);
         self.assertEqual(1, len(idsInPflPerType));
         self.assertEqual(1, len(pfls));
-        self.assertTrue(idsInPflPerType[0].isEqual(ids));
+        self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
         self.assertTrue(pfls[0].isEqual(ids));
         
         cells1=[0, 1, 25, 26]
@@ -3505,6 +3520,13 @@ class MEDCouplingBasicsTest(unittest.TestCase):
             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
             pass
         #
+        d2,d2I=array.maxPerTupleWithCompoId()
+        self.assertEqual(1,d2.getNumberOfComponents());
+        self.assertEqual(5,d2.getNumberOfTuples());
+        for i in xrange(5):
+            self.assertAlmostEqual(5.6,d2.getIJ(i,0),13);
+            pass
+        self.assertTrue(d2I.isEqual(DataArrayInt([4,3,2,0,1])))
         pass
 
     def testChangeNbOfComponents(self):
@@ -7720,12 +7742,10 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         d.setValues(val1,3,1);
         d.setName("sup")
         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
-        self.assertEqual(6,len(code));
+        self.assertEqual(2,len(code));
         self.assertEqual(2,len(idsInPflPerType));
-        expected1=[3,1,0, 4,2,1]
-        for i in xrange(6):
-            self.assertEqual(expected1[i],code[i]);
-            pass
+        expected1=[[3,1,0], [4,2,1]]
+        self.assertEqual(expected1,code)
         self.assertEqual(2,len(idsInPflPerType));
         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
@@ -7746,12 +7766,10 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         d=DataArrayInt.New();
         d.setValues(val2,4,1);
         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
-        self.assertEqual(6,len(code));
+        self.assertEqual(2,len(code));
         self.assertEqual(2,len(idsInPflPerType));
-        expected2=[3,1,0, 4,3,-1]
-        for i in xrange(6):
-            self.assertEqual(expected2[i],code[i]);
-            pass
+        expected2=[[3,1,0], [4,3,-1]]
+        self.assertEqual(expected2,code);
         self.assertEqual(2,len(idsInPflPerType));
         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
@@ -7768,12 +7786,10 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         d=DataArrayInt.New();
         d.setValues(val3,3,1);
         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
-        self.assertEqual(6,len(code));
+        self.assertEqual(2,len(code));
         self.assertEqual(2,len(idsInPflPerType));
-        expected3=[3,2,0, 4,1,1]
-        for i in xrange(6):
-            self.assertEqual(expected3[i],code[i]);
-            pass
+        expected3=[[3,2,0], [4,1,1]]
+        self.assertEqual(expected3,code);
         self.assertEqual(2,len(idsInPflPerType));
         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
@@ -7791,12 +7807,10 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         d=DataArrayInt.New();
         d.setValues(val4,2,1);
         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
-        self.assertEqual(3,len(code));
+        self.assertEqual(1,len(code));
         self.assertEqual(1,len(idsInPflPerType));
-        expected4=[4,2,0]
-        for i in xrange(3):
-            self.assertEqual(expected4[i],code[i]);
-            pass
+        expected4=[[4,2,0]]
+        self.assertEqual(expected4,code);
         self.assertEqual(1,len(idsInPflPerType));
         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
@@ -7868,10 +7882,10 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         self.assertEqual(2,len(code));
         self.assertEqual(3,code[0][0]);
         self.assertEqual(2,code[0][1]);
-        self.assertEqual(0,code[0][2]);
+        self.assertEqual(-1,code[0][2]);
         self.assertEqual(4,code[1][0]);
         self.assertEqual(3,code[1][1]);
-        self.assertEqual(0,code[1][2]);
+        self.assertEqual(-1,code[1][2]);
         pass
 
     def testNorm2_1(self):
@@ -10890,11 +10904,11 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         m.setCoords(coords)
         m.allocateCells(0)
         m.insertNextCell(NORM_TRI3,[0,1,2])
-        a,b,c=m.distanceToPoint([-0.335,2.27,1.21])
-        self.assertEqual(0,b) ; self.assertEqual(0,c)
+        a,b=m.distanceToPoint([-0.335,2.27,1.21])
+        self.assertEqual(0,b)
         self.assertAlmostEqual(0.022360988100374124,a,14);
-        a,b,c=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
-        self.assertEqual(0,b) ; self.assertEqual(0,c)
+        a,b=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
+        self.assertEqual(0,b)
         self.assertAlmostEqual(0.022360988100374124,a,14);
         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
         self.assertAlmostEqual(5.243302871282566,a,14)
@@ -10907,31 +10921,31 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
         m.checkCoherency2()
         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
-        a,b,c=m.distanceToPoint([5.,2.,0.1])
-        self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
-        a,b,c=m.distanceToPoint([5.,-2.,4.])
-        self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
+        a,b=m.distanceToPoint([5.,2.,0.1])
+        self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b)
+        a,b=m.distanceToPoint([5.,-2.,4.])
+        self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b)
         m.allocateCells(0)
         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
         m.checkCoherency2()
         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
-        a,b,c=m.distanceToPoint([11.,3.,4.])
-        self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
-        a,b,c=m.distanceToPoint([4.,12.,5.])
-        self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b) ; self.assertEqual(2,c)
+        a,b=m.distanceToPoint([11.,3.,4.])
+        self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b)
+        a,b=m.distanceToPoint([4.,12.,5.])
+        self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b)
         d=DataArrayDouble([-1.2,3.,2.],1,3)
         for elt in d:
-            a,b,c=m.distanceToPoint(d)
-            self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b) ; self.assertEqual(0,c)
+            a,b=m.distanceToPoint(d)
+            self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b)
             pass
         #
         m=MEDCouplingUMesh("toto",1)
         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
-        a,b,c=m.distanceToPoint([-0.1,4.1])
-        self.assertAlmostEqual(0.14142135623730925,a,14) ; self.assertEqual(-1,b) ; self.assertEqual(2,c)
-        a,b,c=m.distanceToPoint([0.,3.9])
-        self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) ; self.assertEqual(2,c)
+        a,b=m.distanceToPoint([-0.1,4.1])
+        self.assertAlmostEqual(0.14142135623730925,a,14)  # b==1 self.assertEqual(2,c)
+        a,b=m.distanceToPoint([0.,3.9])
+        self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) # self.assertEqual(2,c)
         pass
 
     def testSwig2NonRegressionPartitionBySpreadZone1(self):
@@ -12570,6 +12584,812 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         self.assertTrue( field.getArray().getValues() == coords2 )
         pass
 
+    def testSwig2UMeshDistanceToMesh2(self):
+        sz=5
+        m=MEDCouplingCMesh()
+        arr=DataArrayDouble(sz+1) ; arr.iota() ; arr/=sz
+        m.setCoords(arr,arr,arr)
+        m=m.buildUnstructured()
+        m1=m.computeSkin()
+        m1.zipCoords()
+        c=m1.getCoords()[:]
+        d=2*(c-[0.5,0.5,0.5])+[0.5,0.5,0.5]
+        time_deb = datetime.now()
+        #print "go.."
+        a,b=m1.distanceToPoints(d)
+        #print 'time spent in distanceToPoints %s ' %str(datetime.now() - time_deb)
+        time_deb = datetime.now()
+        a1=DataArrayDouble(len(d))
+        b1=DataArrayInt(len(d))
+        m1s=[m1[i] for i in xrange(m1.getNumberOfCells())]
+        for j,pt in enumerate(d):
+            eter=1e308
+            fter=-1
+            for i,miter in enumerate(m1s):
+                e,f=miter.distanceToPoint(pt)
+                self.assertEqual(0,f)
+                if e<eter:
+                    eter=e ; fter=i
+                    pass
+                pass
+            a1[j]=eter
+            b1[j]=fter
+            pass
+        #print 'time spent in naive distanceToPoints  %s ' %str(datetime.now() - time_deb)
+        self.assertTrue(a.isEqual(a1,1e-12))
+        self.assertTrue(b.isEqual(b1))
+        self.assertTrue(a.isEqual(DataArrayDouble([0.8660254037844386,0.714142842854285,0.7071067811865476,0.7071067811865476,0.714142842854285,0.8660254037844386,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.8660254037844386,0.714142842854285,0.7071067811865476,0.7071067811865476,0.714142842854285,0.8660254037844386,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706631,0.714142842854285,0.5196152422706631,0.5196152422706632,0.5099019513592784,0.5099019513592785,0.5099019513592784,0.5099019513592785,0.5196152422706631,0.5196152422706632,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592784,0.7071067811865475,0.5099019513592784,0.5099019513592785,0.5,0.5,0.5,0.5,0.5099019513592785,0.5099019513592785,0.7071067811865476,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592784,0.7071067811865475,0.5099019513592784,0.5099019513592785,0.5,0.5,0.5,0.5,0.5099019513592785,0.5099019513592785,0.7071067811865476,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706631,0.714142842854285,0.5196152422706631,0.5196152422706632,0.5099019513592784,0.5099019513592785,0.5099019513592784,0.5099019513592785,0.5196152422706631,0.5196152422706632,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.8660254037844386,0.714142842854285,0.7071067811865476,0.7071067811865476,0.714142842854285,0.8660254037844386,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.8660254037844386,0.714142842854285,0.7071067811865476,0.7071067811865476,0.714142842854285,0.8660254037844386]),1e-12))
+        self.assertTrue(b.isEqual(DataArrayInt([0,0,3,7,9,9,0,0,3,7,9,9,12,12,14,16,17,17,26,26,28,30,31,31,33,33,36,40,42,42,33,33,36,40,42,42,0,0,3,7,11,9,0,9,12,17,26,31,33,42,33,33,36,40,42,42,45,45,47,49,51,51,45,50,52,53,56,57,58,63,58,58,60,62,63,63,85,85,87,89,91,91,85,90,92,93,96,97,98,103,98,98,100,102,103,103,105,105,108,112,116,114,105,114,117,122,131,136,138,147,138,138,141,145,147,147,105,105,108,112,114,114,105,105,108,112,114,114,117,117,119,121,122,122,131,131,133,135,136,136,138,138,141,145,147,147,138,138,141,145,147,147])))
+        pass
+
+    def testSwig2NonRegressionBugDistance1(self):
+        pt=DataArrayDouble([(8.8452994616207476,3.1547005383792515,3.1547005383792515)])
+        coo=DataArrayDouble([(8,0,0),(8,0,8),(8,8,8),(8,8,0),(16,0,0),(16,0,8),(16,8,8),(16,8,0),(8,0,4),(8,4,8),(8,8,4),(8,4,0),(16,0,4),(16,4,8),(16,8,4),(16,4,0),(12,0,0),(12,0,8),(12,8,8),(12,8,0),(8,4,4),(16,4,4),(12,0,4),(12,4,8),(12,8,4),(12,4,0)])
+        conn=DataArrayInt([4,15,21,12,4,16,25,15,12,22,16,4,0,8,20,11,16,0,11,25,22,8,0,16,15,7,14,21,15,25,19,7,7,19,24,14,11,20,10,3,25,11,3,19,19,3,10,24,12,21,13,5,13,23,17,5,5,17,22,12,8,1,9,20,23,9,1,17,17,1,8,22,21,14,6,13,14,24,18,6 ,6,18,23,13,20,9,2,10,24,10,2,18,18,2,9,23])
+        m=MEDCouplingUMesh("mesh",2)
+        m.setCoords(coo)
+        m.allocateCells()
+        for i in xrange(24):
+            m.insertNextCell(NORM_QUAD4,conn[4*i:4*i+4])
+            pass
+        m.checkCoherency2()
+        m0=m[3] ; m0.zipCoords()
+        expectedDist=0.8452994616207476
+        a,b=m0.distanceToPoint(pt)
+        self.assertAlmostEqual(expectedDist,a,14)
+        self.assertEqual(0,b)
+        #
+        a,b=m.distanceToPoint(pt)
+        self.assertAlmostEqual(expectedDist,a,14)
+        self.assertEqual(3,b)
+        #
+        fd=MEDCouplingFieldDiscretization.New(ON_CELLS)
+        self.assertEqual(24,fd.getNumberOfTuples(m))
+        fd=MEDCouplingFieldDiscretization.New(ON_NODES)
+        self.assertEqual(26,fd.getNumberOfTuples(m))
+        pass
+
+    def testSwig2AreaBarySeg3Quad8Tri6QPolyg(self):
+        #QUAD8 representing a circle of center zeBary and radius zeRadius
+        zeBary=[5,6]
+        zeRadius=3
+        d=DataArrayDouble(8,2)
+        d[:,0]=zeRadius
+        d[:,1]=[87,-100,-170,110,5,-130,175,95] # angle in degree
+        d[:,1]*=pi/180. # angle in radian
+        d=d.fromPolarToCart()
+        d+=zeBary
+        m=MEDCouplingUMesh("quad8",2) ; m.allocateCells() ; m.insertNextCell(NORM_QUAD8,range(8)) ; m.setCoords(d)
+        self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
+        self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
+        tri32D=m.buildDescendingConnectivity()[0][0] ; tri32D.zipCoords()
+        # spaceDim=3 QUAD8 becomes QUAD4 ... for the moment
+        m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
+        m2=m.deepCpy()
+        m2.convertQuadraticCellsToLinear()
+        self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
+        self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
+        #TRI6 representing a circle of center zeBary and radius zeRadius
+        zeBary=[5,6]
+        zeRadius=3
+        d=DataArrayDouble(6,2)
+        d[:,0]=zeRadius
+        d[:,1]=[87,-100,110,5,175,95] # angle in degree
+        d[:,1]*=pi/180. # angle in radian
+        d=d.fromPolarToCart()
+        d+=zeBary
+        m=MEDCouplingUMesh("tri6",2) ; m.allocateCells() ; m.insertNextCell(NORM_TRI6,range(6)) ; m.setCoords(d)
+        self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
+        self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
+        # spaceDim=3 TRI6 becomes TRI3 ... for the moment
+        m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
+        m2=m.deepCpy()
+        m2.convertQuadraticCellsToLinear()
+        self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
+        self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
+        # QPOLYG representing a circle of center zeBary and radius zeRadius
+        zeBary=[5,6]
+        zeRadius=3
+        d=DataArrayDouble(10,2)
+        d[:,0]=zeRadius
+        d[:,1]=[87,-80,-100,-170,110,5,-90,-130,175,95] # angle in degree
+        d[:,1]*=pi/180. # angle in radian
+        d=d.fromPolarToCart()
+        d+=zeBary
+        m=MEDCouplingUMesh("qpolyg",2) ; m.allocateCells() ; m.insertNextCell(NORM_QPOLYG,range(10)) ; m.setCoords(d)
+        self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
+        self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
+        # spaceDim=3 QPOLYG becomes POLYG ... for the moment
+        m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
+        m2=m.deepCpy()
+        m2.convertQuadraticCellsToLinear() ; m2.checkCoherency2()
+        self.assertTrue(m2.getAllGeoTypes()==[NORM_POLYGON] and m2.getNodalConnectivity().getValues()==[5,0,1,2,3,4])
+        self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
+        self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
+        # TRI3
+        self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),(87+100)*pi/180*zeRadius,13)
+        exp=DataArrayDouble(1,2) ; exp[:,0]=3 ; exp[:,1]=(87-100)/2. ; exp[:,1]*=pi/180. ;  exp=exp.fromPolarToCart() ; exp+=DataArrayDouble([5,6],1,2)
+        self.assertTrue(tri32D.getBarycenterAndOwner().isEqual(exp,1e-12))
+        # spaceDim=3 TRI3 becomes TRI2 ... for the moment
+        tri32D.changeSpaceDimension(3)
+        tri2=tri32D.deepCpy() ; tri2.convertQuadraticCellsToLinear()
+        self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),float(tri2.getMeasureField(False).getArray()),13)
+        self.assertTrue(tri32D.getBarycenterAndOwner().isEqual(tri2.getBarycenterAndOwner(),1e-12))
+        tri32D.changeSpaceDimension(1)
+        self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),-0.67795240172962323,12)
+        pass
+
+    # this bug 5/6/2013 is swig specific
+    def testSwigNonRegressionBugRotate3D1(self):
+        m=MEDCouplingUMesh.New()
+        dataArray=DataArrayDouble.New(100,3)
+        dataArray[:]=0.
+        dataArray[0]=[0.,1,3]
+        m.setCoords(dataArray[0])
+        m1=m.deepCpy()
+        m.rotate([0.,0.,3.],[1.,0.,0.],0.5*pi)
+        self.assertTrue(m.getCoords().isEqual(DataArrayDouble([0.,0.,4.],1,3),1e-15))
+        #
+        d1=DataArrayDouble([0.,0.,3.],1,3) ; d2=DataArrayDouble([1.,0.,0.],1,3)
+        pts=[[0.,0.,3.],[(0.,0.,3.)],DataArrayDouble([0.,0.,3.],1,3),list(d1)[0]]
+        vec=[[1.,0.,0.],[(1.,0.,0.)],DataArrayDouble([1.,0.,0.],1,3),list(d2)[0]]
+        for p in pts:
+            for v in vec:
+                m2=m1.deepCpy()
+                m2.rotate(p,v,0.5*pi)
+                self.assertTrue(m2.getCoords().isEqual(DataArrayDouble([0.,0.,4.],1,3),1e-15))
+                pass
+        pass
+
+    def testSwig2DataArrayCount1(self):
+        d=DataArrayInt([])
+        self.assertEqual(0,d.getNumberOfTuples())
+        self.assertEqual(1,d.getNumberOfComponents())
+        self.assertEqual(0,d.count(0))
+        self.assertEqual(0,d.count(1))
+        self.assertEqual(0,d.count(-1))
+        d=DataArrayInt([2,1,-2,-3,2,0,0,7,2,-2,3,0])
+        self.assertEqual(12,d.getNumberOfTuples())
+        self.assertEqual(1,d.getNumberOfComponents())
+        self.assertEqual(3,d.count(0))
+        self.assertEqual(1,d.count(1))
+        self.assertEqual(0,d.count(-1))
+        self.assertEqual(2,d.count(-2))
+        self.assertEqual(3,d.count(2))
+        e=d.getDifferentValues()
+        f=DataArrayInt()
+        for it in e:
+            f.pushBackSilent(d.count(int(it)))
+            pass
+        self.assertEqual(12,f.accumulate()[0])
+        #
+        eps=1e-12
+        d=DataArrayDouble([])
+        self.assertEqual(0,d.getNumberOfTuples())
+        self.assertEqual(1,d.getNumberOfComponents())
+        self.assertEqual(0,d.count(0,eps))
+        self.assertEqual(0,d.count(1,eps))
+        self.assertEqual(0,d.count(-1,eps))
+        d=DataArrayDouble([2,1,-2,-3,2,0,eps/10,7,2+eps/10,-2,3,0])
+        self.assertEqual(12,d.getNumberOfTuples())
+        self.assertEqual(1,d.getNumberOfComponents())
+        self.assertEqual(3,d.count(0,eps))
+        self.assertEqual(1,d.count(1,eps))
+        self.assertEqual(0,d.count(-1,eps))
+        self.assertEqual(2,d.count(-2,eps))
+        self.assertEqual(3,d.count(2,eps))
+        self.assertEqual(3,d.count(2,eps))
+        self.assertEqual(2,d.count(2,eps/100))
+        e=d.getDifferentValues(eps)
+        f=DataArrayInt()
+        for it in e:
+            f.pushBackSilent(d.count(float(it),eps))
+            pass
+        self.assertEqual(12,f.accumulate()[0])
+        pass
+
+    def testSwig2DataArrayGetSlice1(self):
+        s=slice(2,18,1)
+        self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),16)
+        self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),16)
+        self.assertEqual(DataArray.GetSlice(s,0,4),slice(2,6,1))
+        self.assertEqual(DataArray.GetSlice(s,1,4),slice(6,10,1))
+        self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,14,1))
+        self.assertEqual(DataArray.GetSlice(s,3,4),slice(14,18,1))
+        #
+        s=slice(2,18,2)
+        self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),8)
+        self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),8)
+        self.assertEqual(DataArray.GetSlice(s,0,4),slice(2,6,2))
+        self.assertEqual(DataArray.GetSlice(s,1,4),slice(6,10,2))
+        self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,14,2))
+        self.assertEqual(DataArray.GetSlice(s,3,4),slice(14,18,2))
+        #
+        s=slice(1,18,1)
+        self.assertEqual(DataArray.GetSlice(s,0,4),slice(1,5,1))
+        self.assertEqual(DataArray.GetSlice(s,1,4),slice(5,9,1))
+        self.assertEqual(DataArray.GetSlice(s,2,4),slice(9,13,1))
+        self.assertEqual(DataArray.GetSlice(s,3,4),slice(13,18,1))# 18 not 17
+        #
+        s=slice(1,18,2)
+        self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),9)
+        self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),9)
+        self.assertEqual(DataArray.GetSlice(s,0,4),slice(1,5,2))
+        self.assertEqual(DataArray.GetSlice(s,1,4),slice(5,9,2))
+        self.assertEqual(DataArray.GetSlice(s,2,4),slice(9,13,2))
+        self.assertEqual(DataArray.GetSlice(s,3,4),slice(13,18,2))# 18 not 17
+        #
+        s=slice(18,2,-1)
+        self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-1))
+        self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-1))
+        self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-1))
+        self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,2,-1))
+        #
+        s=slice(18,2,-2)
+        self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-2))
+        self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-2))
+        self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-2))
+        self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,2,-2))
+        #
+        s=slice(18,1,-1)
+        self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-1))
+        self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-1))
+        self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-1))
+        self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,1,-1))# 1 not 2
+        #
+        s=slice(18,1,-2)
+        self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),9)
+        self.assertRaises(InterpKernelException,DataArray.GetNumberOfItemGivenBES,s)
+        self.assertEqual(sum([DataArray.GetNumberOfItemGivenBESRelative(DataArray.GetSlice(s,i,4)) for i in xrange(4)]),DataArray.GetNumberOfItemGivenBESRelative(s))
+        self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-2))
+        self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-2))
+        self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-2))
+        self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,1,-2))# 1 not 2
+        self.assertRaises(InterpKernelException,DataArray.GetSlice,slice(0,None,2),0,4)
+        #
+        d=DataArrayInt.Range(0,18,1)
+        s=slice(2,None,1)
+        self.assertEqual(d.getNumberOfItemGivenBES(s),16)
+        self.assertEqual(d.getNumberOfItemGivenBESRelative(s),16)
+        self.assertEqual(d.getSlice(s,0,4),slice(2,6,1))
+        self.assertEqual(d.getSlice(s,1,4),slice(6,10,1))
+        self.assertEqual(d.getSlice(s,2,4),slice(10,14,1))
+        self.assertEqual(d.getSlice(s,3,4),slice(14,18,1))
+        #
+        d=DataArrayInt.Range(0,18,1)
+        s=slice(2,-2,1)
+        self.assertEqual(d.getSlice(s,0,4),slice(2,5,1))
+        self.assertEqual(d.getSlice(s,1,4),slice(5,8,1))
+        self.assertEqual(d.getSlice(s,2,4),slice(8,11,1))
+        self.assertEqual(d.getSlice(s,3,4),slice(11,16,1))
+        #
+        d=DataArrayInt.Range(0,18,1)
+        s=slice(None,None,1)
+        self.assertEqual(d.getSlice(s,0,4),slice(0,4,1))
+        self.assertEqual(d.getSlice(s,1,4),slice(4,8,1))
+        self.assertEqual(d.getSlice(s,2,4),slice(8,12,1))
+        self.assertEqual(d.getSlice(s,3,4),slice(12,18,1))
+        #
+        d=DataArrayInt.Range(0,18,1)
+        s=slice(None,2,-2)
+        self.assertRaises(InterpKernelException,d.getNumberOfItemGivenBES,s)
+        self.assertEqual(d.getNumberOfItemGivenBESRelative(s),8)
+        self.assertEqual(d.getSlice(s,0,4),slice(17,13,-2))
+        self.assertEqual(d.getSlice(s,1,4),slice(13,9,-2))
+        self.assertEqual(d.getSlice(s,2,4),slice(9,5,-2))
+        self.assertEqual(d.getSlice(s,3,4),slice(5,2,-2))
+        pass
+
+    def testSwig2AccumulatePerChunk1(self):
+        arr=DataArrayDouble(11) ; arr.iota()
+        m=MEDCouplingCMesh() ; m.setCoords(arr,arr)
+        m=m.buildUnstructured()
+        m0=m[::2] ; ids0=m0.simplexize(0) ; m1=m[1::2]
+        m=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m0,m1) ; m.setName("mesh")
+        m.checkConsecutiveCellTypesForMEDFileFrmt()
+        #
+        formula="7-sqrt((x-5.)*(x-5.)+(y-5.)*(y-5.))"
+        f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME) ; f.setMesh(m)
+        f.fillFromAnalytic(1,formula)
+        f.setName("Field1") ; f.setTime(1.1,1,-1)
+        f.checkCoherency()
+        #
+        arr=f.getArray()
+        arr2=DataArrayDouble(len(arr),2) ; arr2[:,0]=arr
+        arr2=DataArrayDouble(len(arr),2) ; arr2[:,0]=arr ; arr2[:,1]=2*arr
+        f.setArray(arr2)
+        f.checkCoherency()
+        # here the compact code to obviously put field on cell to nodes
+        rn,rni=f.getMesh().getReverseNodalConnectivity()
+        arr2=f.getArray()[rn]
+        arr4=arr2.accumulatePerChunck(rni)
+        nbOfCellsSharingNodes=rni.deltaShiftIndex()
+        arr4/=nbOfCellsSharingNodes.convertToDblArr()
+        #
+        maxNbCSN=nbOfCellsSharingNodes.getMaxValue()[0]
+        arr3=DataArrayDouble(f.getMesh().getNumberOfNodes(),f.getArray().getNumberOfComponents()) ; arr3[:]=0.
+        for i in xrange(1,maxNbCSN+1):
+            ids=nbOfCellsSharingNodes.getIdsEqual(i)
+            if len(ids)==0:
+                continue
+            for j in range(i):
+                rni2=rni[ids] ; rni2+=j
+                arr3[ids]+=arr2[rni2]
+                pass
+            arr3[ids]/=i
+            pass
+        fNode=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; fNode.setMesh(m)
+        fNode.setName("Field1Node") ; fNode.setTime(1.1,1,-1)
+        fNode.setArray(arr3) ; fNode.checkCoherency()
+        self.assertTrue(arr3.isEqual(arr4,1e-12))
+        #
+        d=DataArrayInt.Range(0,20,1)
+        self.assertTrue(d.accumulatePerChunck([2,4,12]).isEqual(DataArrayInt([5,60])))
+        #
+        a=DataArrayDouble(12) ; a.iota() ; a.rearrange(3)
+        b=DataArrayDouble(12) ; b.iota(20) ; b.rearrange(3)
+        ids=DataArrayInt([])
+        self.assertEqual(len(a[ids]),0)
+        self.assertEqual(len(b[ids]),0)
+        a2=a.deepCpy() ;  a2[ids]+=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
+        a2=a.deepCpy() ;  a2[ids]*=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
+        a2=a.deepCpy() ;  a2[ids]/=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
+        a2=a.deepCpy() ;  a2[ids]-=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
+        pass
+
+    def testSwig2CheckAndPreparePermutation1(self):
+        a=DataArrayInt([10003,9999999,5,67])
+        self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([2,3,0,1])))
+        a=DataArrayInt([10003,-9999999,5,67])
+        self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([3,0,1,2])))
+        a=DataArrayInt([])
+        self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([])))
+        a=DataArrayInt([])
+        a.iota();
+        self.assertTrue(a.isEqual(DataArrayInt([])))
+        pass
+
+    def testSwig21SGTUMesh1(self):
+        m=MEDCoupling1GTUMesh.New("m",NORM_PENTA6)
+        m.__repr__() ; m.__str__()
+        self.assertTrue(isinstance(m,MEDCoupling1SGTUMesh))
+        m.setCoords(DataArrayDouble(20,3))
+        m.allocateCells()
+        m.__repr__() ; m.__str__()
+        m.insertNextCell([0,1,2,5,7,2])
+        self.assertEqual(1,m.getNumberOfCells())
+        self.assertTrue(DataArrayInt([6]).isEqual(m.computeNbOfNodesPerCell()))
+        self.assertTrue(DataArrayInt([5]).isEqual(m.computeNbOfFacesPerCell()))
+        m.__repr__() ; m.__str__()
+        m.checkCoherency()
+        m.checkCoherency2()
+        #
+        cm=MEDCouplingCMesh() ; cm.setName("m")
+        arr0=DataArrayDouble(6) ; arr0.iota()
+        arr1=DataArrayDouble([0,1])
+        cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured()
+        #
+        m=MEDCoupling1SGTUMesh("m",NORM_QUAD4)
+        m.allocateCells(5)
+        self.assertIn(m.getHeapMemorySize(),xrange(80,90))
+        self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
+        m.setCoords(um.getCoords())
+        m.insertNextCell([1,0,6,7])
+        self.assertEqual(1,m.getNumberOfCells())
+        m.insertNextCell([2,1,7,8])
+        m.insertNextCell([3,2,8,9])
+        m.insertNextCell([4,3,9,10])
+        m.insertNextCell([5,4,10,11])
+        self.assertEqual(5,m.getNumberOfCells())
+        self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7])
+        self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7,1,2])
+        self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
+        f=m.getMeasureField(ON_CELLS)
+        self.assertEqual(f.getMesh().getHiddenCppPointer(),m.getHiddenCppPointer())
+        self.assertTrue(f.getArray().isUniform(1,1e-14))
+        self.assertEqual(m.getType(),10)
+        self.assertEqual(m.getCellModelEnum(),NORM_QUAD4)
+        mo=MEDCoupling1SGTUMesh("m",NORM_QUAD4) ; mo.setCoords(m.getCoords())
+        mo.setNodalConnectivity(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11]))
+        self.assertTrue(m.isEqual(mo,1e-12))
+        #
+        mo2=MEDCoupling1SGTUMesh.Merge1SGTUMeshesOnSameCoords([m[[0,1]],m[[2]],m[[3,4]]])
+        mo2.setName(m.getName())
+        self.assertTrue(m.isEqual(mo2,1e-12))
+        #
+        mp0=m[[0]] ; mp0.zipCoords() ; mp1=m[2] ; mp1.zipCoords() ; mp2=m[4] ; mp2.zipCoords()
+        mo3=MEDCoupling1SGTUMesh.Merge1SGTUMeshes([mp0,mp1,mp2])
+        self.assertTrue(isinstance(mo3,MEDCoupling1SGTUMesh))
+        mo3.setName(m.getName())
+        m_ref=m[(0,2,4)] ; m_ref.zipCoords()
+        m_ref.tryToShareSameCoordsPermute(mo3,1e-12)
+        self.assertTrue(m_ref.isEqual(mo3,1e-12))
+        #
+        m1=um.buildDescendingConnectivity()[0]
+        ids=m1.getCellIdsFullyIncludedInNodeIds(DataArrayInt.Range(0,12,1))
+        m1=m1[ids]
+        m1c=m1.convertIntoSingleGeoTypeMesh()
+        self.assertTrue(isinstance(m1c,MEDCoupling1SGTUMesh))
+        self.assertEqual(m1c.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
+        m1c.checkCoherency2()
+        self.assertTrue(m1c.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11])))
+        self.assertEqual(20,m1c.getNodalConnectivityLength())
+        self.assertTrue(m.isEqual(m1c,1e-12))
+        m.getNodalConnectivity().setIJ(1,0,1)
+        self.assertTrue(not m.isEqual(m1c,1e-12))
+        m.getNodalConnectivity().setIJ(1,0,0)
+        self.assertTrue(m.isEqual(m1c,1e-12))
+        m1c.setCoords(m.getCoords().deepCpy())
+        self.assertTrue(m.isEqual(m1c,1e-12))
+        m1c.getCoords().setIJ(0,1,0.1)
+        self.assertTrue(not m.isEqual(m1c,1e-12))
+        m1c.getCoords().setIJ(0,1,0)
+        self.assertTrue(m.isEqual(m1c,1e-12))
+        m1c.getCoords().setInfoOnComponent(1,"X")
+        self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
+        m.getCoords().setInfoOnComponent(1,"X")
+        self.assertTrue(m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
+        m.setName("m2")
+        self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
+        #
+        m.checkCoherency() ; m.checkCoherency1() ; m.checkCoherency2()
+        self.assertEqual(m.getMeshDimension(),2)
+        self.assertTrue(m.giveCellsWithType(NORM_QUAD4).isEqual(DataArrayInt([0,1,2,3,4])))
+        self.assertTrue(m.giveCellsWithType(NORM_TRI3).isEqual(DataArrayInt([])))
+        self.assertEqual(m.getNumberOfCellsWithType(NORM_QUAD4),5)
+        self.assertEqual(m.getNumberOfCellsWithType(NORM_TRI3),0)
+        self.assertEqual(m.getTypeOfCell(3),NORM_QUAD4)
+        self.assertRaises(InterpKernelException,m.getTypeOfCell,5)
+        self.assertEqual(m.getAllGeoTypes(),[NORM_QUAD4])
+        self.assertEqual(m.getDistributionOfTypes(),[[NORM_QUAD4,5,-1]])
+        ##
+        pfl1=DataArrayInt([1,3,4])
+        a,b,c=m.splitProfilePerType(pfl1)
+        d,e,f=m.buildUnstructured().splitProfilePerType(pfl1)
+        self.assertTrue(a==[[4,3,0]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2])) and len(c)==1 and c[0].getHiddenCppPointer()==pfl1.getHiddenCppPointer())
+        self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
+        #
+        pfl2=DataArrayInt([0,1,2,3])
+        a,b,c=m.splitProfilePerType(pfl2)
+        d,e,f=m.buildUnstructured().splitProfilePerType(pfl2)
+        self.assertTrue(a==[[4,4,0]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2,3])) and len(c)==1 and c[0].getHiddenCppPointer()==pfl2.getHiddenCppPointer())
+        self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
+        #
+        pfl3=DataArrayInt([0,1,2,3,4])
+        a,b,c=m.splitProfilePerType(pfl3)
+        d,e,f=m.buildUnstructured().splitProfilePerType(pfl3)
+        self.assertTrue(a==[[4,5,-1]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2,3,4])) and c==[])
+        self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and c==[])
+        #
+        invalidPfl=DataArrayInt([1,2,3,4,5])
+        self.assertRaises(InterpKernelException,m.splitProfilePerType,invalidPfl)
+        self.assertRaises(InterpKernelException,m.buildUnstructured().splitProfilePerType,invalidPfl)
+        ##
+        pfl1=DataArrayInt([1,2,3])
+        a=m.checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
+        b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
+        self.assertTrue(a.isEqual(b) and pfl1.getHiddenCppPointer(),a.getHiddenCppPointer())
+        #
+        pfl2=DataArrayInt([0,1,2,3])
+        a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
+        b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
+        self.assertTrue(a.isEqual(b) and pfl2.getHiddenCppPointer()==a.getHiddenCppPointer())
+        #
+        pfl3=DataArrayInt([0,1,2,3,4])
+        a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl3])
+        b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,5,0],[pfl3])
+        self.assertTrue(a.isEqual(b) and pfl3.getHiddenCppPointer()==a.getHiddenCppPointer())
+        #
+        invalidPfl=DataArrayInt([1,2,3,4,5])
+        self.assertRaises(InterpKernelException,m.checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
+        self.assertRaises(InterpKernelException,m.buildUnstructured().checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
+        ##
+        self.assertTrue(DataArrayInt([4,4,4,4,4]).isEqual(m.computeNbOfNodesPerCell()))
+        ##
+        self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8])
+        ##
+        self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(DataArrayDouble([(0.5,0.5,0),(1.5,0.5,0),(2.5,0.5,0),(3.5,0.5,0),(4.5,0.5,0)]),1e-13))
+        ##
+        ref=m.getCoords().getHiddenCppPointer()
+        mcpy=m.deepCpy() ; mcpy.insertNextCell([1,0,6,7])
+        c=m.getNodalConnectivity().deepCpy()
+        o2n=DataArrayInt([2,0,1,4,3])
+        m.renumberCells(o2n,False)
+        c.rearrange(4) ; c.renumberInPlace(o2n) ; c.rearrange(1)
+        self.assertTrue(c.isEqual(m.getNodalConnectivity()))
+        self.assertEqual(ref,m.getCoords().getHiddenCppPointer())
+        m2=mcpy.mergeMyselfWith(m)
+        self.assertTrue(isinstance(m2,MEDCoupling1SGTUMesh))
+        self.assertEqual(11,m2.getNumberOfCells())
+        self.assertEqual(48,m2.getNumberOfNodes())
+        self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.Aggregate([m.getCoords(),m.getCoords()]),1e-12))
+        self.assertTrue(m2.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11,1,0,6,7,26,25,31,32,27,26,32,33,25,24,30,31,29,28,34,35,28,27,33,34])))
+        ##
+        mu=m.buildUnstructured()
+        mu.checkCoherency2()
+        self.assertEqual(mu.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
+        self.assertEqual(2,mu.getMeshDimension())
+        self.assertEqual([NORM_QUAD4],mu.getAllGeoTypes())
+        self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([4,2,1,7,8,4,3,2,8,9,4,1,0,6,7,4,5,4,10,11,4,4,3,9,10])))
+        self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25])))
+        ##
+        for typ in [0,1]:
+            mcpy2=m.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
+            ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
+            self.assertTrue(ids.isEqual(ids2))
+            mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
+            self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
+            pass
+        um1=um.convertIntoSingleGeoTypeMesh()
+        self.assertEqual(8,um1.getNumberOfNodesPerCell())
+        for typ in [PLANAR_FACE_5,PLANAR_FACE_6]:
+            mcpy2=um1.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
+            ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
+            self.assertTrue(ids.isEqual(ids2))
+            mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
+            self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
+            pass
+        ##
+        self.assertRaises(InterpKernelException,mcpy.mergeMyselfWithOnSameCoords,m)
+        mcpy.tryToShareSameCoords(m,1e-14)
+        m3=mcpy.mergeMyselfWithOnSameCoords(m)
+        self.assertTrue(isinstance(m3,MEDCoupling1SGTUMesh))
+        self.assertEqual(11,m3.getNumberOfCells())
+        self.assertEqual(24,m3.getNumberOfNodes())
+        self.assertEqual(m3.getCoords().getHiddenCppPointer(),mcpy.getCoords().getHiddenCppPointer())
+        self.assertTrue(m3.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11,1,0,6,7,2,1,7,8,3,2,8,9,1,0,6,7,5,4,10,11,4,3,9,10])))
+        ##
+        ref=mcpy.getCoords().deepCpy()
+        c3=mcpy.getNodalConnectivity()[:]
+        mcpy.getNodalConnectivity().setIJ(int(c3.getIdsEqual(11)),0,24)
+        c2=DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()[11:]])
+        mcpy.setCoords(c2)
+        mcpy.checkCoherency2()
+        a,b=mcpy.getNodeIdsInUse()
+        self.assertEqual(12,b)
+        self.assertTrue(a.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,11,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1])))
+        ids=mcpy.zipCoordsTraducer()
+        self.assertTrue(ids.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,11,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1])))
+        self.assertTrue(mcpy.getCoords().isEqual(ref[:12],1e-12))
+        self.assertTrue(mcpy.getNodalConnectivity().isEqual(c3))
+        mcpy.checkCoherency2()
+        ##
+        m4=mcpy[DataArrayInt([0,3,4])]
+        m5=mcpy.buildPartOfMySelfKeepCoords(DataArrayInt([0,3,4]))
+        self.assertTrue(isinstance(m4,MEDCoupling1SGTUMesh))
+        self.assertTrue(m4.isEqual(m5,-1e-14))# < 0 not a bug it proves that coordinates pointer are equal
+        self.assertTrue(m4.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,4,3,9,10,5,4,10,11])))
+        m6=mcpy[::2]
+        self.assertTrue(isinstance(m6,MEDCoupling1SGTUMesh))
+        self.assertTrue(m6.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,3,2,8,9,5,4,10,11])))
+        ##
+        mcpy.setCoords(DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()]))
+        mcpy.checkCoherency2()
+        ##
+        mcppy=mcpy.deepCpyConnectivityOnly()
+        self.assertTrue(mcppy.isEqual(mcpy,1e-12))
+        self.assertTrue(mcppy.getCoords().getHiddenCppPointer()==mcpy.getCoords().getHiddenCppPointer())
+        self.assertTrue(mcppy.getNodalConnectivity().isEqual(mcpy.getNodalConnectivity()))
+        self.assertTrue(mcppy.getNodalConnectivity().getHiddenCppPointer()!=mcpy.getNodalConnectivity().getHiddenCppPointer())
+        ##
+        a,b=mcpy.getReverseNodalConnectivity()
+        self.assertTrue(a.isEqual(DataArrayInt([0,5,0,1,5,1,2,2,3,3,4,4,0,5,0,1,5,1,2,2,3,3,4,4])))
+        self.assertTrue(b.isEqual(DataArrayInt([0,2,5,7,9,11,12,14,17,19,21,23,24,24,24,24,24,24,24,24,24,24,24,24,24])))
+        self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],False).isEqual(DataArrayInt([0,1,5])))
+        self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,5])))
+        self.assertTrue(mcpy.getCellsInBoundingBox([(0,1),(0,1),(0,1)],1e-12).isEqual(DataArrayInt([0,1,5])))
+        f=mcpy.buildOrthogonalField()
+        self.assertEqual(f.getMesh().getHiddenCppPointer(),mcpy.getHiddenCppPointer())
+        self.assertTrue(f.getArray().isEqual(DataArrayDouble(6*[(0,0,-1)]),1e-12))
+        mcpy.changeSpaceDimension(2)
+        self.assertEqual(1,mcpy.getCellContainingPoint([1.5,0.5],1e-12))
+        ##
+        self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([0,1,5])))
+        ##
+        mcpy2=mcpy.deepCpy()
+        self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
+        mcpy.checkFastEquivalWith(mcpy2,1e-12)
+        mcpy2.renumberCells([0,2,4,3,1,5])
+        mcpy.checkFastEquivalWith(mcpy2,1e-12)
+        self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
+        mcpy2.renumberCells([0,2,4,3,1,5])
+        mcpy2.renumberCells([1,3,5,0,2,4])
+        self.assertRaises(InterpKernelException,mcpy.checkFastEquivalWith,mcpy2,1e-12)
+        self.assertRaises(InterpKernelException,mcpy.checkGeoEquivalWith,mcpy2,1,1e-12)#fast equal
+        pass
+
+    def testSwig21DGTUMesh1(self):
+        a0=DataArrayInt([0,2,3,5,6,8])
+        a1=DataArrayInt([0,4,7,11,14,18,21,25])
+        a2=DataArrayInt([0,1,4,5])
+        self.assertTrue(DataArrayInt.AggregateIndexes([a0,a1,a2]).isEqual(DataArrayInt([0,2,3,5,6,8,12,15,19,22,26,29,33,34,37,38])))
+        self.assertEqual(a1[3:].front(),11)
+        self.assertEqual(a1[4:].convertToDblArr().front(),14.)
+        a1c=DataArrayInt([5,7,1,2, 8,11,0, 5,6,3,12, 1,5,2, 13,12,11,7, 6,1,0, 20,21,19,17])
+        d,e=MEDCouplingUMesh.ExtractFromIndexedArrays2(1,5,2,a1c,a1)
+        self.assertTrue(d.isEqual(DataArrayInt([8,11,0,1,5,2])))
+        self.assertTrue(e.isEqual(DataArrayInt([0,3,6])))
+        #
+        m=MEDCouplingDataForTest.build2DTargetMesh_1()[0,3,4]
+        ref=DataArrayInt([0,3,4,1,6,7,4,3,7,8,5,4])
+        self.assertTrue(m.convertNodalConnectivityToStaticGeoTypeMesh().isEqual(ref))
+        d,e=m.convertNodalConnectivityToDynamicGeoTypeMesh()
+        self.assertTrue(d.isEqual(ref))
+        self.assertTrue(e.isEqual(DataArrayInt.Range(0,13,4)))
+        self.assertTrue(m.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([1,2])))
+        #
+        m=MEDCoupling1GTUMesh.New("m",NORM_POLYHED)
+        self.assertTrue(isinstance(m,MEDCoupling1DGTUMesh))
+        m.__repr__() ; m.__str__()
+        m.setCoords(DataArrayDouble(20,3))
+        m.allocateCells()
+        m.__repr__() ; m.__str__()
+        m.insertNextCell([0,1,2,5,7,2,-1,1,3])
+        self.assertEqual(1,m.getNumberOfCells())
+        self.assertTrue(DataArrayInt([8]).isEqual(m.computeNbOfNodesPerCell()))
+        self.assertTrue(DataArrayInt([2]).isEqual(m.computeNbOfFacesPerCell()))
+        m.__repr__() ; m.__str__()
+        m.checkCoherency()
+        m.checkCoherency2()
+        #
+        cm=MEDCouplingCMesh() ; cm.setName("m")
+        arr0=DataArrayDouble(6) ; arr0.iota()
+        arr1=DataArrayDouble([0,1])
+        cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured() ; um.convertAllToPoly()
+        um2=um.deepCpyConnectivityOnly()
+        self.assertTrue(um2.isEqual(um,1e-12))
+        self.assertEqual(um2.getCoords().getHiddenCppPointer(),um.getCoords().getHiddenCppPointer())
+        self.assertTrue(um2.getNodalConnectivity().isEqual(um.getNodalConnectivity()))
+        self.assertTrue(um2.getNodalConnectivity().getHiddenCppPointer()!=um.getNodalConnectivity().getHiddenCppPointer())
+        self.assertTrue(um2.getNodalConnectivityIndex().isEqual(um.getNodalConnectivityIndex()))
+        self.assertTrue(um2.getNodalConnectivityIndex().getHiddenCppPointer()!=um.getNodalConnectivityIndex().getHiddenCppPointer())
+        #
+        self.assertRaises(InterpKernelException,MEDCoupling1SGTUMesh.New,"m",NORM_POLYHED)
+        m=MEDCoupling1DGTUMesh("m",NORM_POLYHED)
+        m.allocateCells(5)
+        self.assertEqual(15,m.getNodalConnectivity().getNbOfElemAllocated())
+        self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
+        m.setCoords(um.getCoords())
+        m.insertNextCell([1,0,6,7,-1,7,6,1])
+        self.assertEqual(1,m.getNumberOfCells())
+        m.insertNextCell([2,1,7,8,-1,2,1,-1,8,-1,7])
+        m.insertNextCell([3,2,8,9])
+        m.insertNextCell([4,3,9,10,-1,5,3,9])
+        m.insertNextCell([5,4,10,11,-1,11,10,-1,5])
+        m.checkCoherency()
+        m.checkCoherency2()
+        self.assertEqual(5,m.getNumberOfCells())
+        self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40])))
+        self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5])))
+        #
+        m4=m.deepCpy()
+        self.assertTrue(m.isEqual(m4,1e-12))
+        m4.getNodalConnectivity().setIJ(2,0,5)
+        self.assertTrue(not m.isEqual(m4,1e-12))
+        m4.getNodalConnectivity().setIJ(2,0,6)
+        self.assertTrue(m.isEqual(m4,1e-12))
+        m4.getNodalConnectivityIndex().setIJ(2,0,21)
+        self.assertTrue(not m.isEqual(m4,1e-12))
+        m4.getNodalConnectivityIndex().setIJ(2,0,19)
+        self.assertTrue(m.isEqual(m4,1e-12))
+        m4.getCoords().setIJ(10,1,1.1)
+        self.assertTrue(not m.isEqual(m4,1e-12))
+        m4.getCoords().setIJ(10,1,1.)
+        self.assertTrue(m.isEqual(m4,1e-12))
+        m4.getNodalConnectivity().pushBackSilent(7)
+        self.assertTrue(not m.isEqual(m4,1e-12))
+        self.assertEqual(7,m4.getNodalConnectivity().popBackSilent())
+        self.assertTrue(m.isEqual(m4,1e-12))
+        m4.setName("m4")
+        self.assertTrue(not m.isEqual(m4,1e-12))
+        m4.setName("m")
+        self.assertTrue(m.isEqual(m4,1e-12))
+        #
+        self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
+        self.assertEqual(60,m.getNodalConnectivity().getNbOfElemAllocated())
+        self.assertTrue(m.computeNbOfNodesPerCell().isEqual(DataArrayInt([7,8,4,7,7])))
+        self.assertTrue(m.computeNbOfFacesPerCell().isEqual(DataArrayInt([2,4,1,2,3])))
+        self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8,-1,2,1,-1,8,-1,7])
+        f=m.computeIsoBarycenterOfNodesPerCell()
+        self.assertTrue(DataArrayDouble([(0.5714285714285714,0.5714285714285714,0),(1.5,0.5,0),(2.5,0.5,0),(3.5714285714285712,0.42857142857142855,0),(4.5714285714285712,0.5714285714285714,0)]).isEqual(f,1e-14))
+        mu0=m.buildUnstructured()
+        o2n=[1,2,0,4,3]
+        m2=m.deepCpy()
+        m3=m.deepCpyConnectivityOnly()
+        self.assertTrue(m3.isEqual(m,1e-12))
+        self.assertEqual(m3.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
+        self.assertTrue(m3.getNodalConnectivity().getHiddenCppPointer()!=m.getNodalConnectivity().getHiddenCppPointer())
+        self.assertTrue(m3.getNodalConnectivity().isEqual(m.getNodalConnectivity()))
+        self.assertTrue(m3.getNodalConnectivityIndex().getHiddenCppPointer()!=m.getNodalConnectivityIndex().getHiddenCppPointer())
+        self.assertTrue(m3.getNodalConnectivityIndex().isEqual(m.getNodalConnectivityIndex()))
+        m.renumberCells(o2n)
+        mu0.renumberCells(o2n)
+        self.assertTrue(mu0.isEqual(m.buildUnstructured(),1e-12))
+        self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,12,23,32,40])))
+        self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,2,8,9,1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,5,4,10,11,-1,11,10,-1,5,4,3,9,10,-1,5,3,9])))
+        #
+        mcpy0=m.buildUnstructured()
+        self.assertTrue(isinstance(mcpy0,MEDCouplingUMesh))
+        self.assertTrue(mcpy0.getNodalConnectivity().isEqual(DataArrayInt([31,3,2,8,9,31,1,0,6,7,-1,7,6,1,31,2,1,7,8,-1,2,1,-1,8,-1,7,31,5,4,10,11,-1,11,10,-1,5,31,4,3,9,10,-1,5,3,9])))
+        self.assertTrue(mcpy0.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,14,26,36,45])))
+        self.assertEqual(mcpy0.getAllTypes(),[NORM_POLYHED])
+        mcpy0.checkCoherency()
+        mcpy0.checkCoherency2()
+        mcpy1=mcpy0.convertIntoSingleGeoTypeMesh()
+        self.assertTrue(mcpy1.isEqual(m,1e-12))
+        #
+        m_mrg=MEDCoupling1DGTUMesh.Merge1DGTUMeshes([m2,m,m2])
+        self.assertTrue(m_mrg.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
+        self.assertTrue(m_mrg.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5,27,26,32,33,25,24,30,31,-1,31,30,25,26,25,31,32,-1,26,25,-1,32,-1,31,29,28,34,35,-1,35,34,-1,29,28,27,33,34,-1,29,27,33,49,48,54,55,-1,55,54,49,50,49,55,56,-1,50,49,-1,56,-1,55,51,50,56,57,52,51,57,58,-1,53,51,57,53,52,58,59,-1,59,58,-1,53])))
+        m_mrg2=MEDCoupling1DGTUMesh.Merge1DGTUMeshesOnSameCoords([m3,m,m3])
+        self.assertTrue(m_mrg2.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
+        self.assertTrue(m_mrg2.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5,3,2,8,9,1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,5,4,10,11,-1,11,10,-1,5,4,3,9,10,-1,5,3,9,1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5])))
+        a,b=m_mrg2.getReverseNodalConnectivity()
+        self.assertTrue(b.isEqual(DataArrayInt([0,3,15,24,33,39,48,54,66,75,84,93,99,99,99,99,99,99,99,99,99,99,99,99,99])))
+        self.assertTrue(a.isEqual(DataArrayInt([0,6,10,0,0,1,1,6,6,7,7,10,10,11,11,1,1,2,5,7,7,11,11,12,2,3,3,5,9,9,12,13,13,3,4,8,9,13,14,3,4,4,8,8,9,13,14,14,0,0,6,6,10,10,0,0,1,1,6,6,7,7,10,10,11,11,1,1,2,5,7,7,11,11,12,2,3,3,5,9,9,12,13,13,3,4,4,8,8,9,13,14,14,4,4,8,8,14,14])))
+        self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([7],False).isEqual(DataArrayInt([0,1,6,7,10,11])))
+        self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,6,10])))
+        #
+        self.assertTrue(m_mrg2.isPacked())
+        self.assertEqual(120,m_mrg2.getNodalConnectivityIndex().popBackSilent())
+        self.assertEqual(m_mrg2.getNumberOfCells(),14)
+        m_mrg2.checkCoherency2()
+        self.assertTrue(not m_mrg2.isPacked())
+        m_mrg4,b=m_mrg2.copyWithNodalConnectivityPacked()
+        self.assertTrue(not b)
+        m_mrg4.checkCoherency2()
+        self.assertEqual(m_mrg4.getNumberOfCells(),14)
+        self.assertTrue(m_mrg4.getNodalConnectivityIndex().isEqual(m_mrg2.getNodalConnectivityIndex()))
+        self.assertEqual(len(m_mrg4.getNodalConnectivity()),111)
+        self.assertEqual(len(m_mrg2.getNodalConnectivity()),120)
+        self.assertTrue(m_mrg4.getNodalConnectivity().isEqual(m_mrg2.getNodalConnectivity()[:111]))
+        #
+        m0=m_mrg2[:5]
+        m1=m_mrg2[[5,6,7,8,9]]
+        m2=m_mrg2[10:]
+        self.assertTrue(m1.isEqualWithoutConsideringStr(m,1e-12))
+        a,b=m.checkGeoEquivalWith(m0,12,1e-12)
+        self.assertTrue(a.isEqual(DataArrayInt(o2n)))
+        self.assertTrue(b is None)
+        pass
+
+    def testSwig2DADAreIncludedInMe1(self):
+        a=DataArrayDouble(30) ; a.iota() ; a.rearrange(3)
+        p=DataArrayInt([5,2,1,9])
+        b,c=a.areIncludedInMe(a[p],1e-12)
+        self.assertTrue(b)
+        self.assertTrue(c.isEqual(p))
+        d=a[p]
+        d.setIJ(3,1,28.1)
+        b,c=a.areIncludedInMe(d,1e-12)
+        self.assertTrue(not b)
+        self.assertTrue(c.isEqual(DataArrayInt([5,2,1,10])))
+        pass
+
+    def testSwig2DADesallocate1(self):
+        d=DataArrayDouble([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
+        self.assertTrue(d.isAllocated())
+        d.checkAllocated()
+        self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
+        ref=d.getHeapMemorySize()
+        d.desallocate()
+        self.assertEqual(ref-d.getHeapMemorySize(),6*8)
+        self.assertTrue(not d.isAllocated())
+        self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
+        self.assertRaises(InterpKernelException,d.checkAllocated)
+        #
+        d=DataArrayInt([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
+        self.assertTrue(d.isAllocated())
+        d.checkAllocated()
+        self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
+        ref=d.getHeapMemorySize()
+        d.desallocate()
+        self.assertEqual(ref-d.getHeapMemorySize(),6*4)
+        self.assertTrue(not d.isAllocated())
+        self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
+        self.assertRaises(InterpKernelException,d.checkAllocated)
+        pass
+
     def setUp(self):
         pass
     pass