src/MEDLoader/Swig/MEDLoaderTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2012  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.
   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 import MEDLoader
  22 import unittest
  23 from math import pi,e,sqrt
  24 from MEDLoaderDataForTest import MEDLoaderDataForTest
  25
  26 class MEDLoaderTest(unittest.TestCase):
  27     def testMesh1DRW(self):
  28         mesh=MEDLoaderDataForTest.build1DMesh_1();
  29         mesh.checkCoherency();
  30         MEDLoader.MEDLoader.WriteUMesh("Pyfile1.med",mesh,True);
  31         mesh_rw=MEDLoader.MEDLoader.ReadUMeshFromFile("Pyfile1.med",mesh.getName(),0);
  32         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  33         pass
  34
  35     def testMesh2DCurveRW(self):
  36         mesh=MEDLoaderDataForTest.build2DCurveMesh_1();
  37         mesh.checkCoherency();
  38         MEDLoader.MEDLoader.WriteUMesh("Pyfile2.med",mesh,True);
  39         mesh_rw=MEDLoader.MEDLoader.ReadUMeshFromFile("Pyfile2.med",mesh.getName(),0);
  40         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  41         pass
  42
  43     def testMesh2DRW(self):
  44         mesh=MEDLoaderDataForTest.build2DMesh_1();
  45         mesh.checkCoherency();
  46         MEDLoader.MEDLoader.WriteUMesh("Pyfile3.med",mesh,True);
  47         mesh_rw=MEDLoader.MEDLoader.ReadUMeshFromFile("Pyfile3.med",mesh.getName(),0);
  48         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  49         pass
  50
  51     def testMesh3DSurfRW(self):
  52         mesh=MEDLoaderDataForTest.build3DSurfMesh_1();
  53         mesh.checkCoherency();
  54         MEDLoader.MEDLoader.WriteUMesh("Pyfile4.med",mesh,True);
  55         mesh_rw=MEDLoader.MEDLoader.ReadUMeshFromFile("Pyfile4.med",mesh.getName(),0);
  56         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  57         pass
  58
  59     def testMesh3DRW(self):
  60         mesh=MEDLoaderDataForTest.build3DMesh_1();
  61         mesh.checkCoherency();
  62         MEDLoader.MEDLoader.WriteUMesh("Pyfile5.med",mesh,True);
  63         mesh_rw=MEDLoader.MEDLoader.ReadUMeshFromFile("Pyfile5.med",mesh.getName(),0);
  64         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
  65         pass
  66
  67     def testFieldRW1(self):
  68         f1=MEDLoaderDataForTest.buildVecFieldOnCells_1();
  69         MEDLoader.MEDLoader.WriteField("Pyfile6.med",f1,True);
  70         f2=MEDLoader.MEDLoader.ReadFieldCell("Pyfile6.med",f1.getMesh().getName(),0,f1.getName(),0,1);
  71         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
  72         #
  73         f1=MEDLoaderDataForTest.buildVecFieldOnNodes_1();
  74         MEDLoader.MEDLoader.WriteField("Pyfile7.med",f1,True);
  75         f2=MEDLoader.MEDLoader.ReadFieldNode("Pyfile7.med",f1.getMesh().getName(),0,f1.getName(),2,3);
  76         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
  77         self.assertRaises(Exception,MEDLoader.MEDLoader.ReadFieldCell,"Pyfile7.med",f1.getMesh().getName(),0,f1.getName(),2,3);
  78         pass
  79
  80     def testFieldRW2(self):
  81         fileName="Pyfile8.med";
  82         VAL1=12345.67890314;
  83         VAL2=-1111111111111.;
  84         f1=MEDLoaderDataForTest.buildVecFieldOnCells_1();
  85         MEDLoader.MEDLoader.WriteField(fileName,f1,True);
  86         f1.setTime(10.,8,9);
  87         f1.getArray().setIJ(0,0,VAL1);
  88         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
  89         f1.setTime(10.14,18,19);
  90         f1.getArray().setIJ(0,0,VAL2);
  91         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
  92         #retrieving time steps...
  93         f2=MEDLoader.MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),0,f1.getName(),8,9);
  94         f1.setTime(10.,8,9);
  95         f1.getArray().setIJ(0,0,VAL1);
  96         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
  97         f2=MEDLoader.MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),0,f1.getName(),0,1);
  98         f3=MEDLoaderDataForTest.buildVecFieldOnCells_1();
  99         self.assertTrue(f3.isEqual(f2,1e-12,1e-12));
 100         f2=MEDLoader.MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),0,f1.getName(),18,19);
 101         f1.setTime(10.14,18,19);
 102         f1.getArray().setIJ(0,0,VAL2);
 103         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 104         #test of throw on invalid (dt,it)
 105         self.assertRaises(Exception,MEDLoader.MEDLoader.ReadFieldCell,fileName,f1.getMesh().getName(),0,f1.getName(),28,19);
 106         #ON NODES
 107         f1=MEDLoaderDataForTest.buildVecFieldOnNodes_1();
 108         fileName2="Pyfile9.med";
 109         MEDLoader.MEDLoader.WriteField(fileName2,f1,True);
 110         f1.setTime(110.,108,109);
 111         tmp=f1.getArray().getPointer();
 112         f1.getArray().setIJ(0,3,VAL1);
 113         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
 114         f1.setTime(210.,208,209);
 115         f1.getArray().setIJ(0,3,VAL2);
 116         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
 117         f2=MEDLoader.MEDLoader.ReadFieldNode(fileName2,f1.getMesh().getName(),0,f1.getName(),108,109);
 118         f1.setTime(110.,108,109);
 119         f1.getArray().setIJ(0,3,VAL1);
 120         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 121         f2=MEDLoader.MEDLoader.ReadFieldNode(fileName2,f1.getMesh().getName(),0,f1.getName(),2,3);
 122         f3=MEDLoaderDataForTest.buildVecFieldOnNodes_1();
 123         self.assertTrue(f3.isEqual(f2,1e-12,1e-12));
 124         f2=MEDLoader.MEDLoader.ReadFieldNode(fileName2,f1.getMesh().getName(),0,f1.getName(),208,209);
 125         f1.setTime(210.,208,209);
 126         f1.getArray().setIJ(0,3,VAL2);
 127         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 128         pass
 129
 130     #
 131     # Multi field in a same file, but this field has several
 132     #
 133     def testFieldRW3(self):
 134         fileName="Pyfile11.med";
 135         VAL1=12345.67890314;
 136         VAL2=-1111111111111.;
 137         name1="AField";
 138         name3="AMesh1";
 139         f1=MEDLoaderDataForTest.buildVecFieldOnCells_1();
 140         f1.getMesh().setName(name3);
 141         f1.setName(name1);
 142         f1.setTime(10.,8,9);
 143         tmp=f1.getArray().getPointer();
 144         f1.getArray().setIJ(0,0,VAL1);
 145         MEDLoader.MEDLoader.WriteField(fileName,f1,True);
 146         f1.setTime(10.14,18,19);
 147         f1.getArray().setIJ(0,0,VAL2);
 148         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 149         f1.getMesh().setName(name3);
 150         f1.setTime(10.55,28,29);
 151         f1.getArray().setIJ(0,0,3*VAL1);
 152         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 153         vec=MEDLoader.MEDLoader.GetMeshNamesOnField(fileName,name1);
 154         f1.setTime(10.66,38,39);
 155         f1.getArray().setIJ(0,0,3*VAL2);
 156         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 157         f1.setTime(10.77,48,49);
 158         f1.getArray().setIJ(0,0,4*VAL2);
 159         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 160         #ON NODES
 161         f1=MEDLoaderDataForTest.buildVecFieldOnNodes_1();
 162         f1.setName(name1);
 163         f1.getMesh().setName(name3);
 164         f1.setTime(110.,8,9);
 165         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 166         f1.setTime(110.,108,109);
 167         tmp=f1.getArray().getPointer();
 168         f1.getArray().setIJ(0,3,VAL1);
 169         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 170         f1.setTime(210.,208,209);
 171         f1.getArray().setIJ(0,3,VAL2);
 172         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 173         #
 174         it1=MEDLoader.MEDLoader.GetCellFieldIterations(fileName,name3,name1);
 175         self.assertEqual(5,len(it1));
 176         self.assertEqual(8,it1[0][0]); self.assertEqual(9,it1[0][1]);
 177         self.assertEqual(18,it1[1][0]); self.assertEqual(19,it1[1][1]);
 178         self.assertEqual(28,it1[2][0]); self.assertEqual(29,it1[2][1]);
 179         self.assertEqual(38,it1[3][0]); self.assertEqual(39,it1[3][1]);
 180         self.assertEqual(48,it1[4][0]); self.assertEqual(49,it1[4][1]);
 181         it3=MEDLoader.MEDLoader.GetNodeFieldIterations(fileName,name3,name1);
 182         self.assertEqual(3,len(it3));
 183         self.assertEqual(8,it3[0][0]); self.assertEqual(9,it3[0][1]);
 184         self.assertEqual(108,it3[1][0]); self.assertEqual(109,it3[1][1]);
 185         self.assertEqual(208,it3[2][0]); self.assertEqual(209,it3[2][1]);
 186         #
 187         #
 188         f1=MEDLoader.MEDLoader.ReadFieldCell(fileName,name3,0,name1,8,9);
 189         self.assertAlmostEqual(VAL1,f1.getArray().getIJ(0,0),13);
 190         f1=MEDLoader.MEDLoader.ReadFieldCell(fileName,name3,0,name1,18,19);
 191         self.assertAlmostEqual(VAL2,f1.getArray().getIJ(0,0),13);
 192         f1=MEDLoader.MEDLoader.ReadFieldCell(fileName,name3,0,name1,28,29);
 193         self.assertAlmostEqual(3*VAL1,f1.getArray().getIJ(0,0),13);
 194         f1=MEDLoader.MEDLoader.ReadFieldCell(fileName,name3,0,name1,38,39);
 195         self.assertAlmostEqual(3*VAL2,f1.getArray().getIJ(0,0),13);
 196         f1=MEDLoader.MEDLoader.ReadFieldCell(fileName,name3,0,name1,48,49);
 197         self.assertAlmostEqual(4*VAL2,f1.getArray().getIJ(0,0),13);
 198         #
 199         f1=MEDLoader.MEDLoader.ReadFieldNode(fileName,name3,0,name1,8,9);
 200         self.assertAlmostEqual(71.,f1.getArray().getIJ(0,3),13);
 201         f1=MEDLoader.MEDLoader.ReadFieldNode(fileName,name3,0,name1,108,109);
 202         self.assertAlmostEqual(VAL1,f1.getArray().getIJ(0,3),13);
 203         f1=MEDLoader.MEDLoader.ReadFieldNode(fileName,name3,0,name1,208,209);
 204         self.assertAlmostEqual(VAL2,f1.getArray().getIJ(0,3),13);
 205         pass
 206
 207     def testMultiMeshRW1(self):
 208         fileName="Pyfile10.med";
 209         mesh1=MEDLoaderDataForTest.build3DMesh_1();
 210         part1=[1,2,4,13,15]
 211         mesh2=mesh1.buildPartOfMySelf(part1,True);
 212         mesh2.setName("mesh2");
 213         part2=[3,4,13,14]
 214         mesh3=mesh1.buildPartOfMySelf(part2,True);
 215         mesh3.setName("mesh3");
 216         mesh4=MEDLoader.MEDCouplingUMesh.New();
 217         mesh4.setName("mesh4");
 218         mesh4.setMeshDimension(3);
 219         mesh4.allocateCells(1);
 220         conn=[0,11,1,3]
 221         mesh4.insertNextCell(MEDLoader.NORM_TETRA4,4,conn[0:4])
 222         mesh4.finishInsertingCells();
 223         mesh4.setCoords(mesh1.getCoords());
 224         meshes=[mesh1,mesh2,mesh3,mesh4]
 225         mnane="3DToto";
 226         MEDLoader.MEDLoader.WriteUMeshesPartition(fileName,mnane,meshes,True);
 227         #
 228         mesh5=MEDLoader.MEDLoader.ReadUMeshFromFile(fileName,mnane);
 229         mesh1.setName(mnane);
 230         part3=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17]
 231         mesh6=mesh5.buildPartOfMySelf(part3,True);
 232         mesh6.setName(mnane);
 233         self.assertTrue(mesh6.isEqual(mesh1,1e-12));
 234         grps=MEDLoader.MEDLoader.GetMeshGroupsNames(fileName,mnane);
 235         self.assertEqual(4,len(grps));
 236         grps.index("mesh2");
 237         grps.index("mesh3");
 238         grps.index("mesh4");
 239         grps.index("3DMesh_1");
 240         #
 241         vec=("mesh2",);
 242         mesh2_2=MEDLoader.MEDLoader.ReadUMeshFromGroups(fileName,mnane,0,vec);
 243         self.assertTrue(mesh2_2.isEqual(mesh2,1e-12));
 244         vec=["mesh3"];
 245         mesh3_2=MEDLoader.MEDLoader.ReadUMeshFromGroups(fileName,mnane,0,vec);
 246         self.assertTrue(mesh3_2.isEqual(mesh3,1e-12));
 247         vec=["mesh4"];
 248         mesh4_2=MEDLoader.MEDLoader.ReadUMeshFromGroups(fileName,mnane,0,vec);
 249         self.assertTrue(mesh4_2.isEqual(mesh4,1e-12));
 250         vec="3DMesh_1";
 251         mesh1_2=MEDLoader.MEDLoader.ReadUMeshFromGroups(fileName,mnane,0,vec);
 252         mesh1.setName("3DMesh_1");
 253         self.assertTrue(mesh1_2.isEqual(mesh1,1e-12));
 254         #
 255         vec=["Family_4","Family_2"];
 256         mesh2_2=MEDLoader.MEDLoader.ReadUMeshFromFamilies(fileName,mnane,0,vec);
 257         mesh2_2.setName("mesh2");
 258         self.assertTrue(mesh2_2.isEqual(mesh2,1e-12));
 259         #
 260         ret=MEDLoader.MEDLoader.GetMeshFamiliesNamesOnGroup(fileName,"3DToto","3DMesh_1");
 261         self.assertEqual(4,len(ret));
 262         self.assertEqual(ret[0],"Family_1");
 263         self.assertEqual(ret[1],"Family_2");
 264         self.assertEqual(ret[2],"Family_3");
 265         self.assertEqual(ret[3],"Family_4");
 266         #
 267         ret1=MEDLoader.MEDLoader.GetMeshGroupsNamesOnFamily(fileName,"3DToto","Family_2");
 268         self.assertEqual(2,len(ret1));
 269         self.assertEqual(ret1[0],"3DMesh_1");
 270         self.assertEqual(ret1[1],"mesh2");
 271         pass
 272
 273     def testFieldProfilRW1(self):
 274         fileName="Pyfile12.med";
 275         mesh1=MEDLoaderDataForTest.build3DMesh_1();
 276         da,b,newNbOfNodes=mesh1.mergeNodes(1e-12);
 277         MEDLoader.MEDLoader.WriteUMesh(fileName,mesh1,True);
 278         part1=[1,2,4,13,15]
 279         mesh2=mesh1.buildPartOfMySelf(part1,True);
 280         mesh2.setName(mesh1.getName());#<- important for the test
 281         #
 282         nbOfCells=mesh2.getNumberOfCells();
 283         self.assertEqual(5,nbOfCells);
 284         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_CELLS,MEDLoader.ONE_TIME);
 285         f1.setName("VectorFieldOnCells");
 286         f1.setMesh(mesh2);
 287         array=MEDLoader.DataArrayDouble.New();
 288         array.alloc(nbOfCells,2);
 289         f1.setArray(array);
 290         arr1=[71.,171.,10.,110.,20.,120.,30.,130.,40.,140.]
 291         array.setValues(arr1,nbOfCells,2);
 292         f1.setTime(3.14,2,7);
 293         f1.checkCoherency();
 294         #
 295         MEDLoader.MEDLoader.WriteField(fileName,f1,False);#<- False important for the test
 296         #
 297         f2=MEDLoader.MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),0,f1.getName(),2,7);
 298         tt=MEDLoader.MEDLoader.GetTypesOfField(fileName,f1.getMesh().getName(),f1.getName());
 299         self.assertEqual(tt,[MEDLoader.ON_CELLS]);
 300         f2.checkCoherency();
 301         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 302         #
 303         pass
 304
 305     def testFieldGaussRW1(self):
 306         fileName="Pyfile13.med";
 307         f1=MEDLoaderDataForTest.buildVecFieldOnGauss_1();
 308         MEDLoader.MEDLoader.WriteField(fileName,f1,True);
 309         f2=MEDLoader.MEDLoader.ReadField(MEDLoader.ON_GAUSS_PT,fileName,f1.getMesh().getName(),0,f1.getName(),1,5);
 310         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 311         pass
 312
 313     def testFieldGaussNERW1(self):
 314         fileName="Pyfile14.med";
 315         f1=MEDLoaderDataForTest.buildVecFieldOnGaussNE_1();
 316         MEDLoader.MEDLoader.WriteField(fileName,f1,True);
 317         f2=MEDLoader.MEDLoader.ReadField(MEDLoader.ON_GAUSS_NE,fileName,f1.getMesh().getName(),0,f1.getName(),1,5);
 318         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
 319         pass
 320
 321     def testMesh3DSurfShuffleRW(self):
 322         fileName="Pyfile15.med";
 323         mesh=MEDLoaderDataForTest.build3DSurfMesh_1();
 324         renumber1=[2,5,1,0,3,4]
 325         mesh.renumberCells(renumber1,False);
 326         mesh.checkCoherency();
 327         MEDLoader.MEDLoader.WriteUMesh(fileName,mesh,True);
 328         mesh_rw=MEDLoader.MEDLoader.ReadUMeshFromFile(fileName,mesh.getName(),0);
 329         self.assertTrue(mesh.isEqual(mesh_rw,1e-12));
 330         pass
 331
 332     def testMultiFieldShuffleRW1(self):
 333         fileName="Pyfile17.med";
 334         m=MEDLoaderDataForTest.build3DMesh_2();
 335         self.assertEqual(20,m.getNumberOfCells());
 336         self.assertEqual(45,m.getNumberOfNodes());
 337         polys=[1,4,6]
 338         m.convertToPolyTypes(polys);
 339         renum=[1,3,2,8,9,12,13,16,19,0,4,7,5,15,14,17,10,18,6,11]
 340         m.renumberCells(renum,False);
 341         m.orientCorrectlyPolyhedrons();
 342         # Writing
 343         MEDLoader.MEDLoader.WriteUMesh(fileName,m,True);
 344         f1Tmp=m.getMeasureField(False);
 345         f1=f1Tmp.buildNewTimeReprFromThis(MEDLoader.ONE_TIME,False);
 346         f1.setTime(0.,1,2);
 347         f_1=f1.cloneWithMesh(True);
 348         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 349         f1.applyFunc("2*x");
 350         f1.setTime(0.01,3,4);
 351         f_2=f1.cloneWithMesh(True);
 352         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 353         f1.applyFunc("2*x/3");
 354         f1.setTime(0.02,5,6);
 355         f_3=f1.cloneWithMesh(True);
 356         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 357         # Reading
 358         its=[(1,2),(3,4),(5,6)];
 359         fs=MEDLoader.MEDLoader.ReadFieldsOnSameMesh(MEDLoader.ON_CELLS,fileName,f_1.getMesh().getName(),0,f_1.getName(),its);
 360         self.assertEqual(3,len(fs));
 361         self.assertTrue(fs[0].isEqual(f_1,1e-12,1e-12));
 362         self.assertTrue(fs[1].isEqual(f_2,1e-12,1e-12));
 363         self.assertTrue(fs[2].isEqual(f_3,1e-12,1e-12));
 364         pass
 365
 366     def testWriteUMeshesRW1(self):
 367         fileName="Pyfile18.med";
 368         m3d=MEDLoaderDataForTest.build3DMesh_2();
 369         pt=[0.,0.,-0.3]
 370         vec=[0.,0.,1.]
 371         nodes=m3d.findNodesOnPlane(pt,vec,1e-12);
 372         m2d=m3d.buildFacePartOfMySelfNode(nodes,True);
 373         renumber=[1,2,0,4,3]
 374         m2d.renumberCells(renumber,False);
 375         m2d.setName("ExampleOfMultiDimW");
 376         meshes=[m2d,m3d]
 377         MEDLoader.MEDLoader.WriteUMeshes(fileName,meshes,True);
 378         m3d_bis=MEDLoader.MEDLoader.ReadUMeshFromFile(fileName,m2d.getName(),0);
 379         self.assertTrue(not m3d_bis.isEqual(m3d,1e-12));
 380         m3d_bis.setName(m3d.getName());
 381         self.assertTrue(m3d_bis.isEqual(m3d,1e-12));
 382         m2d_bis=MEDLoader.MEDLoader.ReadUMeshFromFile(fileName,m2d.getName(),-1);#-1 for faces
 383         self.assertTrue(m2d_bis.isEqual(m2d,1e-12));
 384         # Creation of a field on faces.
 385         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_CELLS,MEDLoader.ONE_TIME);
 386         f1.setName("FieldOnFacesShuffle");
 387         f1.setMesh(m2d);
 388         array=MEDLoader.DataArrayDouble.New();
 389         arr1=[71.,171.,10.,110.,20.,120.,30.,130.,40.,140.]
 390         array.setValues(arr1,m2d.getNumberOfCells(),2);
 391         array.setInfoOnComponent(0,"plkj [mm]");
 392         array.setInfoOnComponent(1,"pqqqss [mm]");
 393         f1.setArray(array);
 394         tmp=array.setValues(arr1,m2d.getNumberOfCells(),2);
 395         f1.setTime(3.14,2,7);
 396         f1.checkCoherency();
 397         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 398         f2=MEDLoader.MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),-1,f1.getName(),2,7);
 399         self.assertTrue(f2.isEqual(f1,1e-12,1e-12));
 400         pass
 401
 402     def testFieldNodeProfilRW1(self):
 403         fileName="Pyfile19.med";
 404         fileName2="Pyfile20.med";
 405         m=MEDLoaderDataForTest.build2DMesh_1();
 406         nbOfNodes=m.getNumberOfNodes();
 407         MEDLoader.MEDLoader.WriteUMesh(fileName,m,True);
 408         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_NODES,MEDLoader.ONE_TIME);
 409         f1.setName("VFieldOnNodes");
 410         f1.setMesh(m);
 411         array=MEDLoader.DataArrayDouble.New();
 412         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.]
 413         array.setValues(arr1,nbOfNodes,2);
 414         f1.setArray(array);
 415         array.setInfoOnComponent(0,"tyty [mm]");
 416         array.setInfoOnComponent(1,"uiop [MW]");
 417         f1.setTime(3.14,2,7);
 418         f1.checkCoherency();
 419         arr2=[1,4]
 420         f2=f1.buildSubPart(arr2);
 421         f2.getMesh().setName(f1.getMesh().getName());
 422         MEDLoader.MEDLoader.WriteField(fileName,f2,False);#<- False important for the test
 423         #
 424         f3=MEDLoader.MEDLoader.ReadFieldNode(fileName,f2.getMesh().getName(),0,f2.getName(),2,7);
 425         f3.checkCoherency();
 426         self.assertTrue(f3.isEqual(f2,1e-12,1e-12));
 427         #
 428         arr3=[1,3,0,5,2,4]
 429         f2.renumberNodes(arr3);
 430         MEDLoader.MEDLoader.WriteUMesh(fileName2,m,True);
 431         MEDLoader.MEDLoader.WriteField(fileName2,f2,False);#<- False important for the test
 432         f3=MEDLoader.MEDLoader.ReadFieldNode(fileName2,f2.getMesh().getName(),0,f2.getName(),2,7);
 433         f3.checkCoherency();
 434         self.assertTrue(f3.isEqual(f2,1e-12,1e-12));
 435         #
 436         pass
 437
 438     def testFieldNodeProfilRW2(self):
 439         fileName="Pyfile23.med";
 440         mesh=MEDLoaderDataForTest.build3DSurfMesh_1();
 441         MEDLoader.MEDLoader.WriteUMesh(fileName,mesh,True);
 442         #
 443         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_NODES,MEDLoader.ONE_TIME);
 444         f1.setName("FieldMix");
 445         f1.setMesh(mesh);
 446         arr2=[1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150.,
 447               1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.];
 448         array=MEDLoader.DataArrayDouble.New();
 449         array.setValues(arr2,12,2);
 450         f1.setArray(array);
 451         array.setInfoOnComponent(0,"plkj [mm]");
 452         array.setInfoOnComponent(1,"pqqqss [mm]");
 453         tmp=array.getPointer();
 454         f1.setTime(3.17,2,7);
 455         #
 456         renumArr=[3,7,2,1,5,11,10,0,9,6,8,4]
 457         f1.renumberNodes(renumArr);
 458         f1.checkCoherency();
 459         MEDLoader.MEDLoader.WriteField(fileName,f1,False);#<- False important for the test
 460         f2=MEDLoader.MEDLoader.ReadFieldNode(fileName,f1.getMesh().getName(),0,f1.getName(),2,7);
 461         self.assertTrue(f2.isEqual(f1,1e-12,1e-12));
 462         #
 463         pass
 464
 465     def testMixCellAndNodesFieldRW1(self):
 466         fileName="Pyfile21.med";
 467         mesh=MEDLoaderDataForTest.build3DSurfMesh_1();
 468         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_CELLS,MEDLoader.ONE_TIME);
 469         f1.setName("FieldMix");
 470         f1.setMesh(mesh);
 471         array=MEDLoader.DataArrayDouble.New();
 472         f1.setArray(array);
 473         arr1=[71.,171.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
 474         array.setValues(arr1,6,2);
 475         array.setInfoOnComponent(0,"plkj [mm]");
 476         array.setInfoOnComponent(1,"pqqqss [mm]");
 477         f1.setTime(3.14,2,7);
 478         f1.checkCoherency();
 479         #
 480         f2=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_NODES,MEDLoader.ONE_TIME);
 481         f2.setName("FieldMix");
 482         f2.setMesh(mesh);
 483         array=MEDLoader.DataArrayDouble.New();
 484         f2.setArray(array);
 485         arr2=[1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150.,
 486               1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.]
 487         array.setValues(arr2,12,2)
 488         array.setInfoOnComponent(0,"plkj [mm]");
 489         array.setInfoOnComponent(1,"pqqqss [mm]");
 490         f2.setTime(3.14,2,7);
 491         f2.checkCoherency();
 492         #
 493         MEDLoader.MEDLoader.WriteField(fileName,f1,True);
 494         ts=MEDLoader.MEDLoader.GetTypesOfField(fileName,f1.getMesh().getName(),f1.getName());
 495         self.assertEqual(1,len(ts));
 496         self.assertEqual(MEDLoader.ON_CELLS,ts[0]);
 497         fs=MEDLoader.MEDLoader.GetAllFieldNamesOnMesh(fileName,f1.getMesh().getName());
 498         self.assertEqual(1,len(fs));
 499         self.assertTrue(fs[0]=="FieldMix");
 500         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f2);
 501         fs=MEDLoader.MEDLoader.GetAllFieldNamesOnMesh(fileName,f1.getMesh().getName());
 502         self.assertEqual(1,len(fs));
 503         self.assertTrue(fs[0]=="FieldMix");
 504         #
 505         ts=MEDLoader.MEDLoader.GetTypesOfField(fileName,f1.getMesh().getName(),f1.getName());
 506         self.assertEqual(2,len(ts));
 507         self.assertEqual(MEDLoader.ON_NODES,ts[0]);
 508         self.assertEqual(MEDLoader.ON_CELLS,ts[1]);
 509         #
 510         f3=MEDLoader.MEDLoader.ReadFieldNode(fileName,f1.getMesh().getName(),0,f1.getName(),2,7);
 511         self.assertTrue(f3.isEqual(f2,1e-12,1e-12));
 512         f3=MEDLoader.MEDLoader.ReadFieldCell(fileName,f1.getMesh().getName(),0,f1.getName(),2,7);
 513         self.assertTrue(f3.isEqual(f1,1e-12,1e-12));
 514         #
 515         pass
 516
 517     def testGetAllFieldNamesRW1(self):
 518         fileName="Pyfile22.med";
 519         mesh=MEDLoaderDataForTest.build2DMesh_2();
 520         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_NODES,MEDLoader.ONE_TIME);
 521         f1.setName("Field1");
 522         f1.setTime(3.44,5,6);
 523         f1.setMesh(mesh);
 524         f1.fillFromAnalytic(2,"x+y");
 525         MEDLoader.MEDLoader.WriteField(fileName,f1,True);
 526         f1.setTime(1002.3,7,8);
 527         f1.fillFromAnalytic(2,"x+77.*y");
 528         MEDLoader.MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 529         f1.setName("Field2");
 530         MEDLoader.MEDLoader.WriteField(fileName,f1,False);
 531         f1.setName("Field3");
 532         mesh.setName("2DMesh_2Bis");
 533         MEDLoader.MEDLoader.WriteField(fileName,f1,False);
 534         f1=MEDLoader.MEDCouplingFieldDouble.New(MEDLoader.ON_CELLS,MEDLoader.ONE_TIME);
 535         f1.setName("Field8");
 536         f1.setTime(8.99,7,9);
 537         f1.setMesh(mesh);
 538         f1.fillFromAnalytic(3,"3*x+y");
 539         MEDLoader.MEDLoader.WriteField(fileName,f1,False);
 540         fs=MEDLoader.MEDLoader.GetAllFieldNames(fileName);
 541         self.assertEqual(4,len(fs));
 542         self.assertTrue(fs[0]=="Field1");
 543         self.assertTrue(fs[1]=="Field2");
 544         self.assertTrue(fs[2]=="Field3");
 545         self.assertTrue(fs[3]=="Field8");
 546         pass
 547     pass
 548
 549 unittest.main()