Make joints easy to use with python

[tools/medcoupling.git] / src / MEDLoader / Swig / MEDLoaderTest3.py

diff --git a/src/MEDLoader/Swig/MEDLoaderTest3.py b/src/MEDLoader/Swig/MEDLoaderTest3.py
index f84a7cfcd9da4dc243ffa82527fe2c3754ef3b95..55fd117f1498925885467cdc0a8710660c16c6fe 100644 (file)
--- a/src/MEDLoader/Swig/MEDLoaderTest3.py
+++ b/src/MEDLoader/Swig/MEDLoaderTest3.py
@@ -3078,7 +3078,7 @@ class MEDLoaderTest3(unittest.TestCase):
         self.assertTrue(not ff0.getUndergroundDataArray().isAllocated())
         self.assertEqual(ff0.getUndergroundDataArray().getInfoOnComponents(),['X [km]','YY [mm]'])
         heap_memory_ref=ff0.getHeapMemorySize()
-        self.assertIn(heap_memory_ref,xrange(182,465+2*strMulFac))
+        self.assertIn(heap_memory_ref,xrange(182,481+2*strMulFac))
         ff0.loadArrays() ##
         arr=DataArrayDouble(140) ; arr.iota() ; arr.rearrange(2)
         self.assertTrue(ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14))
@@ -3087,7 +3087,7 @@ class MEDLoaderTest3(unittest.TestCase):
         ff0=MEDFileField1TS(fname,"FieldCellPfl",False)
         self.assertEqual(ff0.getUndergroundDataArray().getInfoOnComponents(),["XX [pm]","YYY [hm]"])
         heap_memory_ref=ff0.getHeapMemorySize()
-        self.assertIn(heap_memory_ref,xrange(350,520+6*strMulFac))
+        self.assertIn(heap_memory_ref,xrange(350,536+6*strMulFac))
         ff0.loadArrays() ##
         arr=DataArrayDouble(100) ; arr.iota() ; arr.rearrange(2)
         self.assertTrue(ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14))
@@ -3105,7 +3105,7 @@ class MEDLoaderTest3(unittest.TestCase):
         self.assertEqual(ff0.getUndergroundDataArray().getIJ(30,1),5.5)
         self.assertTrue(not ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14))
         heap_memory_ref=ff0.getHeapMemorySize()
-        self.assertIn(heap_memory_ref,xrange(1100,1384+2*strMulFac))
+        self.assertIn(heap_memory_ref,xrange(1100,1400+2*strMulFac))
         ff0.unloadArrays()
         hmd=ff0.getHeapMemorySize()-heap_memory_ref
         self.assertEqual(hmd,-800) # -50*8*2
@@ -3114,7 +3114,7 @@ class MEDLoaderTest3(unittest.TestCase):
         #
         ff0=MEDFileField1TS(fname,"FieldCellPfl",-1,-1,False)
         heap_memory_ref=ff0.getHeapMemorySize()
-        self.assertIn(heap_memory_ref,xrange(299,520+6*strMulFac))
+        self.assertIn(heap_memory_ref,xrange(299,536+6*strMulFac))
         ff0.loadArrays() ##
         self.assertTrue(ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14))
         self.assertEqual(ff0.getHeapMemorySize()-heap_memory_ref,50*8*2)
@@ -3131,14 +3131,14 @@ class MEDLoaderTest3(unittest.TestCase):
         #
         ff0=MEDFileAnyTypeFieldMultiTS.New(fname,fieldName,False)
         heap_memory_ref=ff0.getHeapMemorySize()
-        self.assertIn(heap_memory_ref,xrange(5536,8212+(80+26)*strMulFac))
+        self.assertIn(heap_memory_ref,xrange(5536,10242+(80+26+1)*strMulFac))
         ff0.loadArrays()
         self.assertEqual(ff0.getHeapMemorySize()-heap_memory_ref,20*70*8*2)
         del ff0
         #
         ffs=MEDFileFields(fname,False)
         heap_memory_ref=ffs.getHeapMemorySize()
-        self.assertIn(heap_memory_ref,xrange(5335,9031+(80+50)*strMulFac))
+        self.assertIn(heap_memory_ref,xrange(5335,11507+(80+50+len(ffs))*strMulFac))
         ffs.loadArrays()
         self.assertEqual(ffs.getHeapMemorySize()-heap_memory_ref,20*70*8*2+70*8*2+50*8*2)
         pass
@@ -5911,6 +5911,78 @@ class MEDLoaderTest3(unittest.TestCase):
             self.assertTrue(params[i].isEqual(params7[i],1e-12)[0])
             pass
         pass
+
+    def testGlobalNumOnNodes1(self):
+        """Test global number on nodes here. Used by partitionners."""
+        fname="Pyfile112.med"
+        arr=DataArrayDouble(5) ; arr.iota()
+        m=MEDCouplingUMesh.Build1DMeshFromCoords(arr)
+        m.setName("mesh")
+        mm=MEDFileUMesh()
+        mm[0]=m
+        self.assertTrue(not mm.getGlobalNumFieldAtLevel(1))
+        d=DataArrayInt([7,8,9,2,0])
+        dRef=d.deepCopy()
+        mm.setGlobalNumFieldAtLevel(1,d)
+        mm.checkConsistency()
+        self.assertRaises(InterpKernelException,mm.setGlobalNumFieldAtLevel,1,d[::2])
+        mm.checkConsistency()
+        self.assertEqual(d.getHiddenCppPointer(),mm.getGlobalNumFieldAtLevel(1).getHiddenCppPointer())
+        self.assertTrue(mm.getGlobalNumFieldAtLevel(1).isEqual(dRef))
+        mm.write(fname,2)
+        mm2=MEDFileMesh.New(fname)
+        self.assertTrue(mm.isEqual(mm2,1e-12)[0])
+        self.assertTrue(mm2.getGlobalNumFieldAtLevel(1).isEqual(dRef))
+        mm2.getGlobalNumFieldAtLevel(1).setIJ(0,0,10)
+        self.assertTrue(not mm.isEqual(mm2,1e-12)[0])
+        mm2.getGlobalNumFieldAtLevel(1).setIJ(0,0,7)
+        self.assertTrue(mm.isEqual(mm2,1e-12)[0])
+        pass
+
+    def testPartialReadOfEntities1(self):
+        """Test for advanced API on read to speed up read phase for users with "huge" number of time steps (more than 10 000)."""
+        fname="Pyfile113.med"
+        arr=DataArrayDouble(5) ; arr.iota()
+        m=MEDCouplingUMesh.Build1DMeshFromCoords(arr)
+        m.setName("mesh")
+        mm=MEDFileUMesh()
+        mm[0]=m
+        #
+        fieldName="Field"
+        ts1=(5.,1,2)
+        f1=MEDCouplingFieldDouble(ON_NODES) ; f1.setMesh(m) ; f1.setName(fieldName)
+        f1.setArray(DataArrayDouble([0.,0.1,0.2,0.3,0.4]))
+        f1.setTime(*ts1)
+        f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setMesh(m) ; f2.setName(fieldName)
+        f2.setArray(DataArrayDouble([1.,1.1,1.2,1.3]))
+        f2.setTime(*ts1)
+        f1ts=MEDFileField1TS()
+        f1ts.setFieldNoProfileSBT(f1)
+        f1ts.setFieldNoProfileSBT(f2)
+        self.assertEqual(set(f1ts.getTypesOfFieldAvailable()),set([ON_NODES,ON_CELLS]))
+        f1ts_2=f1ts.deepCopy()
+        f1ts_2.getUndergroundDataArray()[:]+=2
+        f1ts_2.setTime(3,4,6.)
+        fmts=MEDFileFieldMultiTS()
+        fmts.pushBackTimeStep(f1ts)
+        fmts.pushBackTimeStep(f1ts_2)
+        #
+        mm.write(fname,2)
+        fmts.write(fname,0)
+        #
+        ent=MEDFileEntities.BuildFrom([(ON_NODES,NORM_ERROR)])
+        mm=MEDFileMesh.New(fname)
+        fs=MEDFileFields(fname,False,ent) # the important line is here - We specify to MEDFileFields to read only nodes part to speed up read phase (by avoiding to scan all entities time geo types)
+        fs.loadArrays()
+        self.assertEqual(len(fs),1)
+        fmts=fs[0]
+        self.assertEqual(len(fmts),2)
+        ff0=fmts[0] ; ff1=fmts[1]
+        self.assertEqual(ff0.getTypesOfFieldAvailable(),[ON_NODES]) # only NODES have been loaded
+        self.assertTrue(ff0.field(mm).isEqual(f1,1e-12,1e-12))
+        f3=f1.deepCopy() ; f3+=2. ; f3.setTime(6.,3,4)
+        self.assertTrue(ff1.field(mm).isEqual(f3,1e-12,1e-12))
+        pass
     
     pass