1 #@ MODIF macr_adap_mail_ops Macro DATE 05/10/2004 AUTEUR CIBHHLV L.VIVAN
2 # -*- coding: iso-8859-1 -*-
3 # CONFIGURATION MANAGEMENT OF EDF VERSION
4 # ======================================================================
5 # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
9 # (AT YOUR OPTION) ANY LATER VERSION.
11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
18 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
19 # ======================================================================
20 # RESPONSABLE GNICOLAS G.NICOLAS
22 def macr_adap_mail_ops ( self,
23 INFO, VERSION_HOMARD, LANGUE,
24 NOMBRE, QUALITE, CONNEXITE, TAILLE, INTERPENETRATION,
25 NON_SIMPLEXE, MAILLAGE_FRONTIERE,
28 Ecriture des macros MACR_ADAP_MAIL/MACR_INFO_MAIL
29 Remarque : on ne mentionne explicitement que les mots-clés communs aux
30 deux macros. Les autres sont dans le dictionnaire args
33 # 1. args est le dictionnaire des arguments
34 # args.keys() est la liste des mots-clés
35 # args.keys()[0] est la premiere valeur de cette liste
36 # args.keys()[1:] est la liste des valeurs suivantes dans cette liste
37 # args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante.
41 ### if len (args.keys())>0 : print args.keys()[0]
42 ### print args["MAILLAGE"]
44 # 2. Les caractéristiques d'un passage sont conservées dans un dictionnaire. Il y a autant de
45 # dictionnaires que de sollicitations pour une série d'adaptation. L'ensemble de ces dictionnaires
46 # est conservé dans la liste Liste_Passages. Cette liste est nécessairement globale pour pouvoir
47 # la retrouver à chaque nouveau passage.
48 # Description du dictionnaire de passages :
49 # dico["Maillage_0"] = o ; string ; nom du concept du maillage initial de la série d'adaptation
50 # dico["Maillage_NP1"] = o ; string ; nom du concept du dernier maillage adapté
51 # dico["Rep_Calc_HOMARD_global"] = o ; string ; Nom global du répertoire de calcul pour HOMARD
52 # dico["Rep_Calc_HOMARD_local"] = o ; string ; Nom local du répertoire de calcul pour HOMARD
53 # depuis le répertoire de calcul pour ASTER
54 # dico["niter"] = o ; entier ; numéro d'itération
56 # 3. Les caractéristiques d'un maillage sont conservées dans un dictionnaire. Il y a autant de
57 # dictionnaires que de maillages manipulés. L'ensemble de ces dictionnaires est conservé
58 # dans la liste Liste_Maillages.
59 # Description du dictionnaire de maillages :
60 # dico["Type_Maillage"] = o ; string ; "MAILLAGE_N", "MAILLAGE_NP1" ou "MAILLAGE_FRONTIERE"
61 # dico["Nom_ASTER"] = o ; concept ASTER associé
62 # dico["Action"] = o ; string ; "A_ecrire" ou "A_lire"
63 # dico["NOM_MED"] = o ; string ; Nom MED du maillage
65 # 4. Les caractéristiques d'un champ sont conservées dans un dictionnaire. Il y a autant de
66 # dictionnaires que de champs manipulés. L'ensemble de ces dictionnaires est conservé
67 # dans la liste Liste_Champs.
68 # Description du dictionnaire de champs :
69 # dico["Type_Champ"] = o ; string ; "INDICATEUR" ou "CHAMP"
70 # dico["RESULTAT"] = o ; concept ASTER du résutat associé
71 # dico["NOM_CHAM"] = o ; string ; Nom ASTER du champ
72 # dico["COMPOSANTE"] = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur)
73 # dico["NUME_ORDRE"] = f ; entier ; Numéro d'ordre du champ
74 # dico["INST"] = f ; entier ; Instant du champ
75 # dico["PRECISION"] = f ; entier ; Précision sur l'instant du champ
76 # dico["CRITERE"] = f ; entier ; Critère de précision sur l'instant du champ
77 # dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage
78 # dico["NOM_MED"] = o ; string ; Nom MED du champ
88 #--------------------------------------------------------------------
90 #--------------------------------------------------------------------
92 # 1.1. ==> La macro compte pour 1 dans la numerotation des commandes
96 # 1.2. ==> Numéro du passage dans cette macro
99 self.jdc.indice_macro_homard = self.jdc.indice_macro_homard + 1
101 self.jdc.indice_macro_homard = 1
103 Numero_Passage_Fonction = self.jdc.indice_macro_homard
104 ### print "Numero_Passage_Fonction = ",Numero_Passage_Fonction
106 # 1.3. ==> On importe les definitions des commandes a utiliser dans la macro
108 DEFI_FICHIER = self.get_cmd("DEFI_FICHIER")
109 IMPR_RESU = self.get_cmd("IMPR_RESU")
110 EXEC_LOGICIEL = self.get_cmd("EXEC_LOGICIEL")
111 IMPR_FICO_HOMA = self.get_cmd("IMPR_FICO_HOMA")
112 LIRE_MAILLAGE = self.get_cmd("LIRE_MAILLAGE")
113 LIRE_CHAMP = self.get_cmd("LIRE_CHAMP")
114 DETRUIRE = self.get_cmd('DETRUIRE')
116 # 1.4. ==> Le nom du programme HOMARD à lancer
118 repertoire_outils = aster.repout()
119 homard = repertoire_outils + "homard"
121 # 1.5. ==> Initialisations
125 Rep_Calc_ASTER = os.getcwd()
136 #--------------------------------------------------------------------
137 # 2. Décodage des arguments de la macro-commande
138 #--------------------------------------------------------------------
139 # 2.1. ==> Données de pilotage de l'adaptation
141 if ( self.nom == "MACR_ADAP_MAIL" ) :
145 ADAPTATION = args["ADAPTATION"]
146 if args.has_key("MAJ_CHAM") :
147 MAJ_CHAM = args["MAJ_CHAM"]
149 # 2.1.1. ==> Les concepts "maillage"
151 for mot_cle in ["MAILLAGE_N","MAILLAGE_NP1"] :
153 dico["Type_Maillage"] = mot_cle
154 dico["Nom_ASTER"] = ADAPTATION[mot_cle]
155 if ( mot_cle == "MAILLAGE_N" ) :
156 dico["Action"] = "A_ecrire"
158 dico["Action"] = "A_lire"
159 Liste_Maillages.append(dico)
161 # 2.1.2. ==> L'éventuel indicateur d'erreur
163 if ADAPTATION["LIBRE"] != None :
165 dico["Type_Champ"] = "INDICATEUR"
166 dico["RESULTAT"] = ADAPTATION["RESULTAT_N"]
167 dico["NOM_CHAM"] = ADAPTATION["INDICATEUR"]
168 dico["COMPOSANTE"] = ADAPTATION["NOM_CMP_INDICA"]
169 if ( ADAPTATION["NUME_ORDRE"] != None ) :
170 dico["NUME_ORDRE"] = ADAPTATION["NUME_ORDRE"]
171 if ( ADAPTATION["INST"] != None ) :
172 dico["INST"] = ADAPTATION["INST"]
173 for cle in [ "PRECISION", "CRITERE" ] :
174 if ( ADAPTATION[cle] != None ) :
175 dico[cle] = ADAPTATION[cle]
176 dico["NOM_MED"] = aster.mdnoch ( dico["RESULTAT"].nom , dico["NOM_CHAM"] )
177 Liste_Champs.append(dico)
181 # 2.1.3. ==> Les champs à mettre à jour
183 if ( MAJ_CHAM != None ) :
185 for maj_cham in MAJ_CHAM :
189 dico["Type_Champ"] = "CHAMP"
190 for cle in [ "CHAM_MAJ", "TYPE_CHAM", "RESULTAT", "NOM_CHAM" ] :
191 dico[cle] = maj_cham[cle]
192 if ( maj_cham["NUME_ORDRE"] != None ) :
193 dico["NUME_ORDRE"] = maj_cham["NUME_ORDRE"]
194 elif ( maj_cham["INST"] != None ) :
195 dico["INST"] = maj_cham["INST"]
196 for cle in [ "PRECISION", "CRITERE" ] :
197 if ( maj_cham[cle] != None ) :
198 dico[cle] = maj_cham[cle]
199 dico["NOM_MED"] = aster.mdnoch ( dico["RESULTAT"].nom , dico["NOM_CHAM"] )
202 Liste_Champs.append(dico)
204 # 2.2. ==> Données de pilotage de l'information
211 dico["Type_Maillage"] = "MAILLAGE_N"
212 dico["Nom_ASTER"] = args["MAILLAGE"]
213 dico["Action"] = "A_ecrire"
214 Liste_Maillages.append(dico)
216 # 2.3. ==> Suivi de frontière
218 if ( MAILLAGE_FRONTIERE != None ) :
221 dico["Type_Maillage"] = "MAILLAGE_FRONTIERE"
222 dico["Nom_ASTER"] = MAILLAGE_FRONTIERE
223 dico["Action"] = "A_ecrire"
224 Liste_Maillages.append(dico)
226 #--------------------------------------------------------------------
227 # 3. Préparation du lancement des commandes
228 #--------------------------------------------------------------------
230 # 3.1. ==> . Elaboration des noms MED des concepts de maillage
231 # . Memorisation des noms ASTER du maillage en entrée et en sortie (sous forme string)
232 # On crée une nouvelle liste des dictionnaires décrivant les maillages
233 # et à la fin on écrase l'ancienne liste par cette nouvelle.
236 for dico in Liste_Maillages :
237 dico["NOM_MED"] = aster.mdnoma(dico["Nom_ASTER"].nom)
239 if ( dico["Type_Maillage"] == "MAILLAGE_N" ) :
240 Nom_Concept_Maillage_N = dico["Nom_ASTER"].nom
241 elif ( dico["Type_Maillage"] == "MAILLAGE_NP1" ) :
242 Nom_Concept_Maillage_NP1 = dico["Nom_ASTER"].nom
245 # 3.2. ==> Recherche du numéro d'itération et du répertoire de travail
247 # 3.2.1. ==> Par défaut :
248 # . le numéro d'itération est nul
249 # . le nom du répertoire de lancement de HOMARD est construit sur le nom
250 # du maillage en entrée et le numéro de passage dans la fonction
253 Nom_Rep_local = Nom_Concept_Maillage_N + "_" + modhom + "_" + str(Numero_Passage_Fonction)
254 Rep_Calc_HOMARD_local = os.path.join(".",Nom_Rep_local)
255 Rep_Calc_HOMARD_global = os.path.join(Rep_Calc_ASTER,Nom_Rep_local)
256 ### print "Rep_Calc_HOMARD_local = ", Rep_Calc_HOMARD_local
257 ### print "Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global
259 # 3.2.2. ==> En adaptation :
261 if ( modhom == "ADAP" ) :
263 # 3.2.2.1. ==> On recherche si dans les passages déjà effectués, il en existe un
264 # dont le maillage d'arrivée était l'actuel maillage d'entrée. Si c'est
265 # le cas, cela veut dire que l'adaptation en cours est la suite d'une
266 # précédente. On doit donc utiliser le meme répertoire. Le numéro
267 # d'itération est celui de l'adaptation précédente augmenté de 1.
269 for dico in Liste_Passages :
270 if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) :
271 niter = dico["niter"] + 1
272 Rep_Calc_HOMARD_local = dico["Rep_Calc_HOMARD_local"]
273 Rep_Calc_HOMARD_global = dico["Rep_Calc_HOMARD_global"]
275 # 3.2.2.2. ==> Memorisation de ce passage
277 # 3.2.2.2.1. ==> Enregistrement d'un nouveau cas de figure
281 dico["Maillage_0"] = Nom_Concept_Maillage_N
282 dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1
283 dico["Rep_Calc_HOMARD_local"] = Rep_Calc_HOMARD_local
284 dico["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global
285 dico["niter"] = niter
286 Liste_Passages.append(dico)
288 # 3.2.2.2.2. ==> Modification du cas en cours
292 for dico in Liste_Passages :
293 if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) :
294 dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1
295 dico["niter"] = niter
299 ### print "niter = ", niter, ", Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global
301 #--------------------------------------------------------------------
302 # 4. Ecriture des commandes
303 #--------------------------------------------------------------------
305 # 4.1. ==> Création du répertoire pour homard
306 # attention : on ne fait cette creation qu'une seule fois par cas
307 # d'adaptation ou d'information
312 os.mkdir(Rep_Calc_HOMARD_global)
313 except os.error,codret_partiel :
314 self.cr.warn("Code d'erreur de mkdir : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
315 self.cr.fatal("<F> <MACR_ADAP_MAIL> Impossible de créer le répertoire de travail pour HOMARD : "+Rep_Calc_HOMARD_global)
318 # 4.2. ==> Ecriture des commandes de creation des donnees MED
320 # On doit écrire : le maillage,
321 # le champ d'indicateur d'erreur
322 # les champs à convertir
323 # Remarque : on met tout dans le meme fichier
325 # Chacune de ces écritures est optionnelle selon le contexte.
327 if ( INFO > 1 ) : infomail = "OUI"
328 else : infomail = "NON"
330 # 4.2.1. ==> Noms des fichiers d'ASTER vers HOMARD et éventuellement de HOMARD vers ASTER
331 # Remarque : aujourd'hui, les écritures ou les lectures au format MED se font obligatoirement sur
332 # un fichier de nom fort.n, placé dans le répertoire de calcul
333 # Dans le fichier de configuration, on donne comme nom MAILL.(niter).MED en entrée et
334 # MAILL.(niter+1).MED en sortie (cf. adhc00)
335 # Tant que les E/S MED n'ont pas évolué, on fait un lien pour assurer la cohérence.
337 # 4.2.1.1. ==> D'ASTER vers HOMARD
339 Unite_Fichier_ASTER_vers_HOMARD = 1787 + 2*Numero_Passage_Fonction
340 Fichier_ASTER_vers_HOMARD = os.path.join(Rep_Calc_ASTER,"fort." + str(Unite_Fichier_ASTER_vers_HOMARD))
341 Fichier_HOMARD_Entree = os.path.join(Rep_Calc_HOMARD_global,"MAILL."+str(niter)+".MED")
342 ### print "Fichier_ASTER_vers_HOMARD = ",Fichier_ASTER_vers_HOMARD
343 ### print "Fichier_HOMARD_Entree = ",Fichier_HOMARD_Entree
345 os.symlink(Fichier_ASTER_vers_HOMARD,Fichier_HOMARD_Entree)
346 except os.error,codret_partiel :
347 self.cr.warn("Code d'erreur de symlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
348 self.cr.fatal("<F> <MACR_ADAP_MAIL> Probleme au lien entre " + Fichier_ASTER_vers_HOMARD + " et " + Fichier_HOMARD_Entree)
351 # 4.2.1.2. ==> De HOMARD vers ASTER
353 if ( modhom == "ADAP" ) :
354 Unite_Fichier_HOMARD_vers_ASTER = Unite_Fichier_ASTER_vers_HOMARD + 1
355 Fichier_HOMARD_vers_ASTER = os.path.join(Rep_Calc_ASTER,"fort." + str(Unite_Fichier_HOMARD_vers_ASTER))
356 Fichier_HOMARD_Sortie = os.path.join(Rep_Calc_HOMARD_global,"MAILL."+str(niter+1)+".MED")
357 ### print "Fichier_HOMARD_vers_ASTER = ",Fichier_HOMARD_vers_ASTER
358 ### print "Fichier_HOMARD_Sortie = ",Fichier_HOMARD_Sortie
360 os.symlink(Fichier_HOMARD_vers_ASTER,Fichier_HOMARD_Sortie)
361 except os.error,codret_partiel :
362 self.cr.warn("Code d'erreur de symlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
363 self.cr.fatal("<F> <MACR_ADAP_MAIL> Probleme au lien entre " + Fichier_HOMARD_vers_ASTER + " et " + Fichier_HOMARD_Sortie)
366 # 4.2.2. La définition du fichier de ASTER vers HOMARD
368 DEFI_FICHIER ( ACTION= "ASSOCIER",
369 UNITE = Unite_Fichier_ASTER_vers_HOMARD,
373 # 4.2.3. Le(s) maillage(s)
374 # Le maillage de calcul et l'éventuel maillage de la frontiere sont écrits
375 # dans le meme fichier MED
376 # En fait, on pourrait s'en passer au dela de la 1ère itération
377 # car HOMARD a mémorisé. Mais dès que l'on écrit un champ,
378 # les conventions MED imposent la présence du maillage dans le fichier.
379 # Donc on va toujours écrire.
381 for dico in Liste_Maillages :
382 if ( dico["Action"] == "A_ecrire" ) :
384 motscsi["MAILLAGE"] = dico["Nom_ASTER"]
386 motscfa["RESU"]=_F( INFO_MAILLAGE=infomail,
389 IMPR_RESU ( INFO = INFO,
390 FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD,
393 # 4.2.4. Le(s) champ(s)
394 # Attention : il se peut que l'on demande la mise à jour du champ qui a servi comme
395 # indicateur d'erreur. Si c'est le cas, il ne faut pas demander son
396 # impression sinon il y a plantage d'IMPR_RESU qui ne sait pas substituer
397 # deux champs. D'ailleurs, c'est plus économique ainsi !
398 # Remarque : pour l'adaptation, on ne demande a priori qu'une composante du champ d'indicateur.
399 # s'il y a demande de mise à jour, toutes les composantes sont concernées. Il faut
400 # donc dans ce cas imprimer le champ total.
401 # dico["Type_Champ"] = o ; string ; "INDICATEUR" ou "CHAMP"
402 # dico["RESULTAT"] = o ; concept ASTER du résutat associé
403 # dico["NOM_CHAM"] = o ; string ; Nom ASTER du champ
404 # dico["COMPOSANTE"] = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur)
405 # dico["NUME_ORDRE"] = f ; entier ; Numéro d'ordre du champ
406 # dico["INST"] = f ; entier ; Instant du champ
407 # dico["PRECISION"] = f ; entier ; Précision sur l'instant du champ
408 # dico["CRITERE"] = f ; entier ; Critère de précision sur l'instant du champ
409 # dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage
410 # dico["NOM_MED"] = o ; string ; Nom MED du champ
412 # 4.2.4.1. Recherche d'un doublon éventuel sur le champ d'indicateur d'erreur
414 if len(dico_indi) > 0 :
419 Liste_Champs_imprime = []
420 for dico in Liste_Champs :
421 # Pour un champ à mettre à jour, on a toujours impression
422 if ( dico["Type_Champ"] == "CHAMP" ) :
423 Liste_Champs_imprime.append(dico)
424 # Si le champ d'indicateur n'a pas été repéré comme champ à mettre à jour :
425 if not imprime_indic :
426 # Est-ce le meme champ ?
428 for cle in [ "RESULTAT", "NOM_CHAM" ] :
429 if ( dico_indi[cle] != dico[cle] ) :
432 # Si oui, est-ce au meme moment ? (remarque : si rien n'est désigné, c'est qu'il n'y a qu'un
433 # seul instant ... donc c'est le meme ! En revanche, on ne sait pas comparer une donnée
434 # en numéro d'ordre et une donnée en instant. On croise les doigts.)
436 for cle in [ "NUME_ORDRE", "INST" ] :
437 if dico.has_key(cle) :
438 if ( dico[cle] != None ) :
439 if dico_indi.has_key(cle) :
440 if ( dico_indi[cle] != dico[cle] ) :
443 if ok : imprime_indic = 1
444 # Si le champ d'indicateur n'a pas été repéré comme champ à mettre à jour, il faut
445 # l'inclure dans les champs à imprimer
446 if not imprime_indic : Liste_Champs_imprime.append(dico_indi)
448 # 4.2.4.2. Impressions après le filtrage précédent
450 for dico in Liste_Champs_imprime :
452 for cle in [ "RESULTAT", "NOM_CHAM", "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
453 if dico.has_key(cle) :
454 if ( dico[cle] != None ) :
455 motscsi[cle] = dico[cle]
456 if dico.has_key("COMPOSANTE") :
457 motscsi["NOM_CMP"] = dico["COMPOSANTE"]
459 motscfa["RESU"]=_F( INFO_MAILLAGE=infomail,
463 IMPR_RESU ( INFO = INFO,
464 FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD,
467 # 4.3. ==> Ecriture de la commande d'écriture des fichiers de données pour HOMARD
471 # 4.3.1. ==> Le traitement
475 # 4.3.1.1. ==> Le type de traitement
477 if ( modhom == "ADAP" ) :
478 if ( ADAPTATION["UNIFORME"] != None ) :
479 motscsi["UNIFORME"] = ADAPTATION["UNIFORME"]
481 motscsi["ADAPTATION"] = ADAPTATION["LIBRE"]
483 motscsi["INFORMATION"] = "OUI"
485 # 4.3.1.2. ==> Les noms med des maillages
487 for dico in Liste_Maillages :
488 ### print "Nom MED de " + dico["Type_Maillage"] + " = " + dico["NOM_MED"]
489 motscsi[ "NOM_MED_"+dico["Type_Maillage"] ] = dico["NOM_MED"]
491 # 4.3.1.3. ==> Les caracteristiques de l'éventuel indicateur d'erreur
493 for dico in Liste_Champs :
494 if ( dico["Type_Champ"] == "INDICATEUR" ) :
495 Liste_aux = [ "NOM_MED", "COMPOSANTE" ]
496 if dico.has_key("NUME_ORDRE") :
497 Liste_aux.append("NUME_ORDRE")
499 for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] :
500 Liste_aux.append(cle)
501 for cle in Liste_aux :
502 if dico.has_key(cle) :
503 if ( dico[cle] != None ) :
504 motscsi[cle] = dico[cle]
506 # 4.3.1.4. ==> Les critères de raffinement et les niveaux extremes
508 if ( modhom == "ADAP" ) :
510 if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "RAFFINEMENT" ) :
511 Liste_aux.append("CRIT_RAFF_ABS")
512 Liste_aux.append("CRIT_RAFF_REL")
513 Liste_aux.append("CRIT_RAFF_PE")
514 if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "DERAFFINEMENT" ) :
515 Liste_aux.append("CRIT_DERA_ABS")
516 Liste_aux.append("CRIT_DERA_REL")
517 Liste_aux.append("CRIT_DERA_PE")
519 if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "RAFFINEMENT" or ADAPTATION["UNIFORME"] == "RAFFINEMENT" ) :
520 Liste_aux.append("NIVE_MAX")
522 if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "DERAFFINEMENT" or ADAPTATION["UNIFORME"] == "DERAFFINEMENT" ) :
523 Liste_aux.append("NIVE_MIN")
525 for mot_cle in Liste_aux :
526 if ( ADAPTATION[mot_cle] != None ) :
527 motscsi[mot_cle] = ADAPTATION[mot_cle]
530 if ( ADAPTATION["NIVE_MIN"] > ADAPTATION["NIVE_MAX"] ) :
531 self.cr.fatal("<F> <MACR_ADAP_MAIL> Le niveau minimum doit etre inferieur au niveau maximum.")
534 # 4.3.1.5. ==> Numéro d'itération
536 if ( modhom == "ADAP" ) :
537 motscsi["NITER"] = niter
539 # 4.3.1.6. ==> Suivi de la frontiere
541 if args.has_key("GROUP_MA") :
542 if ( args["GROUP_MA"] != None ) :
543 motscsi["GROUP_MA"] = args["GROUP_MA"]
547 motscfa["TRAITEMENT"] = _F(**motscsi)
549 # 4.3.2. ==> L'analyse
552 if ( NOMBRE != None ) : motscsi["NOMBRE" ] = NOMBRE
553 if ( QUALITE != None ) : motscsi["QUALITE" ] = QUALITE
554 if ( CONNEXITE != None ) : motscsi["CONNEXITE" ] = CONNEXITE
555 if ( TAILLE != None ) : motscsi["TAILLE" ] = TAILLE
556 if ( INTERPENETRATION != None ) : motscsi["INTERPENETRATION" ] = INTERPENETRATION
558 motscfa["ANALYSE"] = _F(**motscsi)
560 # 4.3.3. ==> La mise à jour de champs
563 for dico in Liste_Champs :
565 if ( dico["Type_Champ"] == "CHAMP" ) :
566 Liste_aux = [ "NOM_MED", "COMPOSANTE" ]
567 if dico.has_key("NUME_ORDRE") :
568 Liste_aux.append("NUME_ORDRE")
570 for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] :
571 Liste_aux.append(cle)
572 for cle in Liste_aux :
573 if dico.has_key(cle) :
574 if ( dico[cle] != None ) :
575 motscsi[cle] = dico[cle]
578 motscfa["MAJ_CHAM"] = [_F(**motscsi),]
581 motscfa["MAJ_CHAM"].append(_F(**motscsi))
583 # 4.3.4. ==> La commande
585 # 4.3.4.1. ==> Les fichiers annexes
589 Nom_Fichier_Configuration = "HOMARD.Configuration"
590 Fichier_Configuration = os.path.join(Rep_Calc_HOMARD_local,Nom_Fichier_Configuration)
591 dico[Fichier_Configuration] = ("HOMARD_CONFIG","UNITE_CONF",unite)
593 if ( modhom != "ADAP" ) :
595 Nom_Fichier_Donnees = "HOMARD.Donnees"
596 Fichier_Donnees = os.path.join(Rep_Calc_HOMARD_local,Nom_Fichier_Donnees)
598 dico[Fichier_Donnees] = ("HOMARD_DONN","UNITE_DONN",unite)
600 # 4.3.4.2. ==> L'ouverture de ces fichiers
602 for fic in dico.keys() :
603 DEFI_FICHIER ( ACTION= "ASSOCIER", FICHIER = fic, UNITE = dico[fic][2],
604 TYPE = "ASCII", ACCES = "NEW", INFO = INFO )
605 motscfa[dico[fic][1]] = dico[fic][2]
607 # 4.3.4.3. ==> Ecriture
610 IMPR_FICO_HOMA ( INFO=INFO, LANGUE = LANGUE, NON_SIMPLEXE = NON_SIMPLEXE, **motscfa )
612 ### for fic in dico.keys() :
613 ### print "\nContenu de ", fic
614 ### fichier = open (fic,"r")
615 ### les_lignes = fichier.readlines()
617 ### for ligne in les_lignes :
620 # 4.3.4.4. ==> La fermeture des fichiers locaux
621 # Remarque : il faut le faire ici pour que le gestionnaire de DEFI_FICHIER soit à jour
622 # Remarque : aujourd'hui on est obligé de passer par le numéro d'unité logique
624 for fic in dico.keys() :
625 DEFI_FICHIER ( ACTION= "LIBERER", UNITE = dico[fic][2], INFO = INFO )
627 # 4.4. ==> Ecriture de la commande d'exécution de homard
628 # Remarque : dans la donnée de la version de HOMARD, il faut remplacer
629 # le _ de la donnee par un ., qui
630 # est interdit dans la syntaxe du langage de commandes ASTER
631 # Remarque : il faut remplacer le N majuscule de la donnee par
632 # un n minuscule, qui est interdit dans la syntaxe du langage
634 # Remarque : pour le nommage des fichiers d'échange entre ASTER et HOMARD, on utilise
635 # la convention implicite du fort.n des entrees/sorties au format MED
637 VERSION_HOMARD=string.replace(VERSION_HOMARD,"_",".")
638 VERSION_HOMARD=string.replace(VERSION_HOMARD,"N","n")
639 if ( VERSION_HOMARD[-6:]=="_PERSO" ):
640 # motscsi["ARGUMENT"]=_F("TYPEXE"="-PERSO")
641 VERSION_HOMARD=VERSION_HOMARD[:-6]
643 if ( modhom == "ADAP" ) :
644 Nom_Fichier_Donnees = "0"
646 EXEC_LOGICIEL ( ARGUMENT = (_F(NOM_PARA=Rep_Calc_HOMARD_global), # nom du repertoire
647 _F(NOM_PARA=VERSION_HOMARD), # version de homard
648 _F(NOM_PARA=str(INFO)), # niveau d information
649 _F(NOM_PARA=Nom_Fichier_Donnees), # fichier de données HOMARD
654 # 4.5. ==> Ecriture de la commande de lecture des resultats med
656 # La fonction self.DeclareOut(a,b) focntionne ainsi :
657 # a est une chaine de caracteres
658 # b est la variable déclarée dans la commande
659 # le but est de associer le contenu de b à la variable locale qui sera désignée par a
661 # self.DeclareOut("maillage_np1",ADAPTATION["MAILLAGE_NP1"])
662 # ==> la variable maillage_np1 est identifiée à l'argument "MAILLAGE_NP1" du mot-clé ADAPTATION
664 if ( modhom == "ADAP" ) :
666 # 4.5.1. ==> Le maillage
668 self.DeclareOut("maillage_np1",ADAPTATION["MAILLAGE_NP1"])
669 for dico in Liste_Maillages :
670 if ( dico["Action"] == "A_lire" ) :
671 maillage_np1 = LIRE_MAILLAGE ( UNITE = Unite_Fichier_HOMARD_vers_ASTER,
673 NOM_MED = dico["NOM_MED"],
674 VERI_MAIL = _F(VERIF="NON"), INFO_MED = INFO, INFO = INFO )
676 # 4.5.2. ==> Les champs
678 for dico in Liste_Champs :
679 if ( dico["Type_Champ"] == "CHAMP" ) :
681 self.DeclareOut("champ_maj",dico["CHAM_MAJ"])
683 for cle in [ "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
684 if dico.has_key(cle) :
685 if ( dico[cle] != None ) :
686 motscsi[cle] = dico[cle]
687 if dico.has_key("NUME_ORDRE") :
688 motscsi["NUME_PT"] = dico["NUME_ORDRE"]
689 champ_maj = LIRE_CHAMP ( UNITE = Unite_Fichier_HOMARD_vers_ASTER, FORMAT = "MED",
690 MAILLAGE = maillage_np1,
691 NOM_MED = dico["NOM_MED"], NOM_CMP_IDEM = "OUI", TYPE_CHAM = dico["TYPE_CHAM"],
692 INFO = INFO, **motscsi )
694 #--------------------------------------------------------------------
695 # 5. Menage des fichiers MED et HOMARD devenus inutiles
696 #--------------------------------------------------------------------
698 fic = os.path.join(Rep_Calc_HOMARD_global,"MAILL."+str(niter)+".HOM")
699 Liste_aux = [ Fichier_ASTER_vers_HOMARD, Fichier_HOMARD_Entree, fic ]
700 if ( modhom == "ADAP" ) :
701 Liste_aux.append(Fichier_HOMARD_vers_ASTER)
702 Liste_aux.append(Fichier_HOMARD_Sortie)
704 for fic in Liste_aux :
705 if ( INFO > 1 ) : print "Destruction du fichier ", fic
706 if os.path.islink(fic) :
709 except os.error,codret_partiel :
710 self.cr.warn("Code d'erreur de unlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
711 self.cr.warn("Impossible d'enlever le lien sur le fichier : "+fic)
713 if os.path.isfile(fic) :
716 except os.error,codret_partiel :
717 self.cr.warn("Code d'erreur de remove : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
718 self.cr.warn("Impossible de détruire le fichier : "+fic)
720 ### print os.listdir(Rep_Calc_ASTER)
721 ### print os.listdir(Rep_Calc_HOMARD_global)
723 #--------------------------------------------------------------------
725 #--------------------------------------------------------------------