src/MEDCoupling_Swig/MEDCouplingPickleTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2019  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21
  22 import sys
  23 if sys.platform == "win32":
  24     from MEDCouplingCompat import *
  25 else:
  26     from medcoupling import *
  27 from MEDCouplingDataForTest import MEDCouplingDataForTest
  28
  29 if MEDCouplingHasNumPyBindings():
  30     from numpy import *
  31     pass
  32
  33 from platform import architecture
  34 from sys import getrefcount
  35
  36 import os, gc, weakref, unittest
  37 import sys
  38 if sys.version_info.major < 3:
  39   import cPickle as pickle
  40 else:
  41   import pickle
  42
  43 class MEDCouplingPickleTest(unittest.TestCase):
  44     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
  45     def test1(self):
  46         """ Test of a simple DataArrayDouble."""
  47         x=DataArrayDouble(10,1) ; x.iota() ; x.rearrange(2) ; x.setInfoOnComponents(["aa","bbb"])
  48         x.setName("toto")
  49         pickled=pickle.dumps(x,pickle.HIGHEST_PROTOCOL)
  50         xx=pickle.loads(pickled)
  51         self.assertTrue(xx.isEqual(x,1e-16))
  52         # Bigger to check that the behavior is OK for large strings.
  53         x=DataArrayDouble(1200) ; x.iota() ; x.setInfoOnComponents(["aa"])
  54         x.setName("titi")
  55         pickled=pickle.dumps(x,pickle.HIGHEST_PROTOCOL)
  56         xx=pickle.loads(pickled)
  57         self.assertTrue(xx.isEqual(x,1e-16))
  58         pass
  59
  60     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
  61     def test2(self):
  62         """ Test of a simple DataArrayInt."""
  63         x=DataArrayInt(10) ; x.iota() ; x.rearrange(2) ; x.setInfoOnComponents(["aa","bbb"])
  64         x.setName("toto")
  65         pickled=pickle.dumps(x,pickle.HIGHEST_PROTOCOL)
  66         xx=pickle.loads(pickled)
  67         self.assertTrue(xx.isEqual(x))
  68         # Bigger to check that the behavior is OK for large strings.
  69         x=DataArrayInt(1200) ; x.iota() ; x.setInfoOnComponents(["aa"])
  70         x.setName("titi")
  71         pickled=pickle.dumps(x,pickle.HIGHEST_PROTOCOL)
  72         xx=pickle.loads(pickled)
  73         self.assertTrue(xx.isEqual(x))
  74         pass
  75
  76     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
  77     def test3(self):
  78         """ Test of a MEDCouplingUMesh pickeling."""
  79         arr=DataArrayDouble(10) ; arr.iota()
  80         m=MEDCouplingCMesh() ; m.setCoords(arr,arr,arr)
  81         m=m.buildUnstructured()
  82         m.setName("mesh")
  83         m.getCoords().setInfoOnComponents(["aa","bbb","ddddd"])
  84         m.checkConsistencyLight()
  85         st=pickle.dumps(m,pickle.HIGHEST_PROTOCOL)
  86         m2=pickle.loads(st)
  87         self.assertTrue(m2.isEqual(m,1e-16))
  88         pass
  89
  90     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
  91     def test4(self):
  92         """ Idem test3 except that here serialization/deserialization is done explicitly."""
  93         arr=DataArrayDouble(10) ; arr.iota()
  94         m=MEDCouplingCMesh() ; m.setCoords(arr,arr,arr)
  95         m=m.buildUnstructured()
  96         m.setName("mesh")
  97         m.getCoords().setInfoOnComponents(["aa","bbb","ddddd"])
  98         m.checkConsistencyLight()
  99         #
 100         a0,a1,a2=m.getTinySerializationInformation()
 101         b0,b1=m.serialize()
 102         m2=MEDCouplingUMesh()
 103         m2.unserialization(a0,a1,b0,b1,a2);
 104         self.assertTrue(m2.isEqual(m,1e-16))
 105         pass
 106
 107     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 108     def test5(self):
 109         """ Test of a MEDCouplingCMesh pickeling."""
 110         arrX=DataArrayDouble(10) ; arrX.iota() ; arrX.setInfoOnComponents(["aa"])
 111         arrY=DataArrayDouble(5) ; arrY.iota() ; arrY.setInfoOnComponents(["bbb"])
 112         arrZ=DataArrayDouble(7) ; arrZ.iota() ; arrZ.setInfoOnComponents(["cccc"])
 113         #
 114         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ)
 115         m.setName("mesh")
 116         m.checkConsistencyLight()
 117         st=pickle.dumps(m,pickle.HIGHEST_PROTOCOL)
 118         m2=pickle.loads(st)
 119         self.assertTrue(m2.isEqual(m,1e-16))
 120         self.assertTrue(m2.getCoordsAt(0).isEqual(arrX,1e-16))
 121         pass
 122
 123     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 124     def test6(self):
 125         """ Test of a MEDCoupling1SGTUMesh pickeling."""
 126         arr=DataArrayDouble(10) ; arr.iota()
 127         m=MEDCouplingCMesh() ; m.setCoords(arr,arr)
 128         m=m.build1SGTUnstructured()
 129         self.assertTrue(isinstance(m,MEDCoupling1SGTUMesh))
 130         st=pickle.dumps(m,pickle.HIGHEST_PROTOCOL)
 131         m2=pickle.loads(st)
 132         self.assertTrue(m2.isEqual(m,1e-16))
 133         pass
 134
 135     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 136     def test7(self):
 137         """ Test of a MEDCoupling1DGTUMesh pickeling."""
 138         arr=DataArrayDouble(10) ; arr.iota()
 139         m=MEDCouplingCMesh() ; m.setCoords(arr,arr)
 140         m=m.buildUnstructured() ; m.convertAllToPoly()
 141         m=MEDCoupling1DGTUMesh(m)
 142         self.assertTrue(isinstance(m,MEDCoupling1DGTUMesh))
 143         st=pickle.dumps(m,pickle.HIGHEST_PROTOCOL)
 144         m2=pickle.loads(st)
 145         self.assertTrue(m2.isEqual(m,1e-16))
 146         pass
 147
 148     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 149     def test8(self):
 150         """ Test of a MEDCouplingMappedExtrudedMesh pickeling."""
 151         arrX=DataArrayDouble(10) ; arrX.iota() ; arrX.setInfoOnComponents(["aa"])
 152         arrY=DataArrayDouble(5) ; arrY.iota() ; arrY.setInfoOnComponents(["bbb"])
 153         arrZ=DataArrayDouble(7) ; arrZ.iota() ; arrZ.setInfoOnComponents(["cccc"])
 154         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ)
 155         mesh3D=m.buildUnstructured() ; del m
 156         #
 157         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY)
 158         mesh2D=m.buildUnstructured() ; del m
 159         #
 160         mesh2D.setCoords(mesh3D.getCoords())
 161         mesh=MEDCouplingMappedExtrudedMesh(mesh3D,mesh2D,0) ; del mesh3D,mesh2D
 162         self.assertTrue(isinstance(mesh,MEDCouplingMappedExtrudedMesh))
 163         st=pickle.dumps(mesh,pickle.HIGHEST_PROTOCOL)
 164         m2=pickle.loads(st)
 165         self.assertTrue(m2.isEqual(mesh,1e-16))
 166         pass
 167
 168     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 169     def test9(self):
 170         """ Test of a MEDCouplingCurveLinearMesh pickeling."""
 171         arrX=DataArrayDouble(10) ; arrX.iota() ; arrX.setInfoOnComponents(["aa"])
 172         arrY=DataArrayDouble(5) ; arrY.iota() ; arrY.setInfoOnComponents(["bbb"])
 173         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY)
 174         m=m.buildUnstructured()
 175         #
 176         mesh=MEDCouplingCurveLinearMesh() ; mesh.setCoords(m.getCoords()) ; del m
 177         mesh.setNodeGridStructure([10,5])
 178         st=pickle.dumps(mesh,pickle.HIGHEST_PROTOCOL)
 179         m2=pickle.loads(st)
 180         self.assertTrue(m2.isEqual(mesh,1e-16))
 181         pass
 182
 183     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 184     def test10(self):
 185         """ Test of a MEDCouplingIMesh pickeling."""
 186         m=MEDCouplingIMesh("mesh",3,DataArrayInt([3,1,4]),DataArrayDouble([1.5,2.5,3.5]),DataArrayDouble((0.5,1.,0.25))) ; m.setAxisUnit("km")
 187         m.checkConsistencyLight()
 188         st=pickle.dumps(m,pickle.HIGHEST_PROTOCOL)
 189         m2=pickle.loads(st)
 190         self.assertTrue(m2.isEqual(m,1e-16))
 191         self.assertEqual(m2.getName(),m.getName())
 192         pass
 193
 194     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 195     def test11(self):
 196         """  Test of MEDCouplingFieldDouble lying on MEDCouplingCMesh pickeling. """
 197         arrX=DataArrayDouble(10) ; arrX.iota() ; arrX.setInfoOnComponents(["aa"])
 198         arrY=DataArrayDouble(5) ; arrY.iota() ; arrY.setInfoOnComponents(["bbb"])
 199         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY)
 200         f=m.getMeasureField(True)
 201         f.setName("aname")
 202         a=f.getArray()
 203         b=a[:] ; b.iota(7000.)
 204         f.setArray(DataArrayDouble.Meld(a,b))
 205         f.getArray().setInfoOnComponents(["u1","vv2"])
 206         f.checkConsistencyLight();
 207         #
 208         st=pickle.dumps(f,pickle.HIGHEST_PROTOCOL)
 209         f2=pickle.loads(st)
 210         self.assertTrue(f2.isEqual(f,1e-16,1e-16))
 211         self.assertTrue(f2.getMesh().isEqual(f.getMesh(),1e-16))
 212         pass
 213
 214     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 215     def test12(self):
 216         """  Test of MEDCouplingFieldDouble on Gauss Points lying on MEDCouplingUMesh pickeling."""
 217         _a=0.446948490915965;
 218         _b=0.091576213509771;
 219         _p1=0.11169079483905;
 220         _p2=0.0549758718227661;
 221         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
 222         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
 223                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
 224         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
 225         _refCoo1=refCoo1
 226         _gsCoo1=gsCoo1
 227         _wg1=wg1
 228         #
 229         m=MEDCouplingDataForTest.build2DTargetMesh_1();
 230         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
 231         f.setMesh(m);
 232         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
 233         self.assertEqual(0,f.getNbOfGaussLocalization());
 234         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
 235         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
 236         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
 237         self.assertEqual(1,f.getNbOfGaussLocalization());
 238         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
 239         _refCoo2=refCoo2
 240         _gsCoo1=_gsCoo1[0:4]
 241         _wg1=_wg1[0:2]
 242         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
 243         self.assertEqual(2,f.getNbOfGaussLocalization());
 244         array=DataArrayDouble.New();
 245         ptr=18*2*[None]
 246         for i in range(18 * 2):
 247             ptr[i]=float(i+1)
 248         array.setValues(ptr,18,2);
 249         ptr=array.getPointer();
 250         f.setArray(array);
 251         f.setName("MyFirstFieldOnGaussPoint");
 252         f.checkConsistencyLight();
 253         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
 254         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
 255         #
 256         f.clearGaussLocalizations();
 257         self.assertEqual(0,f.getNbOfGaussLocalization());
 258         self.assertRaises(InterpKernelException,f.checkConsistencyLight);
 259         ids1=[0,1,3,4]
 260         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
 261         self.assertEqual(0,f.getNbOfGaussLocalization());
 262         ids2=[0,4]
 263         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
 264         self.assertEqual(1,f.getNbOfGaussLocalization());
 265         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
 266         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
 267         ids3=[1,2]
 268         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
 269         self.assertEqual(2,f.getNbOfGaussLocalization());
 270         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
 271         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
 272         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
 273         self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- cell 3 has no localization
 274         ids4=[3]
 275         _gsCoo2=_gsCoo1;
 276         _wg2=_wg1;
 277         _gsCoo2[0]=0.8888777776666;
 278         _wg2[0]=0.1234567892377;
 279         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
 280         self.assertEqual(3,f.getNbOfGaussLocalization());
 281         tmpIds=f.getCellIdsHavingGaussLocalization(0);
 282         self.assertEqual(ids2,list(tmpIds.getValues()));
 283         self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- it's always not ok because undelying array not with the good size.
 284         array2=f.getArray().subArray(0,10);
 285         f.setArray(array2);
 286         f.checkConsistencyLight();
 287         ####
 288         st=pickle.dumps(f,pickle.HIGHEST_PROTOCOL)
 289         f2=pickle.loads(st)
 290         self.assertTrue(f2.isEqual(f,1e-16,1e-16))
 291         self.assertTrue(f2.getMesh().isEqual(f.getMesh(),1e-16))
 292         pass
 293
 294     def test13(self):
 295         eStr="This is an exception."
 296         e=InterpKernelException(eStr)
 297         self.assertEqual(e.what(),eStr)
 298         st=pickle.dumps(e,pickle.HIGHEST_PROTOCOL)
 299         e2=pickle.loads(st)
 300         self.assertTrue(e is not e2)
 301         self.assertTrue(isinstance(e2,InterpKernelException))
 302         self.assertEqual(e2.what(),eStr)
 303         pass
 304
 305     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 306     def test14(self):
 307         """Pickelization of DataArrayBytes"""
 308         x=DataArrayByte(256,1)
 309         for i in range(256):
 310             x[i]=-128+i
 311             pass
 312         x.rearrange(2) ; x.setInfoOnComponents(["aa","bbb"])
 313         x.setName("toto")
 314         st=pickle.dumps(x,pickle.HIGHEST_PROTOCOL)
 315         x2=pickle.loads(st)
 316         self.assertTrue(x2.isEqual(x))
 317         pass
 318
 319     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 320     def test15(self):
 321         """Pickelization of DataArrayFloat"""
 322         x=DataArrayFloat(256) ; x.iota()
 323         x.rearrange(2) ; x.setInfoOnComponents(["aa","bbb"])
 324         x.setName("toto")
 325         st = pickle.dumps(x, pickle.HIGHEST_PROTOCOL)
 326         x2 = pickle.loads(st)
 327         self.assertTrue(x2.isEqual(x,1e-7))
 328         pass
 329
 330     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 331     def test16(self):
 332         """  Test of MEDCouplingFieldInt lying on MEDCouplingCMesh pickeling. """
 333         arrX=DataArrayDouble(10) ; arrX.iota() ; arrX.setInfoOnComponents(["aa"])
 334         arrY=DataArrayDouble(5) ; arrY.iota() ; arrY.setInfoOnComponents(["bbb"])
 335         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY)
 336         f=m.getMeasureField(True)
 337         f=f.convertToIntField()
 338         self.assertTrue(isinstance(f,MEDCouplingFieldInt))
 339         f.setName("aname")
 340         a=f.getArray()
 341         b=a[:] ; b.iota(7000)
 342         f.setArray(DataArrayInt.Meld(a,b))
 343         f.getArray().setInfoOnComponents(["u1","vv2"])
 344         f.checkConsistencyLight();
 345         #
 346         st = pickle.dumps(f, pickle.HIGHEST_PROTOCOL)
 347         f2 = pickle.loads(st)
 348         self.assertTrue(f2.isEqual(f,1e-16,0))
 349         self.assertTrue(f2.getMesh().isEqual(f.getMesh(),1e-16))
 350         pass
 351
 352     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 353     def test17(self):
 354         """  Test of MEDCouplingFieldInt lying on MEDCouplingCMesh pickeling. """
 355         arrX=DataArrayDouble(10) ; arrX.iota() ; arrX.setInfoOnComponents(["aa"])
 356         arrY=DataArrayDouble(5) ; arrY.iota() ; arrY.setInfoOnComponents(["bbb"])
 357         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY)
 358         f2=m.getMeasureField(True)
 359         f=MEDCouplingFieldFloat(ON_CELLS)
 360         f.setMesh(m) ; f.setArray(f2.getArray().convertToFloatArr())
 361         self.assertTrue(isinstance(f,MEDCouplingFieldFloat))
 362         f.setName("aname")
 363         a=f.getArray()
 364         b=a[:] ; b.iota(7000.)
 365         f.setArray(DataArrayFloat.Meld(a,b))
 366         f.getArray().setInfoOnComponents(["u1","vv2"])
 367         f.checkConsistencyLight();
 368         #
 369         st = pickle.dumps(f, pickle.HIGHEST_PROTOCOL)
 370         f2 = pickle.loads(st)
 371         self.assertTrue(f2.isEqual(f,1e-16,0))
 372         self.assertTrue(f2.getMesh().isEqual(f.getMesh(),1e-16))
 373         pass
 374
 375     def setUp(self):
 376         pass
 377     pass
 378
 379 if __name__=="__main__":
 380     unittest.main()