src/MEDLoader/Swig/MEDLoaderTest1.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2020  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 # Author : Anthony Geay (CEA/DEN)
  21
  22 import MEDLoader
  23 import unittest
  24 from math import pi,e,sqrt
  25 from MEDLoaderDataForTest import MEDLoaderDataForTest,WriteInTmpDir
  26 from MEDLoaderDataForTest import GeneratePyfile7,GeneratePyfile10,GeneratePyfile12,GeneratePyfile13,GeneratePyfile14,GeneratePyfile18,GeneratePyfile19
  27
  28 class MEDLoaderTest1(unittest.TestCase):
  29     @WriteInTmpDir
  30     def testMesh1DRW(self):
  31         mesh=MEDLoaderDataForTest.build1DMesh_1();
  32         mesh.checkConsistencyLight();
  33         MEDLoader.WriteUMesh("Pyfile1.med",mesh,True);
  34         mesh_rw=MEDLoader.ReadUMeshFromFile("Pyfile1.med",mesh.getName(),0);
  35         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  36         pass
  37
  38     @WriteInTmpDir
  39     def testMesh2DCurveRW(self):
  40         mesh=MEDLoaderDataForTest.build2DCurveMesh_1();
  41         mesh.checkConsistencyLight();
  42         MEDLoader.WriteUMesh("Pyfile2.med",mesh,True);
  43         mesh_rw=MEDLoader.ReadUMeshFromFile("Pyfile2.med",mesh.getName(),0);
  44         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  45         pass
  46
  47     @WriteInTmpDir
  48     def testMesh2DRW(self):
  49         mesh=MEDLoaderDataForTest.build2DMesh_1();
  50         mesh.checkConsistencyLight();
  51         MEDLoader.WriteUMesh("Pyfile3.med",mesh,True);
  52         mesh_rw=MEDLoader.ReadUMeshFromFile("Pyfile3.med",mesh.getName(),0);
  53         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  54         pass
  55
  56     @WriteInTmpDir
  57     def testMesh3DSurfRW(self):
  58         mesh=MEDLoaderDataForTest.build3DSurfMesh_1();
  59         mesh.checkConsistencyLight();
  60         MEDLoader.WriteUMesh("Pyfile4.med",mesh,True);
  61         mesh_rw=MEDLoader.ReadUMeshFromFile("Pyfile4.med",mesh.getName(),0);
  62         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  63         pass
  64
  65     @WriteInTmpDir
  66     def testMesh3DRW(self):
  67         mesh=MEDLoaderDataForTest.build3DMesh_1();
  68         mesh.checkConsistencyLight();
  69         MEDLoader.WriteUMesh("Pyfile5.med",mesh,True);
  70         mesh_rw=MEDLoader.ReadUMeshFromFile("Pyfile5.med",mesh.getName(),0);
  71         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  72         pass
  73
  74     @WriteInTmpDir
  75     def testFieldRW1(self):
  76         GeneratePyfile7(self)
  77         pass
  78
  79     @WriteInTmpDir
  80     def testFieldRW2(self):
  81         fileName="Pyfile8.med";
  82         VAL1=12345.67890314;
  83         VAL2=-1111111111111.;
  84         f1=MEDLoaderDataForTest.buildVecFieldOnCells_1();
  85         f1_int=MEDLoaderDataForTest.buildIntVecFieldOnCells_1();
  86         f1_fl=MEDLoaderDataForTest.buildFloatVecFieldOnCells_1();
  87         MEDLoader.WriteField(fileName,f1,True);
  88         f1.setTime(10.,8,9);
  89         f1_int.setTime(10.,8,9);
  90         f1_fl.setTime(10.,8,9);
  91         f1.getArray().setIJ(0,0,VAL1);
  92         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
  93         f1.setTime(10.14,18,19);
  94         f1.getArray().setIJ(0,0,VAL2);
  95         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
  96         # Write int and float fields:
  97         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1_int);
  98         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1_fl);
  99         #retrieving time steps...
 100         f2=MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),0,f1.getName(),8,9);
 101         f1.setTime(10.,8,9);
 102         f1.getArray().setIJ(0,0,VAL1);
 103         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 104         f2=MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),0,f1.getName(),0,1);
 105         f3=MEDLoaderDataForTest.buildVecFieldOnCells_1();
 106         self.assertTrue(f3.isEqual(f2,1e-12,1e-12));
 107         f2=MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),0,f1.getName(),18,19);
 108         f1.setTime(10.14,18,19);
 109         f1.getArray().setIJ(0,0,VAL2);
 110         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 111         #test of throw on invalid (dt,it)
 112         self.assertRaises(Exception,MEDLoader.ReadFieldCell,fileName,f1.getMesh().getName(),0,f1.getName(),28,19);
 113         # Reading Int and Float fields:
 114         f2_int=MEDLoader.ReadFieldCell(fileName,f1_int.getMesh().getName(),0,f1_int.getName(),8,9);
 115         self.assertTrue(f1_int.isEqual(f2_int,1e-12,0));  # exact comparison here
 116         f2_fl=MEDLoader.ReadFieldCell(fileName,f1_fl.getMesh().getName(),0,f1_fl.getName(),8,9);
 117         self.assertTrue(f1_fl.isEqual(f2_fl,1e-12,1e-7)); # float comparison here
 118         #ON NODES
 119         f1=MEDLoaderDataForTest.buildVecFieldOnNodes_1();
 120         fileName2="Pyfile9.med";
 121         MEDLoader.WriteField(fileName2,f1,True);
 122         f1.setTime(110.,108,109);
 123         tmp=f1.getArray().getPointer();
 124         f1.getArray().setIJ(0,3,VAL1);
 125         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
 126         f1.setTime(210.,208,209);
 127         f1.getArray().setIJ(0,3,VAL2);
 128         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
 129         f2=MEDLoader.ReadFieldNode(fileName2,f1.getMesh().getName(),0,f1.getName(),108,109);
 130         f1.setTime(110.,108,109);
 131         f1.getArray().setIJ(0,3,VAL1);
 132         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 133         f2=MEDLoader.ReadFieldNode(fileName2,f1.getMesh().getName(),0,f1.getName(),2,3);
 134         f3=MEDLoaderDataForTest.buildVecFieldOnNodes_1();
 135         self.assertTrue(f3.isEqual(f2,1e-12,1e-12));
 136         f2=MEDLoader.ReadFieldNode(fileName2,f1.getMesh().getName(),0,f1.getName(),208,209);
 137         f1.setTime(210.,208,209);
 138         f1.getArray().setIJ(0,3,VAL2);
 139         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 140         pass
 141
 142     #
 143     # Multi field in a same file, but this field has several
 144     #
 145     @WriteInTmpDir
 146     def testFieldRW3(self):
 147         fileName="Pyfile11.med";
 148         VAL1=12345.67890314;
 149         VAL2=-1111111111111.;
 150         name1="AField";
 151         name3="AMesh1";
 152         f1=MEDLoaderDataForTest.buildVecFieldOnCells_1();
 153         f1.getMesh().setName(name3);
 154         f1.setName(name1);
 155         f1.setTime(10.,8,9);
 156         tmp=f1.getArray().getPointer();
 157         f1.getArray().setIJ(0,0,VAL1);
 158         MEDLoader.WriteField(fileName,f1,True);
 159         f1.setTime(10.14,18,19);
 160         f1.getArray().setIJ(0,0,VAL2);
 161         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 162         f1.getMesh().setName(name3);
 163         f1.setTime(10.55,28,29);
 164         f1.getArray().setIJ(0,0,3*VAL1);
 165         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 166         vec=MEDLoader.GetMeshNamesOnField(fileName,name1);
 167         f1.setTime(10.66,38,39);
 168         f1.getArray().setIJ(0,0,3*VAL2);
 169         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 170         f1.setTime(10.77,48,49);
 171         f1.getArray().setIJ(0,0,4*VAL2);
 172         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 173         #ON NODES
 174         f1=MEDLoaderDataForTest.buildVecFieldOnNodes_1();
 175         f1.setName(name1);
 176         f1.getMesh().setName(name3);
 177         f1.setTime(110.,8,9);
 178         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 179         f1.setTime(110.,108,109);
 180         tmp=f1.getArray().getPointer();
 181         f1.getArray().setIJ(0,3,VAL1);
 182         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 183         f1.setTime(210.,208,209);
 184         f1.getArray().setIJ(0,3,VAL2);
 185         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 186         #
 187         it1=MEDLoader.GetCellFieldIterations(fileName,name3,name1);
 188         self.assertEqual(5,len(it1));
 189         self.assertEqual(8,it1[0][0]); self.assertEqual(9,it1[0][1]);
 190         self.assertEqual(18,it1[1][0]); self.assertEqual(19,it1[1][1]);
 191         self.assertEqual(28,it1[2][0]); self.assertEqual(29,it1[2][1]);
 192         self.assertEqual(38,it1[3][0]); self.assertEqual(39,it1[3][1]);
 193         self.assertEqual(48,it1[4][0]); self.assertEqual(49,it1[4][1]);
 194         it3=MEDLoader.GetNodeFieldIterations(fileName,name3,name1);
 195         self.assertEqual(3,len(it3));
 196         self.assertEqual(8,it3[0][0]); self.assertEqual(9,it3[0][1]);
 197         self.assertEqual(108,it3[1][0]); self.assertEqual(109,it3[1][1]);
 198         self.assertEqual(208,it3[2][0]); self.assertEqual(209,it3[2][1]);
 199         #
 200         #
 201         f1=MEDLoader.ReadFieldCell(fileName,name3,0,name1,8,9);
 202         self.assertAlmostEqual(VAL1,f1.getArray().getIJ(0,0),13);
 203         f1=MEDLoader.ReadFieldCell(fileName,name3,0,name1,18,19);
 204         self.assertAlmostEqual(VAL2,f1.getArray().getIJ(0,0),13);
 205         f1=MEDLoader.ReadFieldCell(fileName,name3,0,name1,28,29);
 206         self.assertAlmostEqual(3*VAL1,f1.getArray().getIJ(0,0),13);
 207         f1=MEDLoader.ReadFieldCell(fileName,name3,0,name1,38,39);
 208         self.assertAlmostEqual(3*VAL2,f1.getArray().getIJ(0,0),13);
 209         f1=MEDLoader.ReadFieldCell(fileName,name3,0,name1,48,49);
 210         self.assertAlmostEqual(4*VAL2,f1.getArray().getIJ(0,0),13);
 211         #
 212         f1=MEDLoader.ReadFieldNode(fileName,name3,0,name1,8,9);
 213         self.assertAlmostEqual(71.,f1.getArray().getIJ(0,3),13);
 214         f1=MEDLoader.ReadFieldNode(fileName,name3,0,name1,108,109);
 215         self.assertAlmostEqual(VAL1,f1.getArray().getIJ(0,3),13);
 216         f1=MEDLoader.ReadFieldNode(fileName,name3,0,name1,208,209);
 217         self.assertAlmostEqual(VAL2,f1.getArray().getIJ(0,3),13);
 218         pass
 219
 220     @WriteInTmpDir
 221     def testMultiMeshRW1(self):
 222         GeneratePyfile10(self)
 223         pass
 224
 225     @WriteInTmpDir
 226     def testFieldProfilRW1(self):
 227         GeneratePyfile12(self)
 228         #
 229         pass
 230
 231     @WriteInTmpDir
 232     def testFieldGaussRW1(self):
 233         GeneratePyfile13(self)
 234         pass
 235
 236     @WriteInTmpDir
 237     def testFieldGaussNERW1(self):
 238         GeneratePyfile14(self)
 239         pass
 240
 241     @WriteInTmpDir
 242     def testMesh3DSurfShuffleRW(self):
 243         fileName="Pyfile15.med";
 244         mesh=MEDLoaderDataForTest.build3DSurfMesh_1();
 245         renumber1=[2,5,1,0,3,4]
 246         mesh.renumberCells(renumber1,False);
 247         mesh.checkConsistencyLight();
 248         MEDLoader.WriteUMesh(fileName,mesh,True);
 249         mesh_rw=MEDLoader.ReadUMeshFromFile(fileName,mesh.getName(),0);
 250         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
 251         pass
 252
 253     @WriteInTmpDir
 254     def testMultiFieldShuffleRW1(self):
 255         fileName="Pyfile17.med";
 256         m=MEDLoaderDataForTest.build3DMesh_2();
 257         self.assertEqual(20,m.getNumberOfCells());
 258         self.assertEqual(45,m.getNumberOfNodes());
 259         polys=[1,4,6]
 260         m.convertToPolyTypes(polys);
 261         renum=[1,3,2,8,9,12,13,16,19,0,4,7,5,15,14,17,10,18,6,11]
 262         m.renumberCells(renum,False);
 263         m.orientCorrectlyPolyhedrons();
 264         # Writing
 265         MEDLoader.WriteUMesh(fileName,m,True);
 266         f1Tmp=m.getMeasureField(False);
 267         f1=f1Tmp.buildNewTimeReprFromThis(MEDLoader.ONE_TIME,False);
 268         f1.setTime(0.,1,2);
 269         f_1=f1.cloneWithMesh(True);
 270         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 271         f1.applyFunc("2*x");
 272         f1.setTime(0.01,3,4);
 273         f_2=f1.cloneWithMesh(True);
 274         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 275         f1.applyFunc("2*x/3");
 276         f1.setTime(0.02,5,6);
 277         f_3=f1.cloneWithMesh(True);
 278         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 279         # Reading
 280         its=[(1,2),(3,4),(5,6)];
 281         fs=MEDLoader.ReadFieldsOnSameMesh(MEDLoader.ON_CELLS,fileName,f_1.getMesh().getName(),0,f_1.getName(),its);
 282         self.assertEqual(3,len(fs));
 283         self.assertTrue(fs[0].isEqual(f_1,1e-12,1e-12));
 284         self.assertTrue(fs[1].isEqual(f_2,1e-12,1e-12));
 285         self.assertTrue(fs[2].isEqual(f_3,1e-12,1e-12));
 286         pass
 287
 288     @WriteInTmpDir
 289     def testWriteUMeshesRW1(self):
 290         GeneratePyfile18(self)
 291         pass
 292
 293     @WriteInTmpDir
 294     def testFieldNodeProfilRW1(self):
 295         GeneratePyfile19(self)
 296         pass
 297
 298     @WriteInTmpDir
 299     def testFieldNodeProfilRW2(self):
 300         fileName="Pyfile23.med";
 301         mesh=MEDLoaderDataForTest.build3DSurfMesh_1();
 302         MEDLoader.WriteUMesh(fileName,mesh,True);
 303         #
 304         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_NODES,MEDLoader.ONE_TIME);
 305         f1.setName("FieldMix");
 306         f1.setMesh(mesh);
 307         arr2=[1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150.,
 308               1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.];
 309         array=MEDLoader.DataArrayDouble.New();
 310         array.setValues(arr2,12,2);
 311         f1.setArray(array);
 312         array.setInfoOnComponent(0,"plkj [mm]");
 313         array.setInfoOnComponent(1,"pqqqss [mm]");
 314         tmp=array.getPointer();
 315         f1.setTime(3.17,2,7);
 316         #
 317         renumArr=[3,7,2,1,5,11,10,0,9,6,8,4]
 318         f1.renumberNodes(renumArr);
 319         f1.checkConsistencyLight();
 320         MEDLoader.WriteField(fileName,f1,False);#<- False important for the test
 321         f2=MEDLoader.ReadFieldNode(fileName,f1.getMesh().getName(),0,f1.getName(),2,7);
 322         self.assertTrue(f2.isEqual(f1,1e-12,1e-12));
 323         #
 324         pass
 325
 326     @WriteInTmpDir
 327     def testMixCellAndNodesFieldRW1(self):
 328         fileName="Pyfile21.med";
 329         mesh=MEDLoaderDataForTest.build3DSurfMesh_1();
 330         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_CELLS,MEDLoader.ONE_TIME);
 331         f1.setName("FieldMix");
 332         f1.setMesh(mesh);
 333         array=MEDLoader.DataArrayDouble.New();
 334         f1.setArray(array);
 335         arr1=[71.,171.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
 336         array.setValues(arr1,6,2);
 337         array.setInfoOnComponent(0,"plkj [mm]");
 338         array.setInfoOnComponent(1,"pqqqss [mm]");
 339         f1.setTime(3.14,2,7);
 340         f1.checkConsistencyLight();
 341         #
 342         f2=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_NODES,MEDLoader.ONE_TIME);
 343         f2.setName("FieldMix");
 344         f2.setMesh(mesh);
 345         array=MEDLoader.DataArrayDouble.New();
 346         f2.setArray(array);
 347         arr2=[1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150.,
 348               1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.]
 349         array.setValues(arr2,12,2)
 350         array.setInfoOnComponent(0,"plkj [mm]");
 351         array.setInfoOnComponent(1,"pqqqss [mm]");
 352         f2.setTime(3.14,2,7);
 353         f2.checkConsistencyLight();
 354         #
 355         MEDLoader.WriteField(fileName,f1,True);
 356         ts=MEDLoader.GetTypesOfField(fileName,f1.getMesh().getName(),f1.getName());
 357         self.assertEqual(1,len(ts));
 358         self.assertEqual(MEDLoader.ON_CELLS,ts[0]);
 359         fs=MEDLoader.GetAllFieldNamesOnMesh(fileName,f1.getMesh().getName());
 360         self.assertEqual(1,len(fs));
 361         self.assertTrue(fs[0]=="FieldMix");
 362         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f2);
 363         fs=MEDLoader.GetAllFieldNamesOnMesh(fileName,f1.getMesh().getName());
 364         self.assertEqual(1,len(fs));
 365         self.assertTrue(fs[0]=="FieldMix");
 366         #
 367         ts=MEDLoader.GetTypesOfField(fileName,f1.getMesh().getName(),f1.getName());
 368         self.assertEqual(2,len(ts));
 369         self.assertEqual(MEDLoader.ON_NODES,ts[0]);
 370         self.assertEqual(MEDLoader.ON_CELLS,ts[1]);
 371         #
 372         f3=MEDLoader.ReadFieldNode(fileName,f1.getMesh().getName(),0,f1.getName(),2,7);
 373         self.assertTrue(f3.isEqual(f2,1e-12,1e-12));
 374         f3=MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),0,f1.getName(),2,7);
 375         self.assertTrue(f3.isEqual(f1,1e-12,1e-12));
 376         #
 377         pass
 378
 379     @WriteInTmpDir
 380     def testGetAllFieldNamesRW1(self):
 381         fileName="Pyfile22.med";
 382         mesh=MEDLoaderDataForTest.build2DMesh_2();
 383         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_NODES,MEDLoader.ONE_TIME);
 384         f1.setName("Field1");
 385         f1.setTime(3.44,5,6);
 386         f1.setMesh(mesh);
 387         f1.fillFromAnalytic(2,"x+y");
 388         MEDLoader.WriteField(fileName,f1,True);
 389         f1.setTime(1002.3,7,8);
 390         f1.fillFromAnalytic(2,"x+77.*y");
 391         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 392         f1.setName("Field2");
 393         MEDLoader.WriteField(fileName,f1,False);
 394         f1.setName("Field3");
 395         mesh.setName("2DMesh_2Bis");
 396         MEDLoader.WriteField(fileName,f1,False);
 397         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_CELLS,MEDLoader.ONE_TIME);
 398         f1.setName("Field8");
 399         f1.setTime(8.99,7,9);
 400         f1.setMesh(mesh);
 401         f1.fillFromAnalytic(3,"3*x+y");
 402         MEDLoader.WriteField(fileName,f1,False);
 403         fs=MEDLoader.GetAllFieldNames(fileName);
 404         self.assertEqual(4,len(fs));
 405         self.assertTrue(fs[0]=="Field1");
 406         self.assertTrue(fs[1]=="Field2");
 407         self.assertTrue(fs[2]=="Field3");
 408         self.assertTrue(fs[3]=="Field8");
 409         pass
 410
 411     @WriteInTmpDir
 412     def testBigNbOfCompoNonReg(self):
 413         fileName="Pyfile57.med"
 414         m=MEDLoader.MEDCouplingCMesh() ; m.setCoords(MEDLoader.DataArrayDouble([0,1,2,3]),MEDLoader.DataArrayDouble([0,1]),MEDLoader.DataArrayDouble([0,1]))
 415         m=m.buildUnstructured() ; m.setName("TinyMesh")
 416         f=MEDLoader.MEDCouplingFieldDouble(MEDLoader.ON_CELLS) ; f.setMesh(m)
 417         nbOfCompo=4100
 418         arr=MEDLoader.DataArrayDouble(nbOfCompo*3) ; arr.iota()
 419         arr.rearrange(nbOfCompo)
 420         arr.setInfoOnComponents(["c%i" % (i) for i in range(nbOfCompo)])
 421         f.setArray(arr)
 422         f.setName("FieldBigCompo")
 423         MEDLoader.WriteField(fileName,f,True)
 424         f2=MEDLoader.ReadFieldCell(fileName,m.getName(),0,f.getName(),-1,-1)
 425         self.assertTrue(f.isEqual(f2,1e-12,1e-12))
 426         pass
 427
 428     @WriteInTmpDir
 429     def testMultiMeshTypeWrite0(self):
 430         fname="Pyfile73.med"
 431         m=MEDLoader.MEDCoupling1SGTUMesh("mesh",MEDLoader.NORM_QUAD4) ; m.allocateCells()
 432         m.insertNextCell([0,2,1,3])
 433         m.setCoords(MEDLoader.DataArrayDouble([0.,0.,1.,1.,1.,0.,0.,1.],4,2))
 434         #
 435         ms = [m.deepCopy() for i in range(4)]
 436         for i,elt in enumerate(ms):
 437             elt.translate([float(i)*1.5,0.])
 438             pass
 439         #
 440         m0=MEDLoader.MEDCoupling1SGTUMesh.Merge1SGTUMeshes(ms)
 441         f=m0.getMeasureField(False) ; f.getArray().setInfoOnComponents(["ABC [defg]"])
 442         MEDLoader.WriteField(fname,f,True)
 443         #
 444         fRead=MEDLoader.ReadFieldCell(fname,"merge",0,f.getName(),-1,-1)
 445         fRead.setMesh(MEDLoader.MEDCoupling1SGTUMesh(fRead.getMesh()))
 446         self.assertTrue(f.isEqual(fRead,1e-12,1e-12))
 447         #
 448         m0=m0.buildUnstructured() ; m0.convertAllToPoly()
 449         m0=MEDLoader.MEDCoupling1DGTUMesh(m0)
 450         f=m0.getMeasureField(False) ; f.getArray().setInfoOnComponents(["ABC [defg]"])
 451         MEDLoader.WriteField(fname,f,True)
 452         #
 453         fRead=MEDLoader.ReadFieldCell(fname,"merge",0,f.getName(),-1,-1)
 454         fRead.setMesh(MEDLoader.MEDCoupling1DGTUMesh(fRead.getMesh()))
 455         self.assertTrue(f.isEqual(fRead,1e-12,1e-12))
 456         #
 457         m0=MEDLoader.MEDCouplingCMesh()
 458         arr=MEDLoader.DataArrayDouble(4) ; arr.iota()
 459         m0.setCoords(arr,arr)
 460         m0.setName("mesh")
 461         f=m0.getMeasureField(False) ; f.getArray().setInfoOnComponents(["ABC [defg]"])
 462         MEDLoader.WriteField(fname,f,True)
 463         #
 464         fRead=MEDLoader.ReadFieldCell(fname,"mesh",0,f.getName(),-1,-1)
 465         self.assertTrue(f.isEqual(fRead,1e-12,1e-12))
 466         #
 467         c=m0.buildUnstructured().getCoords()
 468         m0=MEDLoader.MEDCouplingCurveLinearMesh("mesh")
 469         m0.setNodeGridStructure([4,4])
 470         m0.setCoords(c)
 471         f=m0.getMeasureField(False) ; f.getArray().setInfoOnComponents(["ABC [defg]"])
 472         MEDLoader.WriteField(fname,f,True)
 473         #
 474         fRead=MEDLoader.ReadFieldCell(fname,"mesh",0,f.getName(),-1,-1)
 475         self.assertTrue(f.isEqual(fRead,1e-12,1e-12))
 476         pass
 477
 478     @WriteInTmpDir
 479     def testMultiMeshTypeWrite1(self):
 480         fname="Pyfile74.med"
 481         m=MEDLoader.MEDCoupling1SGTUMesh("mesh",MEDLoader.NORM_QUAD4) ; m.allocateCells()
 482         m.insertNextCell([0,2,1,3])
 483         m.setCoords(MEDLoader.DataArrayDouble([0.,0.,1.,1.,1.,0.,0.,1.],4,2))
 484         #
 485         ms = [m.deepCopy() for i in range(4)]
 486         for i,elt in enumerate(ms):
 487             elt.translate([float(i)*1.5,0.])
 488             pass
 489         m0=MEDLoader.MEDCoupling1SGTUMesh.Merge1SGTUMeshes(ms)
 490         MEDLoader.WriteMesh(fname,m0,True)
 491         #
 492         mRead=MEDLoader.ReadMeshFromFile(fname,"merge",0)
 493         self.assertTrue(isinstance(mRead,MEDLoader.MEDCouplingUMesh))
 494         mRead=MEDLoader.MEDCoupling1SGTUMesh(mRead)
 495         self.assertTrue(m0.isEqual(mRead,1e-12))
 496         #
 497         m0=m0.buildUnstructured() ; m0.convertAllToPoly()
 498         m0=MEDLoader.MEDCoupling1DGTUMesh(m0)
 499         MEDLoader.WriteMesh(fname,m0,True)
 500         #
 501         mRead=MEDLoader.ReadMeshFromFile(fname,"merge",0)
 502         mRead=MEDLoader.MEDCoupling1DGTUMesh(mRead)
 503         self.assertTrue(m0.isEqual(mRead,1e-12))
 504         #
 505         m0=MEDLoader.MEDCouplingCMesh()
 506         arr=MEDLoader.DataArrayDouble(4) ; arr.iota()
 507         m0.setCoords(arr,arr)
 508         m0.setName("mesh")
 509         MEDLoader.WriteMesh(fname,m0,True)
 510         #
 511         mRead=MEDLoader.ReadMeshFromFile(fname,0)
 512         self.assertTrue(isinstance(mRead,MEDLoader.MEDCouplingCMesh))
 513         self.assertTrue(m0.isEqual(mRead,1e-12))
 514         #
 515         c=m0.buildUnstructured().getCoords()
 516         m0=MEDLoader.MEDCouplingCurveLinearMesh("mesh")
 517         m0.setNodeGridStructure([4,4])
 518         m0.setCoords(c)
 519         MEDLoader.WriteMesh(fname,m0,True)
 520         #
 521         mRead=MEDLoader.ReadMeshFromFile(fname,0)
 522         self.assertTrue(isinstance(mRead,MEDLoader.MEDCouplingCurveLinearMesh))
 523         self.assertTrue(m0.isEqual(mRead,1e-12))
 524         pass
 525
 526     @WriteInTmpDir
 527     def testChangeGroupName(self):
 528         """ This test is a non regression test on MEDFileUMesh.changeGroupName thanks to Alliance.
 529         """
 530         mfd=MEDLoaderDataForTest.buildAMEDFileDataWithGroupOnOneFamilyForSauv()
 531         mesh = mfd.getMeshes().getMeshAtPos(0)
 532         mesh.changeGroupName("grp0_LM1", "xonall1")
 533         self.assertTrue("xonall1" in mesh.getGroupsNames())
 534         pass
 535
 536     @WriteInTmpDir
 537     def testFieldWithTooLongName(self):
 538         """ This test is a non regression test, to check that in basic API the policies are taken into account.
 539         """
 540         fname="Pyfile75.med"
 541         # Coordinates
 542         coords = [0.,0., 0.,1., 1.,1., 1.,0.]
 543         # lvl 0 connectivity
 544         conn2D   = [1,2,3,4]
 545         # lvl 0 mesh
 546         m=MEDLoader.MEDCouplingUMesh.New("mesh",2)
 547         m.allocateCells(1)
 548         m.insertNextCell(MEDLoader.NORM_QUAD4,4,conn2D)
 549         m.finishInsertingCells()
 550         # assigning coordinates
 551         meshCoords=MEDLoader.DataArrayDouble.New()
 552         meshCoords.setValues(coords, 4, 2)
 553         m.setCoords(meshCoords)
 554         #
 555         f=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_CELLS,MEDLoader.ONE_TIME)
 556         f.setMesh(m)
 557         d=MEDLoader.DataArrayDouble.New()
 558         d.alloc(1,1)
 559         d.iota(1.)
 560         # setting a long name
 561         d.setInfoOnComponent(0,"CONCENTRATION of I129")
 562         f.setArray(d)
 563         f.setName("field")
 564         #
 565         mm=MEDLoader.MEDFileUMesh()
 566         MEDLoader.SetTooLongStrPolicy(2)
 567         MEDLoader.AssignStaticWritePropertiesTo(mm)
 568         self.assertEqual(2,mm.getTooLongStrPolicy())
 569         MEDLoader.SetTooLongStrPolicy(0)
 570         MEDLoader.AssignStaticWritePropertiesTo(mm)
 571         self.assertEqual(0,mm.getTooLongStrPolicy())
 572         del mm
 573         #
 574         MEDLoader.SetTooLongStrPolicy(2)
 575         self.assertRaises(MEDLoader.InterpKernelException,MEDLoader.WriteField,fname,f,True)# the component name is too long + policy 2 -> throw
 576         f.getArray().setInfoOnComponent(0,'I129')
 577         MEDLoader.WriteField(fname,f,True)
 578         pass
 579
 580     @WriteInTmpDir
 581     def testUsingAlreadyWrittenMesh2(self):
 582         """ This test focuses on MEDLoader.WriteFieldUsingAlreadyWrittenMesh with mesh different from UMesh.
 583         """
 584         fname="Pyfile76.med"
 585         mesh=MEDLoader.MEDCouplingCMesh("mesh")
 586         arrX=MEDLoader.DataArrayDouble([0,1,2,3])
 587         arrY=MEDLoader.DataArrayDouble([0,2,3,5,7])
 588         arrZ=MEDLoader.DataArrayDouble([7])
 589         mesh.setCoords(arrX,arrY,arrZ)
 590         #
 591         f1=MEDLoader.MEDCouplingFieldDouble(MEDLoader.ON_NODES) ; f1.setName("f1")
 592         f1.setMesh(mesh)
 593         arr=MEDLoader.DataArrayDouble(20) ; arr.iota()
 594         f1.setArray(arr)
 595         f1.checkConsistencyLight()
 596         #
 597         f2=MEDLoader.MEDCouplingFieldDouble(MEDLoader.ON_NODES) ; f2.setName("f2")
 598         f2.setMesh(mesh)
 599         arr=MEDLoader.DataArrayDouble(20) ; arr.iota() ; arr*=3
 600         f2.setArray(arr)
 601         f2.checkConsistencyLight()
 602         #
 603         f11=f1.deepCopy() ; (f11.getArray())[:]*=4 ; f11.setTime(1.1,5,6)
 604         #
 605         MEDLoader.WriteMesh(fname,f1.getMesh(),True)
 606         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f1)
 607         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f2)
 608         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f11)
 609         ##
 610         f1r=MEDLoader.ReadFieldNode(fname,"mesh",0,"f1",-1,-1);
 611         self.assertTrue(f1.isEqual(f1r,1e-12,1e-12))
 612         self.assertTrue(f1r.getArray().isEqual(MEDLoader.DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.]),1e-12))
 613         f2r=MEDLoader.ReadFieldNode(fname,"mesh",0,"f2",-1,-1);
 614         self.assertTrue(f2.isEqual(f2r,1e-12,1e-12))
 615         self.assertTrue(f2r.getArray().isEqual(MEDLoader.DataArrayDouble([0.,3.,6.,9.,12.,15.,18.,21.,24.,27.,30.,33.,36.,39.,42.,45.,48.,51.,54.,57.]),1e-12))
 616         f3r=MEDLoader.ReadFieldNode(fname,"mesh",0,"f1",5,6);
 617         self.assertTrue(f11.isEqual(f3r,1e-12,1e-12))
 618         self.assertTrue(f3r.getArray().isEqual(MEDLoader.DataArrayDouble([0.,4.,8.,12.,16.,20.,24.,28.,32.,36.,40.,44.,48.,52.,56.,60.,64.,68.,72.,76.]),1e-12))
 619         pass
 620
 621     @WriteInTmpDir
 622     def testEasyFieldRead1(self):
 623         fname="Pyfile111.med"
 624         arr=MEDLoader.DataArrayDouble(4) ; arr.iota()
 625         m=MEDLoader.MEDCouplingCMesh() ; m.setCoords(arr,arr)
 626         m=m.buildUnstructured()
 627         m.setName("mesh")
 628         f=MEDLoader.MEDCouplingFieldDouble(MEDLoader.ON_CELLS)
 629         f.setName("field")
 630         f.setTime(3.,1,2)
 631         da=MEDLoader.DataArrayDouble([2,3,4,5,6,7,8,9,10])
 632         f.setArray(da) ; f.setMesh(m)
 633         MEDLoader.WriteField(fname,f,True)
 634         #
 635         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname),1e-12,1e-12))
 636         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field"),1e-12,1e-12))
 637         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field",1,2),1e-12,1e-12))
 638         self.assertTrue(f.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",1,2),1e-12,1e-12))
 639         #
 640         f3=f.deepCopy()
 641         f3.setArray(f.getArray()+30)
 642         f3.setName("field2")
 643         f3.setTime(5.,4,5)
 644         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f3)
 645         #
 646         self.assertRaises(Exception,MEDLoader.ReadField,fname) # because several fields in fname now
 647         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field"),1e-12,1e-12))
 648         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field",1,2),1e-12,1e-12))
 649         self.assertTrue(f.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",1,2),1e-12,1e-12))
 650         self.assertTrue(f3.isEqual(MEDLoader.ReadField(fname,"field2"),1e-12,1e-12))
 651         self.assertTrue(f3.isEqual(MEDLoader.ReadField(fname,"field2",4,5),1e-12,1e-12))
 652         self.assertTrue(f3.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field2",4,5),1e-12,1e-12))
 653         #
 654         f2=f.deepCopy()
 655         f2.setTime(4.,3,4)
 656         f2.setArray(f2.getArray()+10)
 657         MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f2)
 658         #
 659         self.assertRaises(Exception,MEDLoader.ReadField,fname) # because unique field "field" has more than one time step
 660         self.assertRaises(Exception,MEDLoader.ReadField,fname,"field") # because unique field "field" has more than one time step
 661         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field",1,2),1e-12,1e-12))
 662         self.assertTrue(f.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",1,2),1e-12,1e-12))
 663         self.assertTrue(f2.isEqual(MEDLoader.ReadField(fname,"field",3,4),1e-12,1e-12))
 664         self.assertTrue(f2.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",3,4),1e-12,1e-12))
 665         #
 666         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field",1,2),1e-12,1e-12))
 667         self.assertTrue(f.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",1,2),1e-12,1e-12))
 668         self.assertTrue(f2.isEqual(MEDLoader.ReadField(fname,"field",3,4),1e-12,1e-12))
 669         self.assertTrue(f2.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",3,4),1e-12,1e-12))
 670         #
 671         self.assertTrue(f3.isEqual(MEDLoader.ReadField(fname,"field2"),1e-12,1e-12))
 672         self.assertTrue(f3.isEqual(MEDLoader.ReadField(fname,"field2",4,5),1e-12,1e-12))
 673         self.assertRaises(Exception,MEDLoader.ReadField,fname,"field2",5,5) # invalid time step
 674         self.assertTrue(f3.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field2",4,5),1e-12,1e-12))
 675         self.assertRaises(Exception,MEDLoader.ReadField,MEDLoader.ON_CELLS,fname,"mesh",0,"field2",5,5) # invalid time step
 676         # Test on profile - restart from scratch
 677         mm=MEDLoader.MEDFileUMesh()
 678         mm[0]=m
 679         mm.write(fname,2)
 680         #
 681         pfl = MEDLoader.DataArrayInt(list(range(8)))
 682         pfl.setName("PFL")
 683         #
 684         f=MEDLoader.MEDCouplingFieldDouble(MEDLoader.ON_CELLS)
 685         f.setName("field")
 686         f.setTime(3.,1,2)
 687         da=MEDLoader.DataArrayDouble([2,3,4,5,6,7,8,9])
 688         f.setArray(da) ; f.setMesh(m[pfl])
 689         f.checkConsistencyLight()
 690         #
 691         f1ts=MEDLoader.MEDFileField1TS()
 692         f1ts.setFieldProfile(f,mm,0,pfl)
 693         f1ts.write(fname,0)
 694         #
 695         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname),1e-12,1e-12))
 696         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field"),1e-12,1e-12))
 697         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field",1,2),1e-12,1e-12))
 698         self.assertTrue(f.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",1,2),1e-12,1e-12))
 699         #
 700         f3=f.deepCopy()
 701         f3.setArray(f.getArray()+30)
 702         f3.setName("field2")
 703         f3.setTime(5.,4,5)
 704         f1ts=MEDLoader.MEDFileField1TS()
 705         f1ts.setFieldProfile(f3,mm,0,pfl)
 706         f1ts.write(fname,0)
 707         #
 708         self.assertRaises(Exception,MEDLoader.ReadField,fname) # because several fields in fname now
 709         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field"),1e-12,1e-12))
 710         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field",1,2),1e-12,1e-12))
 711         self.assertTrue(f.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",1,2),1e-12,1e-12))
 712         self.assertTrue(f3.isEqual(MEDLoader.ReadField(fname,"field2"),1e-12,1e-12))
 713         self.assertTrue(f3.isEqual(MEDLoader.ReadField(fname,"field2",4,5),1e-12,1e-12))
 714         self.assertTrue(f3.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field2",4,5),1e-12,1e-12))
 715         #
 716         f2=f.deepCopy()
 717         f2.setTime(4.,3,4)
 718         f2.setArray(f2.getArray()+10)
 719         f1ts=MEDLoader.MEDFileField1TS()
 720         f1ts.setFieldProfile(f2,mm,0,pfl)
 721         f1ts.write(fname,0)
 722         #
 723         self.assertRaises(Exception,MEDLoader.ReadField,fname) # because unique field "field" has more than one time step
 724         self.assertRaises(Exception,MEDLoader.ReadField,fname,"field") # because unique field "field" has more than one time step
 725         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field",1,2),1e-12,1e-12))
 726         self.assertTrue(f.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",1,2),1e-12,1e-12))
 727         self.assertTrue(f2.isEqual(MEDLoader.ReadField(fname,"field",3,4),1e-12,1e-12))
 728         self.assertTrue(f2.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",3,4),1e-12,1e-12))
 729         #
 730         self.assertTrue(f.isEqual(MEDLoader.ReadField(fname,"field",1,2),1e-12,1e-12))
 731         self.assertTrue(f.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",1,2),1e-12,1e-12))
 732         self.assertTrue(f2.isEqual(MEDLoader.ReadField(fname,"field",3,4),1e-12,1e-12))
 733         self.assertTrue(f2.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field",3,4),1e-12,1e-12))
 734         #
 735         self.assertTrue(f3.isEqual(MEDLoader.ReadField(fname,"field2"),1e-12,1e-12))
 736         self.assertTrue(f3.isEqual(MEDLoader.ReadField(fname,"field2",4,5),1e-12,1e-12))
 737         self.assertRaises(Exception,MEDLoader.ReadField,fname,"field2",5,5) # invalid time step
 738         self.assertTrue(f3.isEqual(MEDLoader.ReadField(MEDLoader.ON_CELLS,fname,"mesh",0,"field2",4,5),1e-12,1e-12))
 739         self.assertRaises(Exception,MEDLoader.ReadField,MEDLoader.ON_CELLS,fname,"mesh",0,"field2",5,5) # invalid time step
 740         pass
 741
 742     @WriteInTmpDir
 743     def testMultiWriteFieldOnMergeableNodesMeshes(self):
 744         fname="Pyfile120.med"
 745         arr=MEDLoader.DataArrayDouble([(0,0),(1,0),(0,1),(0,0),(1,0),(0,1)])
 746         m=MEDLoader.MEDCouplingUMesh("mesh",2)
 747         m.setCoords(arr)
 748         m.allocateCells()
 749         m.insertNextCell(MEDLoader.NORM_TRI3,[0,4,2])
 750         m.insertNextCell(MEDLoader.NORM_TRI3,[3,1,5])
 751         m.setName("mesh")
 752         #
 753         f=MEDLoader.MEDCouplingFieldDouble(MEDLoader.ON_CELLS)
 754         f.setMesh(m)
 755         f.setArray(MEDLoader.DataArrayDouble([5,6]))
 756         f.setName("field")
 757         #
 758         f.setTime(0.,0,0)
 759         MEDLoader.WriteField(fname,f,True)
 760         f.setTime(1.,1,0)
 761         MEDLoader.WriteField(fname,f,False)
 762         pass
 763
 764     pass
 765
 766 if __name__ == "__main__":
 767   unittest.main()