3 .. index:: single: exemple
4 .. index:: single: python
6 On trouvera ici les instructions python pour quelques configurations caractéristiques. Les fichiers de données associés sont téléchargeables. Il faut penser à adapter la valeur de la variable ``data_dir`` : c'est le répertoire dans lequel les fichiers med auront été enregistrés.
7 C'est dans le répertoire ``dircase`` que seront écrits les fichiers résultant des adaptations successives. Ce répertoire est créé par défaut dans ``/tmp``.
9 Chargement du module HOMARD
10 """""""""""""""""""""""""""
11 .. index:: single: yacs
13 Le chargement du module HOMARD se fait de manière analogue aux autres modules.
18 homard = salome.lcc.FindOrLoadComponent('FactoryServer','HOMARD')
19 homard.SetCurrentStudy(salome.myStudy)
21 Pour utiliser le module HOMARD au sein d'un schéma YACS distribué, le chargement se fait ainsi :
26 my_container.load_component_Library('HOMARD')
27 homard = my_container.create_component_instance('HOMARD',0)
28 homard.SetCurrentStudy(salome.myStudy)
32 .. index:: single: raffinement;uniforme
34 On fera ici trois raffinements uniformes successifs du maillage contenu dans le fichier ``tutorial_1.00.med``. Quelques remarques :
35 * la même hypothèse est utilisée à chaque itération
36 * le maillage produit porte toujours le même nom. Cela ne pose pas de problème car il est stocké dans des fichiers différents.
43 Hypo_0 = homard.CreateHypothesis('Hypo_0')
44 Hypo_0.SetAdapRefinUnRef(-1, 1, 0)
48 Case_1 = homard.CreateCase('Case_1', 'MAILL', data_dir+'/tutorial_1.00.med')
49 Case_1.SetDirName(dircase)
55 Iter_0 = Case_1.NextIteration('Iter_0')
56 Iter_0.SetMeshName('MESH')
57 Iter_0.SetMeshFile(dircase+'/maill.01.med')
58 Iter_0.AssociateHypo('Hypo_0')
59 codret = Iter_0.Compute(1, 2)
62 Iter_1 = Iter_0.NextIteration('Iter_1')
63 Iter_1.SetMeshName('MESH')
64 Iter_1.SetMeshFile(dircase+'/maill.02.med')
65 Iter_1.AssociateHypo('Hypo_0')
66 codret = Iter_1.Compute(1, 2)
69 Iter_2 = Iter_1.NextIteration('Iter_2')
70 Iter_2.SetMeshName('MESH')
71 Iter_2.SetMeshFile(dircase+'/maill.03.med')
72 Iter_2.AssociateHypo('Hypo_0')
73 codret = Iter_2.Compute(1, 2)
76 Téléchargement des fichiers
78 * :download:`maillage initial<files/tutorial_1.00.med.gz>`
79 * :download:`commandes python<files/tutorial_1.py>`
82 Raffinement par des zones
83 """""""""""""""""""""""""
84 .. index:: single: zone
86 On procède ici au raffinement selon des zones. Pour passer du maillage initial au maillage 'M_1', on utilise une boîte encadrant le plan z=1 et une sphère centrée sur l'origine de rayon 1.05. Puis pour passer du maillage 'M_1' au maillage 'M_2', on remplace la sphère par une boîte encadrant le cube de côté 0.5, pointant sur l'origine. On notera que le type de raffinement n'a pas été précisé ; par défaut, il sera donc conforme.
90 # Creation of the zones
91 # =====================
93 Zone_0 = homard.CreateZoneBox('Zone_0', -0.1, 1.1, -0.1, 1.1, 0.9, 1.1)
96 Zone_1 = homard.CreateZoneSphere('Zone_1', 0., 0., 0., 1.05)
99 Zone_2 = homard.CreateZoneBox('Zone_2', -0.1, 0.51, -0.1, 0.51, -0.1, 0.51)
101 # Hypothesis "Hypo_0"
102 # ===================
103 Hypo_0 = homard.CreateHypothesis('Hypo_0')
104 Hypo_0.SetAdapRefinUnRef(0, 1, 0)
105 Hypo_0.AddZone('Zone_1', 1)
106 Hypo_0.AddZone('Zone_0', 1)
108 # Hypothesis "Hypo_1"
109 # ===================
110 Hypo_1 = homard.CreateHypothesis('Hypo_1')
111 Hypo_1.SetAdapRefinUnRef(0, 1, 0)
112 Hypo_1.AddZone('Zone_0', 1)
113 Hypo_1.AddZone('Zone_2', 1)
117 Case_1 = homard.CreateCase('Case_1', 'MZERO', data_dir+'/tutorial_2.00.med')
118 Case_1.SetDirName(dircase)
122 Iter_0 = Case_1.NextIteration('Iter_0')
123 Iter_0.SetMeshName('M_1')
124 Iter_0.SetMeshFile(dircase+'/maill.01.med')
125 Iter_0.AssociateHypo('Hypo_0')
126 codret = Iter_0.Compute(1, 2)
130 Iter_1 = Iter_0.NextIteration('Iter_1')
131 Iter_1.SetMeshName('M_2')
132 Iter_1.SetMeshFile(dircase+'/maill.02.med')
133 Iter_1.AssociateHypo('Hypo_1')
134 codret = Iter_1.Compute(1, 2)
137 Téléchargement des fichiers
139 * :download:`maillage initial<files/tutorial_2.00.med.gz>`
140 * :download:`commandes python<files/tutorial_2.py>`
143 Raffinement selon un champ
144 """"""""""""""""""""""""""
145 .. index:: single: champ
147 On procède ici au raffinement selon un champ. Les hypothèses servent à définir le nom du champ et les seuils de raffinement/déraffinement. La donnée du fichier et des instants est faite dans l'itération. Des champs sur les noeuds ou sur les mailles sont interpolés.
148 Pour adapter le maillage H_1 issu de l'itération Iter_1, deux variantes sont appliquées. Dans la première, Iter_2, le champ est un champ scalaire d'indicateurs d'erreur et on découpe les 1.5% de mailles où l'erreur est la plus grande. Dans la seconde variante, Iter_2_bis, on se base sur un champ vectoriel et on examine le saut de ce vecteur entre une maille et ses voisines : on découpera là où la norme infinie de ce saut est supérieure au seuil absolu de 0.0001.
152 # Hypothesis "Hypo_0vers1"
153 # ========================
154 Hypo_0vers1 = homard.CreateHypothesis('Hypo_0vers1')
155 Hypo_0vers1.SetAdapRefinUnRef(1, 1, 0)
156 # Characterization of the field
157 Hypo_0vers1.SetField('SOLU_0__QIRE_ELEM_SIGM__________')
158 Hypo_0vers1.SetUseComp(0)
159 Hypo_0vers1.AddComp('ERREST ')
160 Hypo_0vers1.SetRefinThr(3, 1.0)
161 Hypo_0vers1.SetTypeFieldInterp(2)
162 Hypo_0vers1.AddFieldInterp('SOLU_0__DEPL____________________')
163 Hypo_0vers1.AddFieldInterp('SOLU_0__ERRE_ELEM_SIGM__________')
165 # Hypothesis "Hypo_1vers2"
166 # ========================
167 Hypo_1vers2 = homard.CreateHypothesis('Hypo_1vers2')
168 Hypo_1vers2.SetAdapRefinUnRef(1, 1, 1)
169 # Characterization of the field
170 Hypo_1vers2.SetField('SOLU_1__QIRE_ELEM_SIGM__________')
171 Hypo_1vers2.SetUseComp(0)
172 Hypo_1vers2.AddComp('ERREST ')
173 Hypo_1vers2.SetRefinThr(3, 1.5)
174 Hypo_1vers2.SetUnRefThr(3, 6.)
175 Hypo_1vers2.SetTypeFieldInterp(2)
176 Hypo_1vers2.AddFieldInterp('SOLU_1__DEPL____________________')
177 Hypo_1vers2.AddFieldInterp('SOLU_1__QIRE_ELEM_SIGM__________')
179 # Hypothesis "Hypo_1vers2_bis"
180 # ============================
181 Hypo_1vers2_bis = homard.CreateHypothesis('Hypo_1vers2_bis')
182 Hypo_1vers2_bis.SetAdapRefinUnRef(1, 1, 1)
183 # Characterization of the field
184 Hypo_1vers2_bis.SetField('SOLU_1__DEPL____________________')
185 Hypo_1vers2_bis.SetUseComp(1)
186 Hypo_1vers2_bis.AddComp('DX')
187 Hypo_1vers2_bis.AddComp('DY')
188 Hypo_1vers2_bis.AddComp('DZ')
189 Hypo_1vers2_bis.SetRefinThr(1, 0.0001)
190 Hypo_1vers2_bis.SetUnRefThr(1, 0.000001)
191 Hypo_1vers2_bis.SetTypeFieldInterp(0)
195 Case_1 = homard.CreateCase('Case_1', 'G_0', data_dir+'/tutorial_3.00.med')
196 Case_1.SetDirName(dircase)
200 Iter_1 = Case_1.NextIteration('Iter_1')
201 Iter_1.SetMeshName('H_1')
202 Iter_1.SetMeshFile(dircase+'/maill.01.med')
203 Iter_1.SetFieldFile(data_dir+'/tutorial_3.00.med')
204 Iter_1.SetTimeStepRank( 1, 1)
205 Iter_1.AssociateHypo('Hypo_0vers1')
206 codret = Iter_1.Compute(1, 2)
210 Iter_2 = Iter_1.NextIteration('Iter_2')
211 Iter_2.SetMeshName('H_2')
212 Iter_2.SetMeshFile(dircase+'/maill.02.med')
213 Iter_2.SetFieldFile(data_dir+'/tutorial_3.01.med')
214 Iter_2.SetTimeStepRank(1, 1)
215 Iter_2.AssociateHypo('Hypo_1vers2')
216 codret = Iter_2.Compute(1, 2)
218 # Iteration "Iter_2_bis"
219 # ======================
220 Iter_2_bis = Iter_1.NextIteration('Iter_2_bis')
221 Iter_2_bis.SetMeshName('H_2_bis')
222 Iter_2_bis.SetMeshFile(dircase+'/maill.02.bis.med')
223 Iter_2_bis.SetFieldFile(data_dir+'/tutorial_3.01.med')
224 Iter_2_bis.SetTimeStepRank(1, 1)
225 Iter_2_bis.AssociateHypo('Hypo_1vers2_bis')
226 codret = Iter_2_bis.Compute(1, 2)
229 Téléchargement des fichiers
231 * :download:`maillage et champ étape 0<files/tutorial_3.00.med.gz>`
232 * :download:`maillage et champ étape 1<files/tutorial_3.01.med.gz>`
233 * :download:`commandes python<files/tutorial_3.py>`
236 Suivi de frontières courbes
237 """""""""""""""""""""""""""
238 .. index:: single: champ
239 .. index:: single: yacs
241 On teste ici le suivi des frontières courbes : des frontières analytiques pour décrire les différentes surfaces des tuyaux et une frontière discrète pour décrire les lignes d'intersection des deux tuyaux. Le pilotage du raffinement est le suivant : raffinement uniforme de toutes les mailles contenues dans des groupes désignés. On commence par raffiner les faces internes aux tuyaux ; ensuite, on raffine deux fois de suite les faces externes aux tuyaux.
242 Le schéma YACS réalisant cette adaptation est téléchargeable.
246 # Creation of the boundaries
247 # ==========================
248 Boundary_1 = homard.CreateBoundaryDi('intersection', 'PIQUAGE', data_dir+'/tutorial_4.fr.med')
250 Boundary_2 = homard.CreateBoundaryCylinder('cyl_1_ext', 0.0, 25., -25., 25., 50., 75., 100.)
252 Boundary_3 = homard.CreateBoundaryCylinder('cyl_2_ext', 17.5, -2.5, -12.5, -100., -75., -25., 50.)
254 Boundary_4 = homard.CreateBoundaryCylinder('cyl_1_int', 0.0, 25., -25., 25., 50., 75., 75.)
256 Boundary_5 = homard.CreateBoundaryCylinder('cyl_2_int', 17.5, -2.5, -12.5, -100., -75., -25., 25.)
259 # ===================
260 # Creation of the hypothesis Hypo_1
261 Hypo_1 = homard.CreateHypothesis('Hypo_1')
262 Hypo_1.SetAdapRefinUnRef(-1, 1, 0)
263 Hypo_1.AddGroup('T1_INT_I')
264 Hypo_1.AddGroup('T1_INT_O')
265 Hypo_1.AddGroup('T2_INT')
266 # Creation of the hypothesis Hypo_2
267 Hypo_2 = homard.CreateHypothesis('Hypo_2')
268 Hypo_2.SetAdapRefinUnRef(-1, 1, 0)
269 Hypo_2.AddGroup('T1_EXT_I')
270 Hypo_2.AddGroup('T1_EXT_O')
271 Hypo_2.AddGroup('T2_EXT')
275 Case = homard.CreateCase('Case', 'PIQUAGE', data_dir+'/tutorial_4.00.med')
276 Case.SetDirName(dircase)
277 Case.AddBoundaryGroup( 'intersection', '' )
278 Case.AddBoundaryGroup( 'cyl_1_ext', 'T1_EXT_I' )
279 Case.AddBoundaryGroup( 'cyl_1_ext', 'T1_EXT_O' )
280 Case.AddBoundaryGroup( 'cyl_2_ext', 'T2_EXT' )
281 Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT_I' )
282 Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT_O' )
283 Case.AddBoundaryGroup( 'cyl_2_int', 'T2_INT' )
285 # Creation of the iterations
286 # ==========================
287 # Creation of the iteration Iter_1 : raffinement selon les faces internes
288 Iter_1 = Case.NextIteration('Iter_1')
289 Iter_1.SetMeshName('PIQUAGE_1')
290 Iter_1.SetMeshFile(dircase+'/maill.01.med')
291 Iter_1.AssociateHypo('Hypo_1')
292 codret = Iter_1.Compute(1, 2)
293 # Creation of the iteration Iter_2 : raffinement selon les faces externes
294 Iter_2 = Iter_1.NextIteration('Iter_2')
295 Iter_2.SetMeshName('PIQUAGE_2')
296 Iter_2.SetMeshFile(dircase+'/maill.02.med')
297 Iter_2.AssociateHypo('Hypo_2')
298 codret = Iter_2.Compute(1, 2)
299 # Creation of the iteration Iter_3 : second raffinement selon les faces externes
300 Iter_3 = Iter_2.NextIteration('Iter_3')
301 Iter_3.SetMeshName('PIQUAGE_3')
302 Iter_3.SetMeshFile(dircase+'/maill.03.med')
303 Iter_3.AssociateHypo('Hypo_2')
304 codret = Iter_3.Compute(1, 2)
307 Téléchargement des fichiers
309 * :download:`maillage initial<files/tutorial_4.00.med.gz>`
310 * :download:`maillage de la frontière discrète<files/tutorial_4.fr.med.gz>`
311 * :download:`commandes python<files/tutorial_4.py>`
312 * :download:`schéma YACS<files/tutorial_4.xml>`
315 Instructions spécifiques au 2D
316 """"""""""""""""""""""""""""""
317 .. index:: single: 2D
319 Les instructions pour adapter un maillage 2D sont exactement identiques à celles nécessaires à l'adaptation d'un maillage 3D. La seule exception concerne le raffinement selon des zones géométriques : des fonctions différentes sont utilisées pour pouvoir définir des zones 2D. On donne alors les coordonnées 2D des zones, en précisant l'orientation du plan du maillage.
320 Dans le cas présenté ici, on raffine une première fois toutes les mailles contenues dans un disque percé, puis dans une seconde itération, toutes les mailles contenues dans un rectangle. On notera l'utilisation du suivi des frontières circulaires du domaine.
324 # Creation of the boundaries
325 # ==========================
326 # Creation of the discrete boundary Boun_1
327 Boun_1 = homard.CreateBoundaryDi('Boun_1', 'MAIL_EXT', data_dir+'/tutorial_5.fr.med')
329 # Creation of the zones
330 # =====================
331 # Creation of the disk with hole enveloppe
332 enveloppe = homard.CreateZoneDiskWithHole( 'enveloppe', 0., 0., 250., 193., 1 )
333 # Creation of the rectangle quart_sup
334 quart_sup = homard.CreateZoneBox2D( 'quart_sup', 0., 250., 0., 250., 1 )
338 # Creation of the hypothesis Hypo_1
339 Hypo_1 = homard.CreateHypothesis('Hypo_1')
340 Hypo_1.SetAdapRefinUnRef(0, 1, 0)
341 Hypo_1.AddZone('enveloppe', 1)
342 # Creation of the hypothesis Hypo_2
343 Hypo_2 = homard.CreateHypothesis('Hypo_2')
344 Hypo_2.SetAdapRefinUnRef(0, 1, 0)
345 Hypo_2.AddZone('quart_sup', 1)
349 Case_1 = homard.CreateCase('Case_1', 'COEUR_2D', data_dir+'/tutorial_5.00.med')
350 Case_1.SetDirName(dircase)
351 Case_1.SetConfType(3)
352 Case_1.AddBoundaryGroup('Boun_1', '')
356 Iter_1 = Case_1.NextIteration('Iter_1')
357 Iter_1.SetMeshName('COEUR_2D_01')
358 Iter_1.SetMeshFile(dircase+'/maill.01.med')
359 Iter_1.AssociateHypo('Hypo_1')
360 codret = Iter_1.Compute(1, 2)
364 Iter_2 = Iter_1.NextIteration('Iter_2')
365 Iter_2.SetMeshName('COEUR_2D_02')
366 Iter_2.SetMeshFile(dircase+'/maill.02.med')
367 Iter_2.AssociateHypo('Hypo_2')
368 codret = Iter_2.Compute(1, 2)
371 Téléchargement des fichiers
373 * :download:`maillage initial<files/tutorial_5.00.med.gz>`
374 * :download:`maillage de la frontière discrète<files/tutorial_5.fr.med.gz>`
375 * :download:`commandes python<files/tutorial_5.py>`