]> SALOME platform Git repositories - tools/medcoupling.git/blob - doc/tutorial/medloader_advancedAPI1_fr.rst
Salome HOME
Merge branch 'master' of https://codev-tuleap.cea.fr/plugins/git/salome/medcoupling
[tools/medcoupling.git] / doc / tutorial / medloader_advancedAPI1_fr.rst
1
2 Lecture, écriture d'un fichier MED grâce à l'API avancée de MEDLoader
3 ---------------------------------------------------------------------
4
5 L'API avancée de MEDLoader est représentée par les classes ``MEDFile*`` de la bibliothèque MEDLoader.
6
7 * Au plus haut niveau, pour l'ensemble du fichier: ``MEDFileData``,
8 * Pour l'ensemble des maillages du fichier : ``MEDFileMeshes``,
9 * Pour chacun des maillages : ``MEDFileMeshMultiTS``, ``MEDFileMesh``, ``MEDFileUMesh``, ``MEDFileCMesh``,  
10 * Pour l'ensemble des champs du fichier : ``MEDFileFields``, ``MEDFileFieldGlobs``, 
11 * Et enfin pour chacun des champs : ``MEDFileField1TS``, ``MEDFileFieldMultiTS``
12
13
14 Objectif
15 ~~~~~~~~
16
17 Ecrire un maillage et un champ à partir de rien, les relire et comparer les résultats.
18
19 Points abordés : en utilisant l'API avancée de MEDLoader,
20
21 * Ecrire un fichier 
22 * Lire un fichier
23
24 Début d'implémentation
25 ~~~~~~~~~~~~~~~~~~~~~~
26
27 Cet exercice repose comme tous les autres sur le language de script Python. On charge 
28 le module Python ``MEDLoader``.
29
30 Pour information, le module ``MEDCoupling`` complet est inclus dans ``MEDLoader``. Pas besoin de l'importer
31 si ``MEDLoader`` a été chargé. ::
32
33         import MEDLoader as ml
34
35 Lecture, écriture d'un maillage
36 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
37
38 Nous créons tout d'abord le même maillage ``targetMesh`` que pour l'API simple. ::
39
40         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 ]
41         targetConn = [0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
42         targetMesh = ml.MEDCouplingUMesh("MyMesh",2)
43         targetMesh.allocateCells(5)
44         targetMesh.insertNextCell(ml.NORM_TRI3,3,targetConn[4:7])
45         targetMesh.insertNextCell(ml.NORM_TRI3,3,targetConn[7:10])
46         targetMesh.insertNextCell(ml.NORM_QUAD4,4,targetConn[0:4])
47         targetMesh.insertNextCell(ml.NORM_QUAD4,4,targetConn[10:14])
48         targetMesh.insertNextCell(ml.NORM_QUAD4,4,targetConn[14:18])
49         myCoords = ml.DataArrayDouble(targetCoords,9,2)
50         myCoords.setInfoOnComponents(["X [km]","YY [mm]"])
51         targetMesh.setCoords(myCoords)        
52
53 .. note:: Le maillage ``targetMesh`` est ordonné par type géométrique.
54
55 Nous construisons ensuite ``targetMesh1`` représentant les sous-constituants (*faces*) du maillage
56 ``targetMesh``, et nous en extrayons seulement les cellules (donc ici des surfaces) [3,4,7,8]. 
57 Pour plus de détails sur la connectivité descendante, 
58 consulter la section :ref:`exo-umesh-desc-connec` du deuxième exercise.
59 Cet ensemble peut par exemple représenter un ensemble d'intérêt pour un calcul : ::
60
61         targetMeshConsti, _, _, _, _ = targetMesh.buildDescendingConnectivity()
62         targetMesh1 = targetMeshConsti[[3,4,7,8]]
63         targetMesh1.setName(targetMesh.getName())
64
65 .. note:: En Python, le underscore ``_`` signifie que l'on attend une valeur de retour, mais qu'on n'en aura pas l'usage 
66         (on ne la *bind* pas).
67 .. note:: ``targetMesh1`` sera sauvé comme étant une partie du même maillage global dans le fichier MED. 
68         Il doit donc avoir le même nom. C'est là qu'on voit qu'un maillage au sens MED fichier peut mélanger les dimensions. 
69
70 On peut alors écrire les deux maillages dans le fichier "TargetMesh2.med". ::
71
72         meshMEDFile = ml.MEDFileUMesh()
73         meshMEDFile.setMeshAtLevel(0,targetMesh)
74         meshMEDFile.setMeshAtLevel(-1,targetMesh1)
75         meshMEDFile.write("TargetMesh2.med",2)         # 2 stands for 'write from scratch'
76
77 Lecture, écriture de groupes de mailles
78 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
79
80 Créons deux groupes de cellules sur le maillage 2D, c'est à dire au niveau relatif 0 (ici, le niveau relatif 0 correspond
81 à la 2D, le niveau -1 
82 correspond à la 1D,  etc ...). Le premier groupe ``grp0_Lev0`` contient les cellules [0,1,3] 
83 le second ``grp1_Lev0`` les cellules [1,2,3,4] : ::
84
85         grp0_0 = ml.DataArrayInt([0,1,3]) 
86         grp0_0.setName("grp0_Lev0")
87         grp1_0 = ml.DataArrayInt([1,2,3,4])
88         grp1_0.setName("grp1_Lev0")
89         meshMEDFile.setGroupsAtLevel(0, [grp0_0,grp1_0])
90
91 .. note:: On voit évidemment ici l'importance de nommer les tableaux : c'est le nom qui sera utilisé pour le groupe. 
92
93 Créons trois groupes de niveau -1, c'est à dire des groupes de faces. Le premier appelé 
94 ``grp0_LevM1`` aux cellules [0,1], le second appelé ``grp1_LevM1`` aux cellules [0,1,2], et le 3ème ``grp2_LevM1``
95 aux cellules [1,2,3] : ::
96
97         grp0_M1 = ml.DataArrayInt([0,1])
98         grp0_M1.setName("grp0_LevM1")
99         grp1_M1 = ml.DataArrayInt([0,1,2])
100         grp1_M1.setName("grp1_LevM1")
101         grp2_M1 = ml.DataArrayInt([1,2,3])
102         grp2_M1.setName("grp2_LevM1")
103         meshMEDFile.setGroupsAtLevel(-1,[grp0_M1,grp1_M1,grp2_M1])
104         
105 Ecrivons le tout : ::
106         
107         meshMEDFile.write("TargetMesh2.med",2)         # 2 stands for 'write from scratch'
108         
109 Nous pouvons ensuite re-lire le fichier MED : ::
110
111         meshMEDFileRead = ml.MEDFileMesh.New("TargetMesh2.med") # a new is needed because it returns a MEDFileUMesh (MEDFileMesh is abstract)
112         meshRead0 = meshMEDFileRead.getMeshAtLevel(0)
113         meshRead1 = meshMEDFileRead.getMeshAtLevel(-1)
114         print "Is level 0 in the file equal to 'targetMesh'?", meshRead0.isEqual(targetMesh,1e-12)
115         print "Is level 0 in the file equal to 'targetMesh1'?", meshRead1.isEqual(targetMesh1,1e-12)
116
117 Affichons les niveaux disponibles pour le groupe ``grp0_Lev0`` : ::
118
119         print meshMEDFileRead.getGrpNonEmptyLevels("grp0_Lev0")
120
121 Et récupérons enfin les identifiants de cellules contenus dans le groupe ``grp0_Lev0`` : ::
122
123         grp0_0_read = meshMEDFileRead.getGroupArr(0,"grp0_Lev0")
124         print "Is group 'grp0_Lev0' equal to what is read in the file?" , grp0_0_read.isEqual(grp0_0)
125
126 Lire/écrire des champs avec l'API avancée
127 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
128
129 Créons un champ de vecteurs simple, aux cellules (P0), avec un seul pas de temps, appelé ``f``. ::
130
131         f = ml.MEDCouplingFieldDouble(ml.ON_CELLS, ml.ONE_TIME)
132         f.setTime(5.6,7,8)
133         f.setArray(targetMesh.computeCellCenterOfMass())
134         f.setMesh(targetMesh)
135         f.setName("AFieldName")
136
137 Stocker ``f`` dans un object ``MEDFileField1TS`` (un champ avec un seul pas de temps -- *one time-step, 1TS*) 
138 pour préparer l'écriture MED ::
139
140         fMEDFile = ml.MEDFileField1TS()
141         fMEDFile.setFieldNoProfileSBT(f)     # No profile desired on the field, Sort By Type
142
143 Ajouter le champ au fichier "TargetMesh2.med" ::
144
145         fMEDFile.write("TargetMesh2.med",0) # 0 is paramount to indicate that we *append* (and no overwrite) to the MED file
146
147 .. note:: Noter l'utilisation du 0 pour indiquer que nous désirons ajouter au fichier existant.
148
149 Lire le champ : ::
150
151         fMEDFileRead = ml.MEDFileField1TS("TargetMesh2.med",f.getName(),7,8)
152         fRead1 = fMEDFileRead.getFieldOnMeshAtLevel(ml.ON_CELLS,0,meshMEDFileRead) # Quickest way, not re-reading mesh in the file.
153         fRead2 = fMEDFileRead.getFieldAtLevel(ml.ON_CELLS,0)                       # Like above, but this time the mesh is read!
154         print "Does the field remain OK with the quick method?", fRead1.isEqual(f,1e-12,1e-12)
155         print "Does the field remain OK with the slow method?", fRead2.isEqual(f,1e-12,1e-12)
156         
157 Lire/écrire un champ sur un "profil"
158 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
159
160 Nous allons maintenant voir un concept avancé des fichiers MED, à savoir la possibilité d'écrire un champ sur seulement
161 une *partie* du maillage. La technique habituellement utilisée est plutôt de mettre des valeurs particulières (e.g. +infinity
162 soit 1e+300) sur les zones où le champ n'a pas de sens, permettant ainsi de repérer en plus des bugs éventuels lors du calcul.
163
164 Le mode de fonctionnement avec les profils reste donc peu courant.
165
166 Construisons une réduction aux cellules [1,2,3] de ``f`` et appelons la ``fPart`` : ::
167
168         pfl = ml.DataArrayInt([1,2,3]) 
169         pfl.setName("My1stPfl")
170         fPart = f.buildSubPart(pfl)
171         fPart.setName("fPart")
172
173 La stocker dans la structure ``MEDFileField1TS`` et invoquer ``setFieldProfile()``. ::
174
175         fMEDFile2 = ml.MEDFileField1TS()
176         fMEDFile2.setFieldProfile(fPart,meshMEDFileRead,0,pfl) # 0 is the relative level (here 0 means 2D)
177         fMEDFile2.write("TargetMesh2.med",0) # 0 is paramount to indicate that we *append* (and no overwrite) to the MED file
178
179 Lire le champ ``fPart`` du fichier "TargetMesh2.med" et les identifiants de cellules correspondant. ::
180
181         fMEDFileRead2 = ml.MEDFileField1TS("TargetMesh2.med",fPart.getName(),7,8)
182         fPartRead, pflRead = fMEDFileRead2.getFieldWithProfile(ml.ON_CELLS,0,meshMEDFileRead)
183         print "Is the partial field correctly read?", fPartRead.isEqualWithoutConsideringStr(fPart.getArray(),1e-12)
184         print "Is the list of cell identifiers matching?", pflRead.isEqualWithoutConsideringStr(pfl)
185
186 Solution
187 ~~~~~~~~
188
189 :ref:`python_testMEDLoaderAdvancedAPI1_solution`
190