From 3a637bd639c0eec702573d699e2749c1e10b43e0 Mon Sep 17 00:00:00 2001 From: Pascale Noyret Date: Tue, 30 May 2006 09:10:45 +0000 Subject: [PATCH] PN CHANGEMENT DE CATALOGUE --- Aster/Cata/cataSTA8/Macro/calc_table_ops.py | 162 ++++ .../cataSTA8/Macro/creation_donnees_homard.py | 522 ++++++++++ .../Cata/cataSTA8/Macro/gene_vari_alea_ops.py | 109 +++ .../Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py | 891 ++++++++++++++++++ Aster/Cata/cataSTA8/Macro/reca_graphique.py | 92 ++ 5 files changed, 1776 insertions(+) create mode 100644 Aster/Cata/cataSTA8/Macro/calc_table_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py create mode 100644 Aster/Cata/cataSTA8/Macro/gene_vari_alea_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/reca_graphique.py diff --git a/Aster/Cata/cataSTA8/Macro/calc_table_ops.py b/Aster/Cata/cataSTA8/Macro/calc_table_ops.py new file mode 100644 index 00000000..cd62da23 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/calc_table_ops.py @@ -0,0 +1,162 @@ +#@ MODIF calc_table_ops Macro DATE 10/04/2006 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +# RESPONSABLE MCOURTOI M.COURTOIS +from types import * +EnumTypes = (ListType, TupleType) + +def calc_table_ops(self, TABLE, ACTION, INFO, **args): + """ + Macro CALC_TABLE permettant de faire des opérations sur une table + """ + import aster + + macro = 'CALC_TABLE' + from Accas import _F + from Cata.cata import table_jeveux + from Utilitai.Utmess import UTMESS + from Utilitai import transpose + from Utilitai.Table import Table, merge + from Utilitai.Sensibilite import NomCompose + + ier = 0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # Le concept sortant (de type table_sdaster ou dérivé) est tab + self.DeclareOut('tabout', self.sd) + + # On importe les definitions des commandes a utiliser dans la macro + # Le nom de la variable doit etre obligatoirement le nom de la commande + CREA_TABLE = self.get_cmd('CREA_TABLE') + DETRUIRE = self.get_cmd('DETRUIRE') + + # 0. faut-il utiliser une table dérivée + form_sens='\n... SENSIBILITE AU PARAMETRE %s (SD COMP %s)' + if args['SENSIBILITE']: + ncomp = NomCompose(TABLE, args['SENSIBILITE'], msg='F') + sdtab = table_jeveux(ncomp) + tab = sdtab.EXTR_TABLE() + else: + tab = TABLE.EXTR_TABLE() + + #---------------------------------------------- + # Boucle sur les actions à effectuer + for fOP in ACTION: + occ = fOP.cree_dict_valeurs(fOP.mc_liste) + for mc, val in occ.items(): + if val == None: + del occ[mc] + + #---------------------------------------------- + # 1. Traitement du FILTRE + # format pour l'impression des filtres + form_filtre = '\nFILTRE -> NOM_PARA: %-16s CRIT_COMP: %-4s VALE: %s' + if occ['OPERATION'] == 'FILTRE': + col = getattr(tab, occ['NOM_PARA']) + # peu importe le type, c'est la meme méthode d'appel + opts = [occ[k] for k in ('VALE','VALE_I','VALE_C','VALE_K') if occ.has_key(k)] + kargs = {} + for k in ('CRITERE','PRECISION'): + if occ.has_key(k): + kargs[k] = occ[k] + tab = tab & ( getattr(col, occ['CRIT_COMP'])(*opts,**kargs) ) + # trace l'operation dans le titre + #if FORMAT in ('TABLEAU','ASTER'): + tab.titr += form_filtre % (occ['NOM_PARA'], occ['CRIT_COMP'], \ + ' '.join([str(v) for v in opts])) + + #---------------------------------------------- + # 2. Traitement de EXTR + if occ['OPERATION'] == 'EXTR': + lpar = occ['NOM_PARA'] + if not type(lpar) in EnumTypes: + lpar = [lpar] + for p in lpar: + if not p in tab.para: + UTMESS('F', macro, 'Paramètre %s inexistant dans la table %s' % (p, TABLE.nom)) + tab = tab[occ['NOM_PARA']] + + #---------------------------------------------- + # 3. Traitement de RENOMME + if occ['OPERATION'] == 'RENOMME': + try: + tab.Renomme(*occ['NOM_PARA']) + except KeyError, msg: + UTMESS('F', macro, msg) + + #---------------------------------------------- + # 4. Traitement du TRI + if occ['OPERATION'] == 'TRI': + tab.sort(CLES=occ['NOM_PARA'], ORDRE=occ['ORDRE']) + + #---------------------------------------------- + # 5. Traitement de COMB + if occ['OPERATION'] == 'COMB': + tab2 = occ['TABLE'].EXTR_TABLE() + opts = [tab, tab2] + if occ['NOM_PARA']<>None: + lpar = occ['NOM_PARA'] + if not type(lpar) in EnumTypes: + lpar = [lpar] + for p in lpar: + if not p in tab.para: + UTMESS('F', macro, 'Paramètre %s inexistant dans la table %s' % (p, TABLE.nom)) + if not p in tab2.para: + UTMESS('F', macro, 'Paramètre %s inexistant dans la table %s' % (p, occ['TABLE'].nom)) + opts.append(lpar) + tab = merge(*opts) + + #---------------------------------------------- + # 6. Traitement de OPER + if occ['OPERATION'] == 'OPER': + # ajout de la colonne dans la table + tab.fromfunction(occ['NOM_PARA'], occ['FORMULE']) + if INFO == 2: + vectval = getattr(tab, occ['NOM_PARA']).values() + aster.affiche('MESSAGE', 'Ajout de la colonne %s : %s' % (occ['NOM_PARA']+repr(vectval))+'\n') + + #---------------------------------------------- + # 99. Création de la table_sdaster résultat + # cas réentrant : il faut détruire l'ancienne table_sdaster + if self.sd.nom == TABLE.nom: + DETRUIRE(CONCEPT=_F(NOM=TABLE.nom,), INFO=1) + + dprod = tab.dict_CREA_TABLE() + if INFO == 2: + echo_mess = [] + echo_mess.append( '@-'*30+'\n' ) + echo_mess.append( tab ) + from pprint import pformat + echo_mess.append( pformat(dprod) ) + echo_mess.append( '@-'*30+'\n' ) + texte_final = ' '.join(echo_mess) + aster.affiche('MESSAGE', texte_final) + + # surcharge par le titre fourni + tit = args['TITRE'] + if tit != None: + if not type(tit) in EnumTypes: + tit = [tit] + dprod['TITRE'] = tuple(['%-80s' % lig for lig in tit]) + # type de la table de sortie à passer à CREA_TABLE + tabout = CREA_TABLE(**dprod) + + return ier diff --git a/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py b/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py new file mode 100644 index 00000000..3c41eccf --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py @@ -0,0 +1,522 @@ +#@ MODIF creation_donnees_homard Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE MCOURTOI M.COURTOIS +__all__ = [ ] +""" +Cette classe crée le fichier de configuration permettant de lancer HOMARD depuis Code_Aster. +""" +__revision__ = "V1.0" + +import os +import os.path + +try: + from Utilitai.Utmess import UTMESS +except ImportError: + def UTMESS(code, sprg, texte) : + """Clone de utmess si on ne reussit pas à le charger + """ + fmt = '\n <%s> <%s> %s\n\n' + print fmt % (code, sprg, texte) + +# ------------------------------------------------------------------------------ +class creation_donnees_homard: + """Cette classe crée les données permettant de lancer HOMARD depuis Code_Aster. + Ce sont : + . le fichier de configuration + . le fichier des données dans le cas d'information + + Arguments (stockés en tant qu'attribut) : + . nom_macro : nom de la macro-commande qui appelle : + 'MACR_ADAP_MAIL' pour une adaptation + 'MACR_INFO_MAIL' pour une information sur un maillage + . mots_cles : mots-clés de la macro-commande + . dico_configuration : dictionnaire des options + + Attributs : + . Nom_Fichier_Configuration : nom du fichier de configuration (immuable) + . Nom_Fichier_Donnees : nom du fichier de données (immuable) + . mode_homard : le mode pour filtrer ici ("ADAP" ou "INFO") + . ModeHOMA : le mode pour HOMARD (1 ou 2) + . mode_homard_texte : le mode d'utilisation, en francais ("ADAPTATION" ou "INFORMATION") + . elements_incompatibles : que faire des éléments incompatibles avec HOMARD + """ +# ------------------------------------------------------------------------------ + def __init__(self, nom_macro, mots_cles, dico_configuration ) : + """Construction + valeurs par défaut des attributs + """ +# +# 1. Vérification de la macro qui appelle +# + d_aux = {} + d_aux["MACR_ADAP_MAIL"] = ( "ADAP", 1, "ADAPTATION" ) + d_aux["MACR_INFO_MAIL"] = ( "INFO", 2, "INFORMATION" ) + if d_aux.has_key(nom_macro) : + self.mode_homard = d_aux[nom_macro][0] + self.ModeHOMA = d_aux[nom_macro][1] + self.mode_homard_texte = d_aux[nom_macro][2] + else : + UTMESS("F", nom_macro, "Cette macro commande est inconnue.") +# +# 2. Données générales de cette initialisation +# +#gn for mot_cle in mots_cles.keys() : +#gn print "mots_cles[", mot_cle, "] = ", mots_cles[mot_cle] +#gn for mot_cle in dico_configuration.keys() : +#gn print "dico_configuration[", mot_cle, "] = ", dico_configuration[mot_cle] +# + self.nom_macro = nom_macro + self.mots_cles = mots_cles + self.dico_configuration = dico_configuration +# +# 3. Quel type de traitement des elemenst incompatibles +# + if mots_cles.has_key("ELEMENTS_NON_HOMARD") : + d_aux = {} + d_aux["REFUSER"] = "TOUS" + d_aux["IGNORER"] = "IGNORE_QUAD" + self.elements_incompatibles = d_aux[mots_cles["ELEMENTS_NON_HOMARD"]] + else : + self.elements_incompatibles = None +# +# 4. Attributs immuables +# + self.Nom_Fichier_Configuration = "HOMARD.Configuration" + self.Nom_Fichier_Donnees = "HOMARD.Donnees" +# +# ------------------------------------------------------------------------------ + def int_to_str2 (self, entier) : + """ + Transforme un entier compris entre 0 et 99 en une chaine sur deux caractères + """ +# print "\nArguments a l'entree de", __name__, ":", entier +# + try: + la_chaine = '%02d' % entier + except TypeError: + la_chaine = None +# + return la_chaine +# ------------------------------------------------------------------------------ + def quel_mode (self) : + """Informe sur le mode de lancement de HOMARD + """ +### print self.mode_homard_texte + print "Lancement de creation_donnees_homard en mode", self.mode_homard_texte + return +# ------------------------------------------------------------------------------ + def creation_configuration (self) : + """Crée les données nécessaires à la configuration + """ +# + message_erreur = None +# + while message_erreur is None : +# +# 1. Les chaines liées aux numéros d'itération +# + if self.mode_homard == "ADAP" : + niter = self.dico_configuration["niter"] + self.str_niter = self.int_to_str2 (niter) + self.str_niterp1 = self.int_to_str2 (niter+1) + self.niter_vers_niterp1 = self.str_niter + ".vers." + self.str_niterp1 +# +# 2. La liste standard +# + if self.mode_homard == "INFO" : + aux = "Liste.info" + else : + aux = "Liste." + self.niter_vers_niterp1 + self.ListeStd = aux +# +# 3. Le type de bilan : il faut convertir la donnée textuelle en un entier, +# produit de nombres premiers. +# Si rien n'est demandé, on met 0. +# + aux = 1 + dico_aux = {} + dico_aux["INTERPENETRATION"] = 3 + dico_aux["NOMBRE"] = 7 + dico_aux["QUALITE"] = 5 + dico_aux["CONNEXITE"] = 11 + dico_aux["TAILLE"] = 13 + l_aux = dico_aux.keys() + for choix in l_aux : + if self.mots_cles.has_key(choix) : + if self.mots_cles[choix] == "OUI" : + aux = aux * dico_aux[choix] + if aux == 1 : + aux = 0 + self.TypeBila = aux +# +# 4. Les entrées/sorties au format MED +# + self.CCNoMN__ = self.dico_configuration["NOM_MED_MAILLAGE_N"] + if self.mode_homard == "ADAP" : + self.CCNoMNP1 = self.dico_configuration["NOM_MED_MAILLAGE_NP1"] + if self.dico_configuration.has_key("NOM_MED_MAILLAGE_NP1_ANNEXE") : + self.CCMaiAnn = self.dico_configuration["NOM_MED_MAILLAGE_NP1_ANNEXE"] +# +# 5. Les entrées/sorties au format HOMARD +# + if self.mode_homard == "ADAP" : + self.fic_homard_niter = "M_" + self.str_niter + ".hom" + self.fic_homard_niterp1 = "M_" + self.str_niterp1 + ".hom" + else : + self.fic_homard_niter = None +# +# 6.1. Le pilotage de l'adaptation +# + if self.mode_homard == "ADAP" : +# +# 6.1. Le type d'adaptation +# + if self.mots_cles["ADAPTATION"] == "RAFFINEMENT" or self.mots_cles["ADAPTATION"] == "RAFFINEMENT_ZONE" : + self.TypeRaff = "libre" + self.TypeDera = "non" + elif self.mots_cles["ADAPTATION"] == "DERAFFINEMENT" : + self.TypeRaff = "non" + self.TypeDera = "libre" + elif self.mots_cles["ADAPTATION"] == "RAFF_DERA" : + self.TypeRaff = "libre" + self.TypeDera = "libre" + elif self.mots_cles["ADAPTATION"] == "RAFFINEMENT_UNIFORME" : + self.TypeRaff = "uniforme" + self.TypeDera = "non" + elif self.mots_cles["ADAPTATION"] == "DERAFFINEMENT_UNIFORME" : + self.TypeRaff = "non" + self.TypeDera = "uniforme" + elif self.mots_cles["ADAPTATION"] == "RIEN" : + self.TypeRaff = "non" + self.TypeDera = "non" +#gn print "... self.TypeRaff = ",self.TypeRaff +#gn print "... self.TypeDera = ",self.TypeDera +# +# 6.2. L'éventuel seuil de raffinement +# + if self.TypeRaff == "libre" and self.mots_cles["ADAPTATION"] != "RAFFINEMENT_ZONE" : + d_aux = {} + d_aux["CRIT_RAFF_ABS"] = ("SeuilHau", 1) + d_aux["CRIT_RAFF_REL"] = ("SeuilHRe", 100) + d_aux["CRIT_RAFF_PE" ] = ("SeuilHPE", 100) + l_aux = d_aux.keys() + for mot_cle in l_aux : + if self.mots_cles[mot_cle] is not None : + aux = self.mots_cles[mot_cle]*d_aux[mot_cle][1] + self.critere_raffinement = (d_aux[mot_cle][0], aux) + else : + self.critere_raffinement = None +#gn print "... self.critere_raffinement = ", self.critere_raffinement +# +# 6.3. L'éventuel seuil de déraffinement +# + if self.TypeDera == "libre" : + d_aux = {} + d_aux["CRIT_DERA_ABS"] = ("SeuilBas", 1) + d_aux["CRIT_DERA_REL"] = ("SeuilBRe", 100) + d_aux["CRIT_DERA_PE" ] = ("SeuilBPE", 100) + l_aux = d_aux.keys() + for mot_cle in l_aux : + if self.mots_cles[mot_cle] is not None : + aux = self.mots_cles[mot_cle]*d_aux[mot_cle][1] + self.critere_deraffinement = (d_aux[mot_cle][0], aux) + else : + self.critere_deraffinement = None +#gn print "... self.critere_deraffinement = ", self.critere_deraffinement +# +# 6.4. Les niveaux extremes +# + self.niveau = [] + for mot_cle in [ "NIVE_MIN", "NIVE_MAX" ] : + if self.mots_cles.has_key(mot_cle) : + if self.mots_cles[mot_cle] is not None : + if mot_cle == "NIVE_MIN" : + aux = "NiveauMi" + else : + aux = "NiveauMa" + self.niveau.append((aux, self.mots_cles[mot_cle])) + if len(self.niveau) == 2 : +#gn print self.mots_cles["NIVE_MIN"] +#gn print self.mots_cles["NIVE_MAX"] + if self.mots_cles["NIVE_MIN"] >= self.mots_cles["NIVE_MAX"] : + message_erreur = "Le niveau mini ,"+str(self.mots_cles["NIVE_MIN"])+\ + ", doit etre < au niveau maxi, "+str(self.mots_cles["NIVE_MAX"])+"." + break +# +# 6.5. Les éventuelles zones de raffinement +# + if self.dico_configuration.has_key("Zones") : + iaux = 0 + for zone in self.dico_configuration["Zones"] : + iaux = iaux + 1 + s_aux_1 = "Zone numero "+str(iaux)+" : " + s_aux_2 = ", doit etre < au " + if zone.has_key("X_MINI") : + if zone["X_MINI"] >= zone["X_MAXI"] : + message_erreur = s_aux_1+"X mini ,"+str(zone["X_MINI"])+s_aux_2+"X maxi, "+str(zone["X_MAXI"])+"." + if zone["Y_MINI"] >= zone["Y_MAXI"] : + message_erreur = s_aux_1+"Y mini ,"+str(zone["Y_MINI"])+s_aux_2+"Y maxi, "+str(zone["Y_MAXI"])+"." + if zone.has_key("Z_MINI") : + if zone["Z_MINI"] >= zone["Z_MAXI"] : + message_erreur = s_aux_1+"Z mini ,"+str(zone["Z_MINI"])+s_aux_2+"Z maxi, "+str(zone["Z_MAXI"])+"." +# + break +# + if message_erreur is not None : + UTMESS("F", self.nom_macro, message_erreur) +# + return self.fic_homard_niter +# ------------------------------------------------------------------------------ + def ouvre_fichier (self, nomfic_local) : + """Ouvre en écriture un fichier après l'avoir éventuellement détruit + """ + codret_partiel = [0] +### print nomfic_local + Rep_Calc_HOMARD_global = self.dico_configuration["Rep_Calc_HOMARD_global"] + nomfic = os.path.join ( Rep_Calc_HOMARD_global , nomfic_local ) +# + if os.path.isfile (nomfic) : + try : + os.remove (nomfic) + except os.error, codret_partiel : + print "Probleme au remove, erreur numéro ", codret_partiel[0], ":", codret_partiel[1] + UTMESS("F", self.nom_macro, "Impossible de tuer le fichier "+nomfic) +# + fichier = open (nomfic,"w") + self.fichier = fichier +# + return fichier, nomfic +# ------------------------------------------------------------------------------ + def ecrire_ligne_configuration_0 (self, commentaire) : + """Ecrit une ligne de commentaires du fichier de configuration + Arguments : + . commentaire : le commentaire à écrire + """ +# + ligne = "#\n" + ligne = ligne + "# " + commentaire + "\n" + ligne = ligne + "#\n" + self.fichier.write(ligne) +# + return +# ------------------------------------------------------------------------------ + def ecrire_ligne_configuration_2 (self, motcle, valeur) : + """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur + Arguments : + . motcle : le mot-clé HOMARD à écrire + . valeur : la valeur associée + """ +# + ligne = motcle + " " + str(valeur) + "\n" + self.fichier.write(ligne) +# + return +# ------------------------------------------------------------------------------ + def ecrire_ligne_configuration_3 (self, motcle, valeur1, valeur2) : + """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur1 + valeur2 + Arguments : + . motcle : le mot-clé HOMARD à écrire + . valeur : la valeur associée + """ +# + ligne = motcle + " " + str(valeur1) + " " + str(valeur2) + "\n" + self.fichier.write(ligne) +# + return +# ------------------------------------------------------------------------------ + def ecrire_fichier_configuration (self) : + """Ecrit le fichier de configuration + """ + message_erreur = None +# + while message_erreur is None : +# +# 1. Ouverture du fichier +# + fichier, nomfic_global = self.ouvre_fichier(self.Nom_Fichier_Configuration) +# +# 2. Généralités +# + self.ecrire_ligne_configuration_0("Generalites") + self.ecrire_ligne_configuration_2("ModeHOMA", self.ModeHOMA) + self.ecrire_ligne_configuration_2("ListeStd", self.ListeStd) + self.ecrire_ligne_configuration_2("TypeBila", self.TypeBila) + self.ecrire_ligne_configuration_2("CCAssoci", "MED") + self.ecrire_ligne_configuration_2("NumeIter", self.dico_configuration["niter"]) +# +# 3. Les fichiers externes +# + self.ecrire_ligne_configuration_0("Les fichiers au format MED") + self.ecrire_ligne_configuration_2("CCNoMN__", self.CCNoMN__) + self.ecrire_ligne_configuration_2("CCMaiN__", self.dico_configuration["Fichier_ASTER_vers_HOMARD"]) + if self.mode_homard == "ADAP" : + self.ecrire_ligne_configuration_2("CCNoMNP1", self.CCNoMNP1) + self.ecrire_ligne_configuration_2("CCMaiNP1", self.dico_configuration["Fichier_HOMARD_vers_ASTER"]) +# + self.ecrire_ligne_configuration_0("Les fichiers de bilan") + self.ecrire_ligne_configuration_2("PPBasFic", "info") +# +# 4. Les fichiers HOMARD +# + self.ecrire_ligne_configuration_0("Les fichiers au format HOMARD") + if self.mode_homard == "ADAP" : + self.ecrire_ligne_configuration_3("HOMaiN__", "M_"+self.str_niter , self.fic_homard_niter ) + self.ecrire_ligne_configuration_3("HOMaiNP1", "M_"+self.str_niterp1, self.fic_homard_niterp1) + aux = "oui" + else : + aux = "non" + self.ecrire_ligne_configuration_2("EcriFiHO", aux) +# +# 5. Le pilotage de l'adaptation +# + if self.mode_homard == "ADAP" : + self.ecrire_ligne_configuration_0("Le pilotage de l'adaptation") +# +# 5.1. Type d'adaptation +# + self.ecrire_ligne_configuration_2("TypeRaff", self.TypeRaff) + if self.critere_raffinement is not None : + self.ecrire_ligne_configuration_2(self.critere_raffinement[0], self.critere_raffinement[1]) + self.ecrire_ligne_configuration_2("TypeDera", self.TypeDera) + if self.critere_deraffinement is not None : + self.ecrire_ligne_configuration_2(self.critere_deraffinement[0], self.critere_deraffinement[1]) +# +# 5.2. L'eventuel indicateur d'erreur +# + if self.dico_configuration.has_key("Indicateur") : +# + self.ecrire_ligne_configuration_0("L'indicateur d'erreur") + self.ecrire_ligne_configuration_2("CCIndica", self.dico_configuration["Fichier_ASTER_vers_HOMARD"]) + self.ecrire_ligne_configuration_2("CCNoChaI", self.dico_configuration["Indicateur"]["NOM_MED"]) + self.ecrire_ligne_configuration_2("CCCoChaI", self.dico_configuration["Indicateur"]["COMPOSANTE"]) + if self.dico_configuration["Indicateur"].has_key("NUME_ORDRE") : + self.ecrire_ligne_configuration_2("CCNumOrI", self.dico_configuration["Indicateur"]["NUME_ORDRE"]) + self.ecrire_ligne_configuration_2("CCNumPTI", self.dico_configuration["Indicateur"]["NUME_ORDRE"]) +# +# 5.3. Les niveaux extremes +# + for aux in self.niveau : + self.ecrire_ligne_configuration_2(aux[0], aux[1]) +# +# 6. Les éventuelles zones de raffinement +# + if self.dico_configuration.has_key("Zones") : + iaux = 0 + for zone in self.dico_configuration["Zones"] : + iaux = iaux + 1 + self.ecrire_ligne_configuration_0("Zone de raffinement numéro "+str(iaux)) + if zone.has_key("X_MINI") : + self.ecrire_ligne_configuration_3("ZoRaXmin", iaux, zone["X_MINI"]) + self.ecrire_ligne_configuration_3("ZoRaXmax", iaux, zone["X_MAXI"]) + self.ecrire_ligne_configuration_3("ZoRaYmin", iaux, zone["Y_MINI"]) + self.ecrire_ligne_configuration_3("ZoRaYmax", iaux, zone["Y_MAXI"]) + if zone.has_key("Z_MINI") : + self.ecrire_ligne_configuration_3("ZoRaZmin", iaux, zone["Z_MINI"]) + self.ecrire_ligne_configuration_3("ZoRaZmax", iaux, zone["Z_MAXI"]) + if zone.has_key("X_CENTRE") : + self.ecrire_ligne_configuration_3("ZoRaXCen", iaux, zone["X_CENTRE"]) + self.ecrire_ligne_configuration_3("ZoRaYCen", iaux, zone["Y_CENTRE"]) + self.ecrire_ligne_configuration_3("ZoRaRayo", iaux, zone["RAYON"]) + if zone.has_key("Z_CENTRE") : + self.ecrire_ligne_configuration_3("ZoRaZCen", iaux, zone["Z_CENTRE"]) +# +# 7. Les éventuels champs à mettre à jour +# + if self.dico_configuration.has_key("Champs") : + self.ecrire_ligne_configuration_0("Champs à mettre à jour") + self.ecrire_ligne_configuration_2("CCSolN__", self.dico_configuration["Fichier_ASTER_vers_HOMARD"]) + self.ecrire_ligne_configuration_2("CCSolNP1", self.dico_configuration["Fichier_HOMARD_vers_ASTER"]) + iaux = 0 + for maj_champ in self.dico_configuration["Champs"] : + iaux = iaux + 1 + self.ecrire_ligne_configuration_0("Mise à jour du champ numéro "+str(iaux)) + self.ecrire_ligne_configuration_3("CCChaNom", iaux, maj_champ["NOM_MED"]) + if maj_champ.has_key("NUME_ORDRE") : + self.ecrire_ligne_configuration_3("CCChaNuO", iaux, maj_champ["NUME_ORDRE"]) + self.ecrire_ligne_configuration_3("CCChaPdT", iaux, maj_champ["NUME_ORDRE"]) + elif maj_champ.has_key("INST") : + self.ecrire_ligne_configuration_3("CCChaIns", iaux, maj_champ["INST"]) +# +# 8. L'éventuel maillage de frontière +# + if self.dico_configuration.has_key("NOM_MED_MAILLAGE_FRONTIERE") : + self.ecrire_ligne_configuration_0("Maillage de frontière") + self.ecrire_ligne_configuration_2("SuivFron", "oui") + self.ecrire_ligne_configuration_2("CCFronti", self.dico_configuration["Fichier_ASTER_vers_HOMARD"]) + self.ecrire_ligne_configuration_2("CCNoMFro", self.dico_configuration["NOM_MED_MAILLAGE_FRONTIERE"]) + if self.mots_cles.has_key("GROUP_MA") : + if self.mots_cles["GROUP_MA"] is not None : + for group_ma in self.mots_cles["GROUP_MA"] : + self.ecrire_ligne_configuration_2("CCGroFro", group_ma) +# +# 9. L'usage des éléments incompatibles avec HOMARD +# + if self.elements_incompatibles is not None : + self.ecrire_ligne_configuration_0("Les éléments incompatibles avec HOMARD") + self.ecrire_ligne_configuration_2("TypeElem", self.elements_incompatibles) +# +# 10. Options particulières +# + self.ecrire_ligne_configuration_0("Autres options") + if self.mots_cles.has_key("LANGUE") : + self.ecrire_ligne_configuration_2("Langue", self.mots_cles["LANGUE"]) + self.ecrire_ligne_configuration_2("MessInfo", self.dico_configuration["INFO"]) + if self.dico_configuration["version_perso"] : + VERSION_HOMARD = self.dico_configuration["VERSION_HOMARD"] + self.ecrire_ligne_configuration_2("DicoOSGM", "$HOMARD_USER/"+VERSION_HOMARD+"/CONFIG/typobj.stu") +# +# 11. Fermeture du fichier +# + fichier.close() + break +# + if message_erreur is not None : + message_erreur = "Ecriture de "+nomfic_global+". "+message_erreur + UTMESS("F", self.nom_macro, message_erreur) +# + return +# ------------------------------------------------------------------------------ + def ecrire_fichier_donnees (self) : + """Ecrit le fichier des donnees dans le cas d'une demande d'information + """ + message_erreur = None +# + while message_erreur is None : +# +# 1. Ouverture du fichier +# + fichier, nomfic_global = self.ouvre_fichier(self.Nom_Fichier_Donnees) +# +# 2. On ne demande rien pour le moment +# + fichier.write("0\n") + fichier.write("0\n") + fichier.write("0\n") + fichier.write("q\n") +# +# n. Fermeture du fichier +# + fichier.close() + break +# + if message_erreur is not None : + UTMESS("F", self.nom_macro, message_erreur) +# + return nomfic_global diff --git a/Aster/Cata/cataSTA8/Macro/gene_vari_alea_ops.py b/Aster/Cata/cataSTA8/Macro/gene_vari_alea_ops.py new file mode 100644 index 00000000..829a93e7 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/gene_vari_alea_ops.py @@ -0,0 +1,109 @@ +#@ MODIF gene_vari_alea_ops Macro DATE 28/02/2006 AUTEUR VABHHTS J.PELLET +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +from math import sqrt,log,exp,pi,atan2,tan + +def gene_vari_alea_ops(self,**args): + self.set_icmd(1) + return 0 + +def gene_vari_alea_init(self,d): + from Utilitai.Utmess import UTMESS + a =self.etape['BORNE_INF'] + moyen =self.etape['VALE_MOY' ] + TYPE =self.etape['TYPE'] + if self['INIT_ALEA']!=None : + jump =self.etape['INIT_ALEA' ] + self.iniran(jump) + if TYPE=='EXP_TRONQUEE' : + b =self.etape['BORNE_SUP'] + if (a>=b) : + message=' : il faut BORNE_INF < BORNE_SUP \n' + message=message+' BORNE_INF = '+str(a)+'\n' + message=message+' BORNE_SUP = '+str(b)+'\n' + UTMESS('F','GENE_VARI_ALEA',message) + elif (moyen<=a)or(moyen>=b) : + message=' : VALE_MOY trop grand ou trop petit\n' + message=message+' BORNE_INF = '+str(a)+'\n' + message=message+' VALE_MOY = '+str(moyen)+'\n' + message=message+' BORNE_SUP = '+str(b)+'\n' + UTMESS('F','GENE_VARI_ALEA',message) + k=1./(moyen-a) + if (exp(-b*k)<1.E-12) : + message=' : BORNE SUP très grande \n' + message=message+'pb précision possible, vérifiez'+'\n' + message=message+'la distribution des valeurs générées \n' + UTMESS('F','GENE_VARI_ALEA',message) + # résolution par point fixe + eps =1.E-4 + nitmax=100000 + test =0. + while abs((test-k)/k)>eps : + test = k + k = 1./(moyen-(a*exp(-a*k) - b*exp(-b*k))/(exp(-a*k) - exp(-b*k))) + # génération de la variable aléatoire + alpha = exp(-a*k) - exp(-b*k) + self.sd.valeur=-( log(exp(-a*k)-alpha*self.getran()[0] ) ) /k + elif TYPE=='EXPONENTIELLE' : + if (moyen<=a) : + message=' : on doit avoir : VALE_MOY > BORNE_INF \n' + message=message+' VALE_MOY = '+str(moyen)+'\n' + message=message+' BORNE_INF = '+str(a)+'\n' + UTMESS('F','GENE_VARI_ALEA',message) + v = moyen-a + u=self.getran()[0] + x = -log(1-u) + self.sd.valeur=a + v*x + elif TYPE=='GAMMA' : + delta =self.etape['COEF_VAR' ] + if (moyen<=a) : + message=' : on doit avoir : VALE_MOY > BORNE_INF \n' + message=message+' VALE_MOY = '+str(moyen)+'\n' + message=message+' BORNE_INF = '+str(a)+'\n' + UTMESS('F','GENE_VARI_ALEA',message) + v = moyen-a + alpha = 1./(delta**2) + if (alpha<=1.) : + message=' : erreur : ALPHA < 1\n' + UTMESS('F','GENE_VARI_ALEA',message) + gamma2 = alpha-1. + gamm1 = 1./gamma2 + beta = sqrt(2.*alpha-1.) + beta2 = 1./(beta**2) + f0 = 0.5+(1./pi)*atan2(-gamma2/beta,1.) + c1 = 1.-f0 + c2 = f0-0.5 + vref = 0. + vv = -1. +# + while (-vv>vref) : + u=self.getran()[0] + gamdev = beta*tan(pi*(u*c1+c2))+gamma2 + unif=self.getran()[0] + if unif<0. : + message=' : erreur : unif < 0\n' + UTMESS('F','GENE_VARI_ALEA',message) + vv= -log(unif) + vref = log(1+beta2*((gamdev-gamma2)**2))+gamma2*log(gamdev*gamm1)-gamdev+gamma2 +# + if vv<=0. : + message=' : erreur : GAMDEV(ALPHA) < 0\n' + UTMESS('F','GENE_VARI_ALEA',message) + self.sd.valeur = a + v*(delta**2)*gamdev diff --git a/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py b/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py new file mode 100644 index 00000000..5f3f5533 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py @@ -0,0 +1,891 @@ +#@ MODIF post_k1_k2_k3_ops Macro DATE 22/05/2006 AUTEUR REZETTE C.REZETTE +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +def veri_tab(tab,nom,ndim) : + from Utilitai.Utmess import UTMESS + macro = 'POST_K1_K2_K3' + for label in ('DX','DY','COOR_X','COOR_Y','ABSC_CURV') : + if label not in tab.para : + message='le label '+label+' doit etre present dans la table : '+nom + UTMESS('F', macro, message) + if ndim==3 : + if 'DZ' not in tab.para : + message='le label DZ doit etre present dans la table : '+nom + UTMESS('F', macro, message) + if 'COOR_Z' not in tab.para : + message='le label COOR_Z doit etre present dans la table : '+nom + UTMESS('F', macro, message) + +def cross_product(a,b): + cross = [0]*3 + cross[0] = a[1]*b[2]-a[2]*b[1] + cross[1] = a[2]*b[0]-a[0]*b[2] + cross[2] = a[0]*b[1]-a[1]*b[0] + return cross + +def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, + TABL_DEPL_SUP,TABL_DEPL_INF,ABSC_CURV_MAXI,PREC_VIS_A_VIS, + TOUT_ORDRE,NUME_ORDRE,LIST_ORDRE,INST,LIST_INST,SYME_CHAR, + INFO,VECT_K1,TITRE,**args): + """ + Macro POST_K1_K2_K3 + Calcul des facteurs d'intensité de contraintes en 2D et en 3D + par extrapolation des sauts de déplacements sur les lèvres de + la fissure. Produit une table. + """ + import aster + import string + import copy + import math + import Numeric + from Numeric import array,asarray,Float,sqrt,matrixmultiply,transpose,sign,resize,dot,multiply + from math import pi + from types import ListType, TupleType + from Accas import _F + from Utilitai.Table import Table, merge + EnumTypes = (ListType, TupleType) + + macro = 'POST_K1_K2_K3' + from Accas import _F + from Utilitai.Utmess import UTMESS + + ier = 0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # Le concept sortant (de type table_sdaster ou dérivé) est tab + self.DeclareOut('tabout', self.sd) + + # On importe les definitions des commandes a utiliser dans la macro + # Le nom de la variable doit etre obligatoirement le nom de la commande + CREA_TABLE = self.get_cmd('CREA_TABLE') + CALC_TABLE = self.get_cmd('CALC_TABLE') + IMPR_TABLE = self.get_cmd('IMPR_TABLE') + POST_RELEVE_T = self.get_cmd('POST_RELEVE_T') + DETRUIRE = self.get_cmd('DETRUIRE') + MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE') + +# ------------------------------------------------------------------ +# CARACTERISTIQUES MATERIAUX +# ------------------------------------------------------------------ + matph = aster.getvectjev( string.ljust(MATER.nom,8)+'.MATERIAU.NOMRC ') + phenom=None + for cmpt in matph : + if cmpt[:4]=='ELAS' : + phenom=cmpt + break + if phenom==None : UTMESS('F', macro, 'IL FAUT DEFINIR ELAS DANS DEFI_MATERIAU') +# --- RECHERCHE SI LE MATERIAU DEPEND DE LA TEMPERATURE: + valk = aster.getvectjev( string.ljust(MATER.nom,8)+'.'+phenom[:10]+'.VALK') + valk = [x.strip() for x in valk] + valr = aster.getvectjev( string.ljust(MATER.nom,8)+'.'+phenom[:10]+'.VALR') + dicmat=dict(zip(valk,valr)) +# --- PROPRIETES MATERIAUX DEPENDANTES DE LA TEMPERATURE + Tempe3D = False + if dicmat.has_key('TEMP_DEF') and FOND_FISS and RESULTAT : +# on recupere juste le nom du resultat thermique + ndim = 3 + Lchar = aster.getvectjev(string.ljust(RESULTAT.nom,8)+'.0000.EXCIT.LCHA ') + for i in range(len(Lchar)): + resuth = aster.getvectjev(Lchar[i][0:8]+'.CHME.TEMPE.TEMP ') + if resuth !=None : + Tempe3D = True + break + elif dicmat.has_key('TEMP_DEF') and not Tempe3D : + message = 'LES PROPRIETES MATERIAUX, NECESSAIRES AUX CALCULS \n' + message = message +'DES COEFFICIENTS D INTENSITE DES CONTRAINTES, ONT ETE OBTENUES A LA\n' + message = message +'TEMPERATURE DE REFERENCE DU MATERIAU ET NON A LA TEMPERATURE CALCULEE.' + UTMESS('A', macro, message) + nompar = ('TEMP',) + valpar = (dicmat['TEMP_DEF'],) + nomres=['E','NU'] + valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F') + e = valres[0] + nu = valres[1] + + +# --- PROPRIETES MATERIAUX INDEPENDANTES DE LA TEMPERATURE + else : + e = dicmat['E'] + nu = dicmat['NU'] + + if not Tempe3D : + coefd3 = 0. + coefd = e * sqrt(2.*pi) + unmnu2 = 1. - nu**2 + unpnu = 1. + nu + if MODELISATION=='3D' : + UTMESS('I', macro, 'l operateur CALC_G -option CALC_K_G- calcule plus precisement les K1 K2 K3') + ndim = 3 + coefd = coefd / ( 8.0 * unmnu2 ) + coefd3 = e*sqrt(2*pi) / ( 8.0 * unpnu ) + coefg = unmnu2 / e + coefg3 = unpnu / e + elif MODELISATION=='AXIS' : + ndim = 2 + coefd = coefd / ( 8. * unmnu2 ) + coefg = unmnu2 / e + coefg3 = unpnu / e + elif MODELISATION=='D_PLAN' : + UTMESS('I', macro, 'l operateur CALC_G -option CALC_K_G- calcule plus precisement les K1 K2') + ndim = 2 + coefd = coefd / ( 8. * unmnu2 ) + coefg = unmnu2 / e + coefg3 = unpnu / e + elif MODELISATION=='C_PLAN' : + UTMESS('I', macro, 'l operateur CALC_G -option CALC_K_G- calcule plus precisement les K1 K2') + ndim = 2 + coefd = coefd / 8. + coefg = 1. / e + coefg3 = unpnu / e + else : + UTMESS('F', macro, 'modélisation non implantée') + + +# ------------------------------------------------------------------ +# CAS FOND_FISS +# ------------------------------------------------------------------ + if FOND_FISS : + MAILLAGE = args['MAILLAGE'] + NOEUD = args['NOEUD'] + SANS_NOEUD = args['SANS_NOEUD'] + GROUP_NO = args['GROUP_NO'] + SANS_GROUP_NO = args['SANS_GROUP_NO'] + TOUT = args['TOUT'] + TYPE_MAILLAGE = args['TYPE_MAILLAGE'] + NB_NOEUD_COUPE = args['NB_NOEUD_COUPE'] + LNOFO = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.FOND .NOEU ') + RECOL = False +# Cas double fond de fissure : par convention les noeuds sont ceux de fond_inf + if LNOFO==None : + RECOL = True + LNOFO = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.FOND_INF .NOEU ') + if LNOFO==None : UTMESS('F', macro, 'PROBLEME A LA RECUPERATION DES NOEUDS DU FOND DE FISSURE') + LNOFO = map(string.rstrip,LNOFO) + Nbfond = len(LNOFO) + +# ----------Mots cles TOUT, NOEUD, SANS_NOEUD ------------- + Typ = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.FOND .TYPE ') + if (Typ[0]=='SEG2 ') or (Typ[0]=='SEG3 ' and TOUT=='OUI') : + pas = 1 + elif (Typ[0]=='SEG3 ') : + pas = 2 + else : + UTMESS('F', macro, 'TYPE DE MAILLES DU FOND DE FISSURE NON DEFINI') +#### + NO_SANS = [] + NO_AVEC = [] + if GROUP_NO!=None : + collgrno=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO') + cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE') + if type(GROUP_NO) not in EnumTypes : GROUP_NO = (GROUP_NO,) + for m in range(len(GROUP_NO)) : + ngrno=GROUP_NO[m].ljust(8).upper() + if ngrno not in collgrno.keys() : + UTMESS('F', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE") + for i in range(len(collgrno[ngrno])) : NO_AVEC.append(cnom[collgrno[ngrno][i]-1]) + NO_AVEC= map(string.rstrip,NO_AVEC) + if NOEUD!=None : + if type(NOEUD) not in EnumTypes : NO_AVEC = (NOEUD,) + else : NO_AVEC = NOEUD + if SANS_GROUP_NO!=None : + collgrno=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO') + cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE') + if type(SANS_GROUP_NO) not in EnumTypes : SANS_GROUP_NO = (SANS_GROUP_NO,) + for m in range(len(SANS_GROUP_NO)) : + ngrno=SANS_GROUP_NO[m].ljust(8).upper() + if ngrno not in collgrno.keys() : + UTMESS('F', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE") + for i in range(len(collgrno[ngrno])) : NO_SANS.append(cnom[collgrno[ngrno][i]-1]) + NO_SANS= map(string.rstrip,NO_SANS) + if SANS_NOEUD!=None : + if type(SANS_NOEUD) not in EnumTypes : NO_SANS = (SANS_NOEUD,) + else : NO_SANS = SANS_NOEUD +# Creation de la liste des noeuds du fond a traiter : Lnf1 + Lnf1 = [] + Nbf1 = 0 + if len(NO_AVEC)!=0 : + for i in range(len(NO_AVEC)) : + if NO_AVEC[i] in LNOFO : + Lnf1.append(NO_AVEC[i]) + Nbf1 = Nbf1 +1 + else : + UTMESS('F', macro, 'LE NOEUD %s N APPARTIENT PAS AU FOND DE FISSURE'%NO_AVEC[i]) + else : + for i in range(0,Nbfond,pas) : + if not (LNOFO[i] in NO_SANS) : + Lnf1.append(LNOFO[i]) + Nbf1 = Nbf1 +1 + +##### Cas maillage libre########### +# creation des directions normales et macr_lign_coup + if TYPE_MAILLAGE =='LIBRE': + if not RESULTAT : UTMESS('F', macro, 'MOT CLE RESULTAT OBLIGATOIRE POUR TYPE_MAILLAGE = LIBRE') + Lnofon = Lnf1 + Nbnofo = Nbf1 + ListmaS = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.LEVRESUP .MAIL ') + if SYME_CHAR=='SANS': + ListmaI = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.LEVREINF .MAIL ') + __NCOFON=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees noeuds du fond', + NOEUD=LNOFO, + RESULTAT=RESULTAT, + NOM_CHAM='DEPL',NUME_ORDRE=1,NOM_CMP=('DX',), + OPERATION='EXTRACTION',),); + tcoorf=__NCOFON.EXTR_TABLE() + DETRUIRE(CONCEPT=_F(NOM=__NCOFON),INFO=1) + nbt = len(tcoorf['NOEUD'].values()['NOEUD']) + xs=array(tcoorf['COOR_X'].values()['COOR_X'][:nbt],Float) + ys=array(tcoorf['COOR_Y'].values()['COOR_Y'][:nbt],Float) + if ndim==2 : zs=Numeric.zeros(nbval,Float) + elif ndim==3 : zs=array(tcoorf['COOR_Z'].values()['COOR_Z'][:nbt],Float) + ns = tcoorf['NOEUD'].values()['NOEUD'][:nbt] + ns = map(string.rstrip,ns) + l_coorf = [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)] + l_coorf = [(i[0],i[1:]) for i in l_coorf] + d_coorf = dict(l_coorf) +# Calcul des normales a chaque noeud du fond + v1 = array(VECT_K1) + VN = [None]*Nbfond + absfon = [0,] + DTANOR = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_ORIGINE') + if DTANOR != None : + VN[0] = array(DTANOR) + else : + Pfon2 = array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]]) + Pfon3 = array([d_coorf[LNOFO[1]][0],d_coorf[LNOFO[1]][1],d_coorf[LNOFO[1]][2]]) + VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2)) + VN[i] = array(cross_product(VT,v1)) + for i in range(1,Nbfond-1): + Pfon1 = array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]]) + Pfon2 = array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]]) + Pfon3 = array([d_coorf[LNOFO[i+1]][0],d_coorf[LNOFO[i+1]][1],d_coorf[LNOFO[i+1]][2]]) + absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1] + absfon.append(absf) + VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2)) + VT = VT+(Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1)) + VN[i] = array(cross_product(VT,v1)) + VN[i] = VN[i]/sqrt(dot(transpose(VN[i]),VN[i])) + i = Nbfond-1 + Pfon1 = array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]]) + Pfon2 = array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]]) + absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1] + absfon.append(absf) + DTANEX = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_EXTREMITE') + if DTANEX != None : + VN[i] = array(DTANEX) + else : + VT = (Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1)) + VN[i] = array(cross_product(VT,v1)) + dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)]) + dicVN = dict([(LNOFO[i],VN[i]) for i in range(Nbfond)]) +#Extraction dep sup/inf sur les normales + TlibS = [None]*Nbf1 + TlibI = [None]*Nbf1 + if NB_NOEUD_COUPE < 3 : + message = 'LE NOMBRE DE NOEUDS NB_NOEUD_COUPE DOIT ETRE SUPERIEUR A 3 : ON PREND LA VALEUR PAR DEFAUT' + UTMESS('A', macro, message) + NB_NOEUD_COUPE = 5 + MOD = aster.getvectjev(string.ljust(RESULTAT.nom,19)+'.MODL ') + if MOD==None : UTMESS('F', macro, 'PROBLEME A LA RECUPERATION DU MODELE DANS LA SD RESULTAT FOURNIE') + MOD = map(string.rstrip,MOD) + MODEL = self.jdc.sds_dict[MOD[0]] + for i in range(Nbf1): + Porig = array(d_coorf[Lnf1[i]] ) + Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]] + TlibS[i] = MACR_LIGN_COUPE(RESULTAT=RESULTAT, + NOM_CHAM='DEPL',MODELE=MODEL, MAILLE = ListmaS, + LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],), + COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),),); + if SYME_CHAR=='SANS': + TlibI[i] = MACR_LIGN_COUPE(RESULTAT=RESULTAT, + NOM_CHAM='DEPL',MODELE=MODEL, MAILLE = ListmaI, + LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],), + COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),),); + + +##### Cas maillage regle########### + else: +# ---------- Dictionnaires des levres ------------- + NnormS = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.SUPNORM .NOEU ') + if NnormS==None : UTMESS('F', macro, 'PROBLEME A LA RECUPERATION DES NOEUDS DES LEVRES') + NnormS = map(string.rstrip,NnormS) + if LNOFO[0]==LNOFO[-1] : Nbfond=Nbfond-1 # Cas fond de fissure ferme + NnormS = [[LNOFO[i],NnormS[i*20:(i+1)*20]] for i in range(0,Nbfond)] + NnormS = [(i[0],i[1][0:]) for i in NnormS] + dicoS = dict(NnormS) + if SYME_CHAR=='SANS': + NnormI = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.INFNORM .NOEU ') + NnormI = map(string.rstrip,NnormI) + NnormI = [[LNOFO[i],NnormI[i*20:(i+1)*20]] for i in range(0,Nbfond)] + NnormI = [(i[0],i[1][0:]) for i in NnormI] + dicoI = dict(NnormI) + +# ---------- Dictionnaire des coordonnees ------------- + if RESULTAT : + Ltot = LNOFO + for i in range(Nbf1) : + for k in range(0,20) : + if dicoS[Lnf1[i]][k] !='': Ltot.append(dicoS[Lnf1[i]][k]) + if SYME_CHAR=='SANS': + for i in range(Nbf1) : + for k in range(0,20) : + if dicoI[Lnf1[i]][k] !='': Ltot.append(dicoI[Lnf1[i]][k]) + Ltot=dict([(i,0) for i in Ltot]).keys() + __NCOOR=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees noeuds des levres', + NOEUD=Ltot, + RESULTAT=RESULTAT, + NOM_CHAM='DEPL',NUME_ORDRE=1,NOM_CMP=('DX',), + OPERATION='EXTRACTION',),); + tcoor=__NCOOR.EXTR_TABLE() + DETRUIRE(CONCEPT=_F(NOM=__NCOOR),INFO=1) + else : + if SYME_CHAR=='SANS': + __NCOOR=CALC_TABLE(TABLE=TABL_DEPL_SUP, + ACTION=_F(OPERATION = 'COMB',NOM_PARA='NOEUD',TABLE=TABL_DEPL_INF,)) + tcoor=__NCOOR.EXTR_TABLE() + DETRUIRE(CONCEPT=_F(NOM=__NCOOR),INFO=1) + else : + tcoor=TABL_DEPL_SUP.EXTR_TABLE() + nbt = len(tcoor['NOEUD'].values()['NOEUD']) + xs=array(tcoor['COOR_X'].values()['COOR_X'][:nbt],Float) + ys=array(tcoor['COOR_Y'].values()['COOR_Y'][:nbt],Float) + if ndim==2 : zs=Numeric.zeros(nbval,Float) + elif ndim==3 : zs=array(tcoor['COOR_Z'].values()['COOR_Z'][:nbt],Float) + ns = tcoor['NOEUD'].values()['NOEUD'][:nbt] + ns = map(string.rstrip,ns) + l_coor = [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)] + l_coor = [(i[0],i[1:]) for i in l_coor] + d_coor = dict(l_coor) + +# ---------- Abscisse curviligne du fond ------------- + absfon = [0,] + for i in range(Nbfond-1) : + Pfon1 = array([d_coor[LNOFO[i]][0],d_coor[LNOFO[i]][1],d_coor[LNOFO[i]][2]]) + Pfon2 = array([d_coor[LNOFO[i+1]][0],d_coor[LNOFO[i+1]][1],d_coor[LNOFO[i+1]][2]]) + absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i] + absfon.append(absf) + dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)]) + + +# ---Noeuds LEVRE_SUP et LEVRE_INF: ABSC_CURV_MAXI et PREC_VIS_A_VIS----- + + NBTRLS = 0 + NBTRLI = 0 + Lnosup = [None]*Nbf1 + Lnoinf = [None]*Nbf1 + Nbnofo = 0 + Lnofon = [] + precv = PREC_VIS_A_VIS + if ABSC_CURV_MAXI!=None : rmax = ABSC_CURV_MAXI + else : rmax = 100 + precn = precv * rmax + rmprec= rmax*(1.+precv/10.) + for i in range(0,Nbf1) : + Pfon = array([d_coor[Lnf1[i]][0],d_coor[Lnf1[i]][1],d_coor[Lnf1[i]][2]]) + Tmpsup = [] + Tmpinf = [] + itots = 0 + itoti = 0 + NBTRLS = 0 + NBTRLI = 0 + for k in range(0,20) : + if dicoS[Lnf1[i]][k] !='': + itots = itots +1 + Nsup = dicoS[Lnf1[i]][k] + Psup = array([d_coor[Nsup][0],d_coor[Nsup][1],d_coor[Nsup][2]]) + abss = sqrt(dot(transpose(Pfon-Psup),Pfon-Psup)) + if abssprecn : + message= 'LES NOEUDS NE SONT PAS EN VIS-A-VIS \n' + message=message+'DANS LE PLAN PERPENDICULAIRE AU NOEUD %s \n'%Lnf1[i] + UTMESS('A', macro, message) + else : + NBTRLI = NBTRLI +1 + Tmpinf.append(dicoI[Lnf1[i]][k]) +# On verifie qu il y a assez de noeuds + if NBTRLS < 3 : + message= 'IL MANQUE DES POINTS DANS LE PLAN DEFINI PAR LA LEVRE \n' + message=message+'SUPERIEURE ET PERPENDICULAIRE AU FOND %s :\n'%Lnf1[i] + if itots<3 : message=message+' Augmenter PREC_NORM dans DEFI_FOND_FISS \n' + else : message=message+' Augmenter ABSC_CURV_MAXI' + if Lnf1[i]==LNOFO[0] or Lnf1[i]==LNOFO[-1]: message=message+' OU VERIFIER LES TANGENTES EXTREMITES' + UTMESS('A',macro, message) + elif (SYME_CHAR=='SANS') and (NBTRLI < 3) : + message= 'IL MANQUE DES POINTS DANS LE PLAN DEFINI PAR LA LEVRE \n' + message=message+'INFERIEURE ET PERPENDICULAIRE AU FOND %s :\n'%Lnf1[i] + if itoti<3 : message=message+' Augmenter PREC_NORM dans DEFI_FOND_FISS \n' + else : message=message+' Augmenter ABSC_CURV_MAXI' + if Lnf1[i]==LNOFO[0] or Lnf1[i]==LNOFO[-1]: message=message+' OU VERIFIER LES TANGENTES EXTREMITES' + UTMESS('A',macro, message) + else : + Lnosup[Nbnofo] = Tmpsup + if SYME_CHAR=='SANS' : Lnoinf[Nbnofo] = Tmpinf + Lnofon.append(Lnf1[i]) + Nbnofo = Nbnofo+1 + + else : + Nbnofo = 1 + +# ----------Recuperation de la temperature au fond ------------- + if Tempe3D : + resuth = map(string.rstrip,resuth) + Rth = self.jdc.sds_dict[resuth[0]] + __TEMP=POST_RELEVE_T(ACTION=_F(INTITULE='Temperature fond de fissure', + NOEUD=Lnofon,TOUT_CMP='OUI', + RESULTAT=Rth,NOM_CHAM='TEMP',TOUT_ORDRE='OUI', + OPERATION='EXTRACTION',),); + tabtemp=__TEMP.EXTR_TABLE() + DETRUIRE(CONCEPT=_F(NOM=__TEMP),INFO=1) + + +# ------------------------------------------------------------------ +# BOUCLE SUR NOEUDS DU FOND +# ------------------------------------------------------------------ + for ino in range(0,Nbnofo) : + if FOND_FISS and INFO==2 : + texte="\n\n--> TRAITEMENT DU NOEUD DU FOND DE FISSURE: %s"%Lnofon[ino] + aster.affiche('MESSAGE',texte) +# ------------------------------------------------------------------ +# TABLE 'DEPSUP' +# ------------------------------------------------------------------ + if FOND_FISS : + if TYPE_MAILLAGE =='LIBRE': + tabsup=TlibS[ino].EXTR_TABLE() + DETRUIRE(CONCEPT=_F(NOM=TlibS[ino]),INFO=1) + elif RESULTAT : + __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP', + NOEUD=Lnosup[ino], + RESULTAT=RESULTAT, + NOM_CHAM='DEPL', + TOUT_ORDRE='OUI', + NOM_CMP=('DX','DY','DZ',), + OPERATION='EXTRACTION',),); + tabsup=__TSUP.EXTR_TABLE() + DETRUIRE(CONCEPT=_F(NOM=__TSUP),INFO=1) + else : + tabsup=TABL_DEPL_SUP.EXTR_TABLE() + veri_tab(tabsup,TABL_DEPL_SUP.nom,ndim) + Ls = [string.ljust(Lnosup[ino][i],8) for i in range(len(Lnosup[ino]))] + tabsup=tabsup.NOEUD==Ls + else : + tabsup=TABL_DEPL_SUP.EXTR_TABLE() + veri_tab(tabsup,TABL_DEPL_SUP.nom,ndim) + +# ------------------------------------------------------------------ +# TABLE 'DEPINF' +# ------------------------------------------------------------------ + if SYME_CHAR=='SANS': + if FOND_FISS : + if TYPE_MAILLAGE =='LIBRE': + tabinf=TlibI[ino].EXTR_TABLE() + DETRUIRE(CONCEPT=_F(NOM=TlibI[ino]),INFO=1) + elif RESULTAT : + __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF', + NOEUD=Lnoinf[ino], + RESULTAT=RESULTAT, + NOM_CHAM='DEPL', + TOUT_ORDRE='OUI', + NOM_CMP=('DX','DY','DZ',), + OPERATION='EXTRACTION',),); + tabinf=__TINF.EXTR_TABLE() + DETRUIRE(CONCEPT=_F(NOM=__TINF),INFO=1) + else : + tabinf=TABL_DEPL_INF.EXTR_TABLE() + if TABL_DEPL_INF==None : UTMESS('F', macro, 'TABL_DEPL_SUP et TABL_DEPL_INF sont obligatoires si SYME_CHAR=SANS') + veri_tab(tabinf,TABL_DEPL_INF.nom,ndim) + Li = [string.ljust(Lnoinf[ino][i],8) for i in range(len(Lnoinf[ino]))] + tabinf=tabinf.NOEUD==Li + else : + if TABL_DEPL_INF==None : UTMESS('F', macro, 'TABL_DEPL_SUP et TABL_DEPL_INF sont obligatoires si SYME_CHAR=SANS') + tabinf=TABL_DEPL_INF.EXTR_TABLE() + veri_tab(tabinf,TABL_DEPL_INF.nom,ndim) + + +# ------------------------------------------------------------------ +# LES INSTANTS DE POST-TRAITEMENT +# ------------------------------------------------------------------ + if 'INST' in tabsup.para : + l_inst=None + l_inst_tab=tabsup['INST'].values()['INST'] + l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() #elimine les doublons + if LIST_ORDRE !=None or NUME_ORDRE !=None : + l_ord_tab = tabsup['NUME_ORDRE'].values()['NUME_ORDRE'] + l_ord_tab=dict([(i,0) for i in l_ord_tab]).keys() + d_ord_tab= [[l_ord_tab[i],l_inst_tab[i]] for i in range(0,len(l_ord_tab))] + d_ord_tab= [(i[0],i[1]) for i in d_ord_tab] + d_ord_tab = dict(d_ord_tab) + if NUME_ORDRE !=None : + if type(NUME_ORDRE) not in EnumTypes : NUME_ORDRE=(NUME_ORDRE,) + l_ord=list(NUME_ORDRE) + elif LIST_ORDRE !=None : + l_ord= aster.getvectjev(string.ljust(LIST_ORDRE.nom,19)+'.VALE') + l_inst = [] + for ord in l_ord : + if ord in l_ord_tab : l_inst.append(d_ord_tab[ord]) + else : + message ='LE NUMERO D ORDRE %i N A PAS ETE ETE TROUVE DANS LA TABLE\n'%ord + UTMESS('F', macro, message) + if INST !=None or LIST_INST !=None : + CRITERE = args['CRITERE'] + PRECISION = args['PRECISION'] + else : + l_inst=l_inst_tab + PRECISION = 1.E-6 + CRITERE='ABSOLU' + if INST !=None : + if type(INST) not in EnumTypes : INST=(INST,) + l_inst=list(INST) + elif LIST_INST !=None : l_inst=LIST_INST.Valeurs() + if l_inst !=None : + for inst in l_inst : + if CRITERE=='RELATIF' and inst!=0.: match=[x for x in l_inst_tab if abs((inst-x)/inst)=2 : + message = 'PLUSIEURS INSTANTS TROUVES DANS LA TABLE POUR L INSTANT %f\n'%inst + UTMESS('F', macro, message) + else : + l_inst = l_inst_tab + else : + l_inst = [None,] + +# ------------------------------------------------------------------ +# BOUCLE SUR LES INSTANTS +# ------------------------------------------------------------------ + for iord in range(len(l_inst)) : + inst=l_inst[iord] + if INFO==2 and inst!=None: + texte="==> INSTANT: %f"%inst + aster.affiche('MESSAGE',texte) + if inst!=None: + if PRECISION == None : PRECISION = 1.E-6 + if CRITERE == None : CRITERE='ABSOLU' + if inst==0. : + tabsupi=tabsup.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION) + if SYME_CHAR=='SANS': tabinfi=tabinf.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION) + else : + tabsupi=tabsup.INST.__eq__(VALE=inst,CRITERE=CRITERE,PRECISION=PRECISION) + if SYME_CHAR=='SANS': tabinfi=tabinf.INST.__eq__(VALE=inst,CRITERE=CRITERE,PRECISION=PRECISION) + else : + tabsupi=tabsup + if SYME_CHAR=='SANS': tabinfi=tabinf + +# --- LEVRE SUP : "ABSC_CURV" CROISSANTES, < RMAX ET DEP --- + abscs = getattr(tabsupi,'ABSC_CURV').values() + if not FOND_FISS : + refs=copy.copy(abscs) + refs.sort() + if refs!=abscs : UTMESS('F', macro, 'ABSC_CURV NON CROISSANTS POUR TABL_DEPL_INF') + if ABSC_CURV_MAXI!=None : rmax = ABSC_CURV_MAXI + else : rmax = abscs[-1] + precv = PREC_VIS_A_VIS + rmprec= rmax*(1.+precv/10.) + refsc=[x for x in refs if xprecn : UTMESS('F', macro, 'LES NOEUDS NE SONT PAS EN VIS_A_VIS') + + if FOND_FISS and not RESULTAT :#tri des noeuds avec abscisse + Pfon = array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]]) + absci = sqrt((coxi-Pfon[0])**2+(coyi-Pfon[1])**2+(cozi-Pfon[2])**2) + tabinfi['Abs_fo'] = absci + tabinfi.sort('Abs_fo') + absci = getattr(tabinfi,'Abs_fo').values() + absci=array(abscs[:nbval]) + coxi=array(tabinfi['COOR_X'].values()['COOR_X'][:nbval],Float) + coyi=array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval],Float) + if ndim==2 : cozi=Numeric.zeros(nbval,Float) + elif ndim==3 : cozi=array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval],Float) + + dxi=array(tabinfi['DX'].values()['DX'][:nbval],Float) + dyi=array(tabinfi['DY'].values()['DY'][:nbval],Float) + if ndim==2 : dzi=Numeric.zeros(nbval,Float) + elif ndim==3 : dzi=array(tabinfi['DZ'].values()['DZ'][:nbval],Float) + + if FOND_FISS and INFO==2 and iord==0 and not TYPE_MAILLAGE =='LIBRE': + for ki in range(0,nbval) : + texte="NOEUD RETENU POUR LA LEVRE INF: %s %f"%(Lnoinf[ino][ki],absci[ki]) + aster.affiche('MESSAGE',texte) + +# --- TESTS NOMBRE DE NOEUDS--- + if nbval<3 : + message= 'IL FAUT AU MOINS TROIS NOEUDS DANS LE PLAN DEFINI PAR LES LEVRES ET PERPENDICULAIRE AU FOND DE FISSURE' + if FOND_FISS : message=message+'Noeud %.s \n'%Lnofon[ino] + message=message+' : augmenter ABSC_CURV_MAXI\n' + UTMESS('F',macro, message) + +# ---------- CALCUL PROP. MATERIAU AVEC TEMPERATURE ----------- + if Tempe3D : + tempeno=tabtemp.NOEUD==Lnofon[ino] + tempeno=tempeno.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION) + nompar = ('TEMP',) + valpar = (tempeno.TEMP.values()[0],) + nomres=['E','NU'] + valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F') + e = valres[0] + nu = valres[1] + coefd = e * sqrt(2.*pi) / ( 8.0 * (1. - nu**2)) + coefd3 = e*sqrt(2*pi) / ( 8.0 * (1. + nu)) + coefg = (1. - nu**2) / e + coefg3 = (1. + nu) / e + +# ------------------------------------------------------------------ +# CHANGEMENT DE REPERE +# ------------------------------------------------------------------ +# +# 1 : VECTEUR NORMAL AU PLAN DE LA FISSURE +# ORIENTE LEVRE INFERIEURE VERS LEVRE SUPERIEURE +# 2 : VECTEUR NORMAL AU FOND DE FISSURE EN M +# 3 : VECTEUR TANGENT AU FOND DE FISSURE EN M +# + if SYME_CHAR=='SANS' : + vo = array([( coxs[-1]+coxi[-1] )/2.,( coys[-1]+coyi[-1] )/2.,( cozs[-1]+cozi[-1] )/2.]) + ve = array([( coxs[0 ]+coxi[0 ] )/2.,( coys[0 ]+coyi[0 ] )/2.,( cozs[0 ]+cozi[0 ] )/2.]) + else : + vo = array([ coxs[-1], coys[-1], cozs[-1]]) + ve = array([ coxs[0], coys[0], cozs[0]]) + v1 = array(VECT_K1) + v2 = ve-vo + v2 = v2/sqrt(v2[0]**2+v2[1]**2+v2[2]**2) + v1p = sum(v2*v1) + v1 = v1-v1p*v2 + v1 = v1/sqrt(v1[0]**2+v1[1]**2+v1[2]**2) + v3 = array([v1[1]*v2[2]-v2[1]*v1[2],v1[2]*v2[0]-v2[2]*v1[0],v1[0]*v2[1]-v2[0]*v1[1]]) + pgl = asarray([v1,v2,v3]) + dpls = asarray([dxs,dys,dzs]) + dpls = matrixmultiply(pgl,dpls) + if SYME_CHAR=='SANS' : + dpli = asarray([dxi,dyi,dzi]) + dpli = matrixmultiply(pgl,dpli) + else : + dpli = [multiply(dpls[0],-1.),dpls[1],dpls[2]] +# ------------------------------------------------------------------ +# CALCUL DES K1, K2, K3 +# ------------------------------------------------------------------ + saut=(dpls-dpli) + isig=sign(transpose(resize(saut[:,-1],(nbval-1,3)))) + isig=sign(isig+0.001) + saut=saut*array([[coefd]*nbval,[coefd]*nbval,[coefd3]*nbval]) + saut=saut**2 + ksig = isig[:,1] + ksig = array([ksig,ksig]) + ksig = transpose(ksig) + kgsig=resize(ksig,(1,6))[0] + if INFO==2 : + mcfact=[] + mcfact.append(_F(PARA='ABSC_CURV' ,LISTE_R=abscs.tolist() )) + mcfact.append(_F(PARA='DEPL_SUP_DX',LISTE_R=dpls[0].tolist() )) + mcfact.append(_F(PARA='DEPL_INF_DX',LISTE_R=dpli[0].tolist() )) + mcfact.append(_F(PARA='SAUT_DX' ,LISTE_R=saut[0].tolist() )) + mcfact.append(_F(PARA='DEPL_SUP_DY',LISTE_R=dpls[1].tolist() )) + mcfact.append(_F(PARA='DEPL_INF_DY',LISTE_R=dpli[1].tolist() )) + mcfact.append(_F(PARA='SAUT_DY' ,LISTE_R=saut[1].tolist() )) + if ndim==3 : + mcfact.append(_F(PARA='DEPL_SUP_DZ',LISTE_R=dpls[2].tolist() )) + mcfact.append(_F(PARA='DEPL_INF_DZ',LISTE_R=dpli[2].tolist() )) + mcfact.append(_F(PARA='SAUT_DZ' ,LISTE_R=saut[2].tolist() )) + __resu0=CREA_TABLE(LISTE=mcfact,TITRE='--> SAUTS') + aster.affiche('MESSAGE',__resu0.EXTR_TABLE().__repr__()) + DETRUIRE(CONCEPT=_F(NOM=__resu0),INFO=1) +# ------------------------------------------------------------------ +# --- METHODE 1 --- +# ------------------------------------------------------------------ + x1 = abscs[1:-1] + x2 = abscs[2: ] + y1 = saut[:,1:-1]/x1 + y2 = saut[:,2: ]/x2 + k = abs(y1-x1*(y2-y1)/(x2-x1)) + g = coefg*(k[0]+k[1])+coefg3*k[2] + kg1 = [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])] + kg1 = sqrt(kg1)*kgsig + kg1=Numeric.concatenate([kg1,[max(g),min(g)]]) + vk = sqrt(k)*isig[:,:-1] + if INFO==2 : + mcfact=[] + mcfact.append(_F(PARA='ABSC_CURV_1' ,LISTE_R=x1.tolist() )) + mcfact.append(_F(PARA='ABSC_CURV_2' ,LISTE_R=x2.tolist() )) + mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0].tolist() )) + mcfact.append(_F(PARA='K2' ,LISTE_R=vk[1].tolist() )) + if ndim==3 : + mcfact.append(_F(PARA='K3' ,LISTE_R=vk[2].tolist() )) + mcfact.append(_F(PARA='G' ,LISTE_R=g.tolist() )) + __resu1=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 1') + aster.affiche('MESSAGE',__resu1.EXTR_TABLE().__repr__()) + DETRUIRE(CONCEPT=_F(NOM=__resu1),INFO=1) +# ------------------------------------------------------------------ +# --- METHODE 2 --- +# ------------------------------------------------------------------ + x1 = abscs[1: ] + y1 = saut[:,1:] + k = abs(y1/x1) + g = coefg*(k[0]+k[1])+coefg3*k[2] + kg2= [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])] + kg2 = sqrt(kg2)*kgsig + kg2=Numeric.concatenate([kg2,[max(g),min(g)]]) + vk = sqrt(k)*isig + if INFO==2 : + mcfact=[] + mcfact.append(_F(PARA='ABSC_CURV' ,LISTE_R=x1.tolist() )) + mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0].tolist() )) + mcfact.append(_F(PARA='K2' ,LISTE_R=vk[1].tolist() )) + if ndim==3 : + mcfact.append(_F(PARA='K3' ,LISTE_R=vk[2].tolist() )) + mcfact.append(_F(PARA='G' ,LISTE_R=g.tolist() )) + __resu2=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 2') + aster.affiche('MESSAGE',__resu2.EXTR_TABLE().__repr__()) + DETRUIRE(CONCEPT=_F(NOM=__resu2),INFO=1) +# ------------------------------------------------------------------ +# --- METHODE 3 --- +# ------------------------------------------------------------------ + x1 = abscs[:-1] + x2 = abscs[1: ] + y1 = saut[:,:-1] + y2 = saut[:,1: ] + k = (sqrt(y2)*sqrt(x2)+sqrt(y1)*sqrt(x1))*(x2-x1) + k = Numeric.sum(transpose(k)) + de = abscs[-1] + vk = (k/de**2)*isig[:,0] + g = coefg*(vk[0]**2+vk[1]**2)+coefg3*vk[2]**2 + kg3=Numeric.concatenate([[vk[0]]*2,[vk[1]]*2,[vk[2]]*2,[g]*2]) + if INFO==2 : + mcfact=[] + mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0] )) + mcfact.append(_F(PARA='K2' ,LISTE_R=vk[1] )) + if ndim==3 : + mcfact.append(_F(PARA='K3' ,LISTE_R=vk[2] )) + mcfact.append(_F(PARA='G' ,LISTE_R=g )) + __resu3=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 3') + aster.affiche('MESSAGE',__resu3.EXTR_TABLE().__repr__()) + DETRUIRE(CONCEPT=_F(NOM=__resu3),INFO=1) +# ------------------------------------------------------------------ +# CREATION DE LA TABLE +# ------------------------------------------------------------------ + kg=array([kg1,kg2,kg3]) + kg=transpose(kg) + mcfact=[] + if TITRE != None : + titre = TITRE + else : + v = aster.__version__ + titre = 'ASTER %s - CONCEPT CALCULE PAR POST_K1_K2_K3 LE &DATE A &HEURE \n'%v + if FOND_FISS : + mcfact.append(_F(PARA='NOEUD_FOND',LISTE_K=[Lnofon[ino],]*3)) + mcfact.append(_F(PARA='ABSC_CURV',LISTE_R=[dicoF[Lnofon[ino]]]*3)) + mcfact.append(_F(PARA='METHODE',LISTE_I=(1,2,3))) + mcfact.append(_F(PARA='K1_MAX' ,LISTE_R=kg[0].tolist() )) + mcfact.append(_F(PARA='K1_MIN' ,LISTE_R=kg[1].tolist() )) + mcfact.append(_F(PARA='K2_MAX' ,LISTE_R=kg[2].tolist() )) + mcfact.append(_F(PARA='K2_MIN' ,LISTE_R=kg[3].tolist() )) + if ndim==3 : + mcfact.append(_F(PARA='K3_MAX' ,LISTE_R=kg[4].tolist() )) + mcfact.append(_F(PARA='K3_MIN' ,LISTE_R=kg[5].tolist() )) + mcfact.append(_F(PARA='G_MAX' ,LISTE_R=kg[6].tolist() )) + mcfact.append(_F(PARA='G_MIN' ,LISTE_R=kg[7].tolist() )) + if (ino==0 and iord==0) and inst==None : + tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre) + elif iord==0 and ino==0 and inst!=None : + mcfact=[_F(PARA='INST' ,LISTE_R=[inst,]*3 )]+mcfact + tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre) + else : + if inst!=None : mcfact=[_F(PARA='INST' ,LISTE_R=[inst,]*3 )]+mcfact + __tabi=CREA_TABLE(LISTE=mcfact,) + npara = ['K1_MAX','METHODE'] + if inst!=None : npara.append('INST') + if FOND_FISS : npara.append('NOEUD_FOND') + tabout=CALC_TABLE(reuse=tabout,TABLE=tabout,TITRE = titre, + ACTION=_F(OPERATION = 'COMB',NOM_PARA=npara,TABLE=__tabi,)) + +# Tri pour conserver le meme ordre que operateur initial en fortran + if len(l_inst)!=1 and FOND_FISS : + tabout=CALC_TABLE(reuse=tabout,TABLE=tabout, + ACTION=_F(OPERATION = 'TRI',NOM_PARA=('INST','ABSC_CURV','METHODE'),ORDRE='CROISSANT')) + + return ier + diff --git a/Aster/Cata/cataSTA8/Macro/reca_graphique.py b/Aster/Cata/cataSTA8/Macro/reca_graphique.py new file mode 100644 index 00000000..bab1d8c2 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/reca_graphique.py @@ -0,0 +1,92 @@ +#@ MODIF reca_graphique Macro DATE 08/11/2005 AUTEUR ASSIRE A.ASSIRE +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +import string, copy, Numeric, types +import Cata +from Cata.cata import DEFI_FICHIER, IMPR_FONCTION +from Utilitai.Utmess import UTMESS +from Accas import _F + +try: + import Gnuplot +except: + pass + + +#_____________________________________________ +# +# IMPRESSIONS GRAPHIQUES +#_____________________________________________ + +def graphique(FORMAT, L_F, res_exp, reponses, iter, UL_out, interactif): + + if FORMAT=='XMGRACE': + for i in range(len(L_F)): + _tmp = [] + courbe1 = res_exp[i] + _tmp.append( { 'ABSCISSE': courbe1[:,0].tolist(), 'ORDONNEE': courbe1[:,1].tolist(), 'COULEUR': 1 } ) + courbe2 = L_F[i] + _tmp.append( { 'ABSCISSE': courbe2[:,0].tolist(), 'ORDONNEE': courbe2[:,1].tolist(), 'COULEUR': 2 } ) + + motscle2= {'COURBE': _tmp } + if interactif: motscle2['PILOTE']= 'INTERACTIF' + else: motscle2['PILOTE']= 'POSTSCRIPT' + +# DEFI_FICHIER(UNITE=int(UL_out), ACCES='NEW',) + + IMPR_FONCTION(FORMAT='XMGRACE', + UNITE=int(UL_out), + TITRE='Courbe de : ' + reponses[i][0], + SOUS_TITRE='Iteration : ' + str(iter), + LEGENDE_X=reponses[i][1], + LEGENDE_Y=reponses[i][2], + **motscle2 + ); +# DEFI_FICHIER(ACTION='LIBERER',UNITE=int(UL_out),) + + elif FORMAT=='GNUPLOT': + graphe=[] + impr=Gnuplot.Gnuplot() + Gnuplot.GnuplotOpts.prefer_inline_data=1 + impr('set data style linespoints') + impr('set grid') + impr('set pointsize 2.') + impr('set terminal postscript color') + impr('set output "fort.'+str(UL_out)+'"') + + for i in range(len(L_F)): + if interactif: + graphe.append(Gnuplot.Gnuplot(persist=0)) + graphe[i]('set data style linespoints') + graphe[i]('set grid') + graphe[i]('set pointsize 2.') + graphe[i].xlabel(reponses[i][1]) + graphe[i].ylabel(reponses[i][2]) + graphe[i].title(reponses[i][0]+' Iteration '+str(iter)) + graphe[i].plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental')) + graphe[i]('pause 5') + + impr.xlabel(reponses[i][1]) + impr.ylabel(reponses[i][2]) + impr.title(reponses[i][0]+' Iteration '+str(iter)) + impr.plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental')) + + else: + pass -- 2.39.2