src/MEDLoader/Swig/MEDLoaderTest1.py

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