~~~~~~~~~~~~~~~~~~~~~~
Cet exercice repose comme tous les autres sur le language de script Python. On charge
-le module Python ``MEDLoader``.
+le module Python ``medcoupling``.::
-Pour information, le module ``MEDCoupling`` complet est inclus dans ``MEDLoader``. Pas besoin de l'importer
-si ``MEDLoader`` a été chargé. ::
-
- import MEDLoader as ml
+ import medcoupling as mc
Lecture, écriture d'un maillage
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
targetCoords = [-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7 ]
targetConn = [0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
- targetMesh = ml.MEDCouplingUMesh("MyMesh",2)
+ targetMesh = mc.MEDCouplingUMesh("MyMesh",2)
targetMesh.allocateCells(5)
- targetMesh.insertNextCell(ml.NORM_TRI3,3,targetConn[4:7])
- targetMesh.insertNextCell(ml.NORM_TRI3,3,targetConn[7:10])
- targetMesh.insertNextCell(ml.NORM_QUAD4,4,targetConn[0:4])
- targetMesh.insertNextCell(ml.NORM_QUAD4,4,targetConn[10:14])
- targetMesh.insertNextCell(ml.NORM_QUAD4,4,targetConn[14:18])
- myCoords = ml.DataArrayDouble(targetCoords,9,2)
+ targetMesh.insertNextCell(mc.NORM_TRI3,3,targetConn[4:7])
+ targetMesh.insertNextCell(mc.NORM_TRI3,3,targetConn[7:10])
+ targetMesh.insertNextCell(mc.NORM_QUAD4,4,targetConn[0:4])
+ targetMesh.insertNextCell(mc.NORM_QUAD4,4,targetConn[10:14])
+ targetMesh.insertNextCell(mc.NORM_QUAD4,4,targetConn[14:18])
+ myCoords = mc.DataArrayDouble(targetCoords,9,2)
myCoords.setInfoOnComponents(["X [km]","YY [mm]"])
targetMesh.setCoords(myCoords)
On peut alors écrire les deux maillages dans le fichier "TargetMesh2.med". ::
- meshMEDFile = ml.MEDFileUMesh()
+ meshMEDFile = mc.MEDFileUMesh()
meshMEDFile.setMeshAtLevel(0,targetMesh)
meshMEDFile.setMeshAtLevel(-1,targetMesh1)
meshMEDFile.write("TargetMesh2.med",2) # 2 stands for 'write from scratch'
correspond à la 1D, etc ...). Le premier groupe ``grp0_Lev0`` contient les cellules [0,1,3]
le second ``grp1_Lev0`` les cellules [1,2,3,4] : ::
- grp0_0 = ml.DataArrayInt([0,1,3])
+ grp0_0 = mc.DataArrayInt([0,1,3])
grp0_0.setName("grp0_Lev0")
- grp1_0 = ml.DataArrayInt([1,2,3,4])
+ grp1_0 = mc.DataArrayInt([1,2,3,4])
grp1_0.setName("grp1_Lev0")
meshMEDFile.setGroupsAtLevel(0, [grp0_0,grp1_0])
``grp0_LevM1`` aux cellules [0,1], le second appelé ``grp1_LevM1`` aux cellules [0,1,2], et le 3ème ``grp2_LevM1``
aux cellules [1,2,3] : ::
- grp0_M1 = ml.DataArrayInt([0,1])
+ grp0_M1 = mc.DataArrayInt([0,1])
grp0_M1.setName("grp0_LevM1")
- grp1_M1 = ml.DataArrayInt([0,1,2])
+ grp1_M1 = mc.DataArrayInt([0,1,2])
grp1_M1.setName("grp1_LevM1")
- grp2_M1 = ml.DataArrayInt([1,2,3])
+ grp2_M1 = mc.DataArrayInt([1,2,3])
grp2_M1.setName("grp2_LevM1")
meshMEDFile.setGroupsAtLevel(-1,[grp0_M1,grp1_M1,grp2_M1])
Nous pouvons ensuite re-lire le fichier MED : ::
- meshMEDFileRead = ml.MEDFileMesh.New("TargetMesh2.med") # a new is needed because it returns a MEDFileUMesh (MEDFileMesh is abstract)
+ meshMEDFileRead = mc.MEDFileMesh.New("TargetMesh2.med") # a new is needed because it returns a MEDFileUMesh (MEDFileMesh is abstract)
meshRead0 = meshMEDFileRead.getMeshAtLevel(0)
meshRead1 = meshMEDFileRead.getMeshAtLevel(-1)
print("Is level 0 in the file equal to 'targetMesh'?", meshRead0.isEqual(targetMesh,1e-12))
Créons un champ de vecteurs simple, aux cellules (P0), avec un seul pas de temps, appelé ``f``. ::
- f = ml.MEDCouplingFieldDouble(ml.ON_CELLS, ml.ONE_TIME)
+ f = mc.MEDCouplingFieldDouble(mc.ON_CELLS, mc.ONE_TIME)
f.setTime(5.6,7,8)
f.setArray(targetMesh.computeCellCenterOfMass())
f.setMesh(targetMesh)
Stocker ``f`` dans un object ``MEDFileField1TS`` (un champ avec un seul pas de temps -- *one time-step, 1TS*)
pour préparer l'écriture MED ::
- fMEDFile = ml.MEDFileField1TS()
+ fMEDFile = mc.MEDFileField1TS()
fMEDFile.setFieldNoProfileSBT(f) # No profile desired on the field, Sort By Type
Ajouter le champ au fichier "TargetMesh2.med" ::
Lire le champ : ::
- fMEDFileRead = ml.MEDFileField1TS("TargetMesh2.med",f.getName(),7,8)
- fRead1 = fMEDFileRead.getFieldOnMeshAtLevel(ml.ON_CELLS,0,meshMEDFileRead) # Quickest way, not re-reading mesh in the file.
- fRead2 = fMEDFileRead.getFieldAtLevel(ml.ON_CELLS,0) # Like above, but this time the mesh is read!
+ fMEDFileRead = mc.MEDFileField1TS("TargetMesh2.med",f.getName(),7,8)
+ fRead1 = fMEDFileRead.getFieldOnMeshAtLevel(mc.ON_CELLS,0,meshMEDFileRead) # Quickest way, not re-reading mesh in the file.
+ fRead2 = fMEDFileRead.getFieldAtLevel(mc.ON_CELLS,0) # Like above, but this time the mesh is read!
print("Does the field remain OK with the quick method?", fRead1.isEqual(f,1e-12,1e-12))
print("Does the field remain OK with the slow method?", fRead2.isEqual(f,1e-12,1e-12))
Construisons une réduction aux cellules [1,2,3] de ``f`` et appelons la ``fPart`` : ::
- pfl = ml.DataArrayInt([1,2,3])
+ pfl = mc.DataArrayInt([1,2,3])
pfl.setName("My1stPfl")
fPart = f.buildSubPart(pfl)
fPart.setName("fPart")
La stocker dans la structure ``MEDFileField1TS`` et invoquer ``setFieldProfile()``. ::
- fMEDFile2 = ml.MEDFileField1TS()
+ fMEDFile2 = mc.MEDFileField1TS()
fMEDFile2.setFieldProfile(fPart,meshMEDFileRead,0,pfl) # 0 is the relative level (here 0 means 2D)
fMEDFile2.write("TargetMesh2.med",0) # 0 is paramount to indicate that we *append* (and no overwrite) to the MED file
Lire le champ ``fPart`` du fichier "TargetMesh2.med" et les identifiants de cellules correspondant. ::
- fMEDFileRead2 = ml.MEDFileField1TS("TargetMesh2.med",fPart.getName(),7,8)
- fPartRead, pflRead = fMEDFileRead2.getFieldWithProfile(ml.ON_CELLS,0,meshMEDFileRead)
+ fMEDFileRead2 = mc.MEDFileField1TS("TargetMesh2.med",fPart.getName(),7,8)
+ fPartRead, pflRead = fMEDFileRead2.getFieldWithProfile(mc.ON_CELLS,0,meshMEDFileRead)
print("Is the partial field correctly read?", fPartRead.isEqualWithoutConsideringStr(fPart.getArray(),1e-12))
print("Is the list of cell identifiers matching?", pflRead.isEqualWithoutConsideringStr(pfl))
