def crea_noeu_lig_coup(dimension, pt1, pt2, anglj, dnor): from Utilitai.Utmess import UTMESS from math import pi, sin, cos, sqrt a = pt1[0] - pt2[0] b = pt1[1] - pt2[1] eps = 0.00000001 anglr = anglj * pi / 180. if dimension == 2: r = sqrt(a ** 2 + b ** 2) if abs(r) < eps: UTMESS('F', 'POST0_6') x = pt2[0] + a * cos(anglr) - b * sin(anglr) y = pt2[1] + b * cos(anglr) + a * sin(anglr) return x, y elif dimension == 3: c = pt1[2] - pt2[2] r = sqrt(a ** 2 + b ** 2 + c ** 2) if abs(r) < eps: UTMESS('F', 'POST0_6') d1 = dnor[0] d2 = dnor[1] d3 = dnor[2] d = sqrt(d1 ** 2 + d2 ** 2 + d3 ** 2) if abs(r) < eps: UTMESS('F', 'POST0_7') x = pt2[0] + a * cos(anglr) + sin(anglr) * (c * d2 - b * d3) / d y = pt2[1] + b * cos(anglr) + sin(anglr) * (a * d3 - c * d1) / d z = pt2[2] + c * cos(anglr) + sin(anglr) * (b * d1 - a * d2) / d return x, y, z
def INCLUDE(self, UNITE, DONNEE, **args): """Fonction sd_prod pour la macro INCLUDE""" self.show_children = args.get('INFO', 1) != 0 if not (UNITE or DONNEE) or hasattr(self, '_mark'): return self._mark = 1 if self.jdc and self.jdc.par_lot == 'NON': # On est en mode commande par commande, on appelle la methode speciale self.Execute_alone() if UNITE: fname = 'fort.%s' % UNITE else: fname = DONNEE if aster_exists: repdex = aster_core.get_option('repdex') fname = osp.join(repdex, fname) try: if aster_exists: self.make_include(fname=fname) else: # dans eficas if UNITE: self.make_include(unite=UNITE) else: self.make_include(fname=fname) except Accas.AsException: if aster_exists: UTMESS('F+', 'FICHIER_1', valk=fname) UTMESS('F', 'FICHIER_2') raise
def corrcoefmodel(Period, f_beta=None): # --------------------------------------------------------- # IN : Periods= liste des periodes 1/f [s] # optionnel: liste de beta (ecart-type) # OUT : mat_out= matrice de covariance pour periodes T # >>>coef de correlation (ecart-type=1) si beta=None # >>>covariance si beta=tfonction # # REFERENCE corrcoef selon le modele de Baker: # Baker & Jayaram, Earthquake Spectra 24(1),299-317, 2008. # # --------------------------------------------------------- PMIN = min(Period) if PMIN < 0.01: UTMESS('F', 'SEISME_37', valk=(str(1. / PMIN))) if max(Period) > 10.: nb = len(NP.extract(Period > 10., Period)) Periods = Period[nb:] else: Periods = Period nbT = len(Periods) Mat_Eps = NP.array([0.0] * nbT * nbT) Mat_Eps.resize(nbT, nbT) # Le modele de Baker est defini pour max(Periods)<=10. if f_beta != None: if min(f_beta.vale_x) > 0.1: UTMESS('F', 'SEISME_82') else: f_beta = f_beta.evalfonc(1. / Periods) vale_beta = f_beta.vale_y for (ii, Ti) in enumerate(Periods): for (jj, Tj) in enumerate(Periods): Tmin = min(Ti, Tj) Tmax = max(Ti, Tj) C1 = 1. - cos(pi / 2. - 0.366 * log(Tmax / max(Tmin, 0.109))) C3 = C1 if Tmax < 0.109: C2 = 1. - 0.105 * \ (1. - 1. / (1. + exp(100. * Tmax - 5.))) * ( (Tmax - Tmin) / (Tmax - 0.0099)) Mat_Eps[ii, jj] = C2 elif Tmin > 0.109: Mat_Eps[ii, jj] = C1 elif Tmax < 0.2: C2 = 1. - 0.105 * \ (1 - 1 / (1 + exp(100 * Tmax - 5))) * ( (Tmax - Tmin) / (Tmax - 0.0099)) C4 = C1 + 0.5 * (sqrt(C3) - C3) * (1 + cos(pi * Tmin / 0.109)) Mat_Eps[ii, jj] = min(C2, C4) else: C4 = C1 + 0.5 * (sqrt(C3) - C3) * (1. + cos(pi * Tmin / 0.109)) Mat_Eps[ii, jj] = C4 if f_beta != None: Mat_Eps[ii, jj] = Mat_Eps[ii, jj] * vale_beta[ii] * vale_beta[jj] Mat_Gx = NP.linalg.cholesky(Mat_Eps) return Periods, Mat_Gx
def lire_table_ops(self, UNITE, FORMAT, SEPARATEUR, NUME_TABLE, RENOMME_PARA, INFO, TITRE, **args): """Méthode corps de la macro LIRE_TABLE """ import aster from Utilitai.Utmess import UTMESS, raise_UTMESS from Utilitai.UniteAster import UniteAster from Utilitai.TableReader import TableReaderFactory, unique_parameters ier = 0 # On importe les definitions des commandes a utiliser dans la macro CREA_TABLE = self.get_cmd('CREA_TABLE') # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # Lecture de la table dans un fichier d unité logique UNITE UL = UniteAster() nomfich = UL.Nom(UNITE) if not osp.isfile(nomfich): UTMESS('F', 'FONCT0_41', valk=nomfich) texte = open(nomfich, 'r').read() # remet UNITE dans son état initial UL.EtatInit() check_para = None if RENOMME_PARA == "UNIQUE": check_para = unique_parameters reader = TableReaderFactory(texte, FORMAT, SEPARATEUR, debug=(INFO == 2)) try: tab = reader.read(NUME_TABLE, check_para=check_para) except TypeError, exc: UTMESS('F', 'TABLE0_45', valk=str(exc))
def RCVALE(self, phenomene, nompar=(), valpar=(), nomres=(), stop=1): """Appel à la routine fortran RCVALE pour récupérer les valeurs des propriétés du matériau. """ if not self.accessible(): raise AsException("Erreur dans mater.RCVALE en PAR_LOT='OUI'") from Utilitai.Utmess import UTMESS # vérification des arguments if not type(nompar) in (list, tuple): nompar = [nompar,] if not type(valpar) in (list, tuple): valpar = [valpar,] if not type(nomres) in (list, tuple): nomres = [nomres,] nompar = tuple(nompar) valpar = tuple(valpar) nomres = tuple(nomres) if len(nompar) != len(valpar): vk1=', '.join(nompar) vk2=', '.join([repr(v) for v in valpar]) UTMESS('F','SDVERI_4',valk=[vk1,vk2]) if len(nomres) < 1: UTMESS('F', 'SDVERI_5') # appel à l'interface Python/C return aster.rcvale(self.nom, phenomene, nompar, valpar, nomres, stop)
def get_para_loi(loi, relation, l_para, l_vale, l_para1, l_vale1, nom_mater, donnees, liste_fonc): """ Lecture des paramètres de la loi 'loi' """ cle = relation + '/' + loi if not cata_lois[cle].has_key('POSI_PARA'): posi_para = False else: posi_para = True for ipar, para in enumerate(cata_lois[cle]['PARA']): if donnees.has_key(para): para_epx = cata_lois[cle]['PARA_EPX'][ipar] type_donnee = cata_lois[cle]['TYPE'][ipar] if type_donnee == 'fonc': car_temp = donnees[para] nom_fonc = car_temp.get_name() ifonc = len(liste_fonc) + 1 for dic_fonc in liste_fonc: if type(dic_fonc) is dict: nom = dic_fonc['NOM_FONC'] if nom == nom_fonc: ifonc = dic_fonc['NUME'] break if ifonc > len(liste_fonc): val = car_temp.Valeurs() dic_fonc = {'VALE': val, 'NUME': ifonc, 'NOM_FONC': nom_fonc } liste_fonc.append(dic_fonc) vale = 'FONC %i' % ifonc elif type_donnee == 'mfac': raise Exception( 'Erreur de programmation : type de donnees mfac impossible') else: vale = donnees[para] if type(para_epx) == float or type(para_epx) == int: if vale != para_epx: UTMESS('F', 'PLEXUS_49', valk=(para, loi, nom_mater), valr=(para_epx, vale)) if not posi_para: l_para.append(para_epx) l_vale.append(vale) elif cata_lois[cle]['POSI_PARA'][ipar] == 0: l_para.append(para_epx) l_vale.append(vale) else: l_para1.append(para_epx) l_vale1.append(vale) else: bes_para = cata_lois[cle]['BESOIN'][ipar] if bes_para == 'o': UTMESS('F', 'PLEXUS_31', valk=(para, loi, nom_mater)) # vérifcation que l'on utilise pas de mot-clé non pris en charge for para in donnees.keys(): if para not in cata_lois[cle]['PARA']: UTMESS('A', 'PLEXUS_46', valk=(para, loi, nom_mater)) return l_para, l_vale, l_para1, l_vale1, liste_fonc
def check_amor(amor_ref, amor): """ Vérification que les deux listes d'amortissement sont identiques """ if len(amor_ref) != len(amor): UTMESS('F', 'SPECTRAL0_18') for i in range(len(amor_ref)): if amor_ref[i] != amor[i]: UTMESS('F', 'SPECTRAL0_18')
def _run(self): """INTERPOL_FFT""" import copy kw = self.kw t0 = self._lf[0].vale_x[0] dt_init = self._lf[0].vale_x[1] - t0 N_init = len(self._lf[0].vale_x) dt_cible = kw['PAS_INST'] if dt_init < dt_cible: UTMESS('F', 'FONCT0_35') # nombre d'intervalles N_init -= 1 N_sortie = int((N_init) * dt_init / dt_cible) if N_init * dt_init / dt_cible - N_sortie >= 0.5: N_sortie += 1 # retour au nombre de valeurs N_sortie += 1 # FFT ft = self._lf[0].fft('COMPLET') # suppression de la partie symetrique du signal N = len(ft.vale_x) valex = list(ft.vale_x[:N / 2 + 1]) valey = list(ft.vale_y[:N / 2 + 1]) # zero padding dfreq = (valex[1] - valex[0]).real last_freq = valex[-1] N_pad = N_sortie / 2 + 1 - N / 2 - 1 for i in range(N_pad): freq = last_freq + (i + 1) * dfreq valex.append(freq) valey.append(0.) ft.vale_x = NP.array(valex) ft.vale_y = NP.array(valey) # IFFT self.resu = ft.fft('COMPLET', 'NON') self.resu.vale_x = self.resu.vale_x + t0 # dt fin reel dt_fin = self.resu.vale_x[1] - self.resu.vale_x[0] # normalisation coef_norm = dt_init / dt_fin self.resu.vale_y = self.resu.vale_y * coef_norm ecart = abs(dt_fin - kw['PAS_INST']) / kw['PAS_INST'] if ecart > kw['PRECISION']: UTMESS('A', 'FONCT0_51', valr=[dt_fin, kw['PAS_INST'], 100 * ecart])
def __init__(self, gr_max=10, options=None, xmgrace=os.path.join(aster_core.get_option('repout'), 'xmgrace')): # Declaration global TERMINAL # Precondition if TERMINAL: raise Xmgr.DEJA_ACTIF # Initialisation TERMINAL = 1 self.gr_max = gr_max # nombre de graphes self.gr_act = 0 # numero du graphe actif self.sets = [0] * gr_max # nombre de sets par graphe self.nom_pipe = 'xmgr.pipe' # nom du pipe de communication self.xmgrace = xmgrace # Ouverture du pipe de communication avec xmgrace if os.path.exists(self.nom_pipe): os.remove(self.nom_pipe) os.mkfifo(self.nom_pipe) self.pipe = open(self.nom_pipe, 'a+') # Lancement de xmgrace if options != None: cmd = self.xmgrace + ' -noask ' + options + \ ' -graph ' + repr(gr_max - 1) + ' -npipe ' + self.nom_pipe else: cmd = self.xmgrace + ' -noask ' + \ ' -graph ' + repr(gr_max - 1) + ' -npipe ' + self.nom_pipe # Teste le DISPLAY avant de lancer xmgrace... if os.environ.has_key('DISPLAY'): UTMESS('I', 'STANLEY_9', valk=[cmd]) self.controle = Popen(cmd, shell=True) # Mise a l'echelle des graphes for i in xrange(gr_max): gr = 'G' + repr(i) self.Send('WITH ' + gr) self.Send('VIEW XMIN 0.10') self.Send('VIEW XMAX 0.95') self.Send('VIEW YMIN 0.10') self.Send('VIEW YMAX 0.95') # Activation du graphe G0 self.Active(0) else: TERMINAL = 0 UTMESS('A', 'STANLEY_3', valk=['XMGRACE'])
def verif_reuse(OPERATION, obj_reuse): # verification que reuse est correctement employe if OPERATION in ('ABSC_CURV_NORM', 'ANGLE_BIFURCATION', 'LOI_PROPA', 'K1_NEGATIF'): if not obj_reuse: UTMESS('F', 'RUPTURE1_62', valk=(OPERATION)) if OPERATION in ('COMPTAGE_CYCLES', 'CUMUL_CYCLES', 'PILO_PROPA'): if obj_reuse: UTMESS('F', 'RUPTURE1_63', valk=(OPERATION))
def recu_coor_z(noma, group, typ_group, tole_r): import aster from Utilitai.Utmess import UTMESS collcnx = aster.getcolljev(noma.nom.ljust(8) + '.CONNEX') coord = aster.getvectjev(noma.nom.ljust(8) + '.COORDO .VALE') cnom = aster.getvectjev(noma.nom.ljust(8) + '.NOMNOE') coor_z = [] if typ_group == 'group_ma': nomgrma = group collgrma = aster.getcolljev(noma.nom.ljust(8) + '.GROUPEMA') if nomgrma.ljust(24) not in collgrma: UTMESS("F", "MISS0_26", valk=group) else: numa = collgrma[nomgrma.ljust(24)] for ima in numa: n = collcnx[ima][0] uzmin = round(coord[3 * (n - 1) + 2], tole_r) uzmax = round(coord[3 * (n - 1) + 2], tole_r) for i in range(len(collcnx[ima])): n = collcnx[ima][i] uzmin = min(uzmin, round(coord[3 * (n - 1) + 2], tole_r)) uzmax = max(uzmax, round(coord[3 * (n - 1) + 2], tole_r)) if uzmin not in coor_z: coor_z.append(uzmin) if uzmax not in coor_z: coor_z.append(uzmax) elif typ_group == 'group_no': collgrno = aster.getcolljev(noma.nom.ljust(8) + '.GROUPENO') nomgrno = group if nomgrno.ljust(24) not in collgrno: UTMESS("F", "MISS0_26", valk=group) else: grpn = collgrno[nomgrno.ljust(24)] l_coor_group = [] i = 0 for node in grpn: l_coor_group.append( aster.getvectjev( noma.nom.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3)) uz = round(l_coor_group[i][2], tole_r) i += 1 if uz not in coor_z: coor_z.append(uz) else: assert 0, 'recu_coor_z : erreur argument typ_group' prov = sorted(coor_z) coor_z = prov[::-1] return coor_z
def _build_data(self): """Read keywords to build the data""" CalcFonctionOper._build_list_fonc(self) kw = self.kw self._dat = {} # amor if kw['AMOR_REDUIT'] is None: l_amor = [0.02, 0.05, 0.1] UTMESS('I', 'FONCT0_31', valr=l_amor) else: l_amor = force_list(kw['AMOR_REDUIT']) eps = 1.e-6 for amor in l_amor: if amor > (1 - eps): UTMESS('S', 'FONCT0_36') self._dat['AMOR'] = l_amor # freq if kw['LIST_FREQ'] is not None: l_freq = kw['LIST_FREQ'].Valeurs() elif kw['FREQ'] is not None: l_freq = force_list(kw['FREQ']) else: l_freq = [] for i in range(56): l_freq.append(0.2 + 0.050 * i) for i in range(8): l_freq.append(3.0 + 0.075 * i) for i in range(14): l_freq.append(3.6 + 0.100 * i) for i in range(24): l_freq.append(5.0 + 0.125 * i) for i in range(28): l_freq.append(8.0 + 0.250 * i) for i in range(6): l_freq.append(15.0 + 0.500 * i) for i in range(4): l_freq.append(18.0 + 1.0 * i) for i in range(10): l_freq.append(22.0 + 1.500 * i) texte = [] for i in range(len(l_freq) / 5): texte.append(' %f %f %f %f %f' % tuple(l_freq[i * 5:i * 5 + 5])) UTMESS('I', 'FONCT0_32', vali=len(l_freq), valk=os.linesep.join(texte)) if min(l_freq) < 1.E-10: UTMESS('F', 'FONCT0_43') self._dat['FREQ'] = l_freq # check if abs(kw['NORME']) < 1.E-10: UTMESS('S', 'FONCT0_33') if kw['NATURE_FONC'] == 'DSP': ASSERT(kw['METHODE'] == 'RICE')
def IniGrace(fich): """Retourne le numéro de la dernière courbe d'un fichier xmgrace (sinon 0). """ ns = 0 x0 = None x1 = None y0 = None y1 = None if os.path.exists(fich) and os.stat(fich).st_size <> 0: os.rename(fich, fich + '.prev') fpre = open(fich + '.prev', 'r') fnew = open(fich, 'w') for line in fpre: ikeep = True mat = re.search('@target g[0-9]+\.s([0-9]+)', line) if mat <> None and int(mat.group(1)) > ns: ns = int(mat.group(1)) mat = re.search('@[ ]+world[ ]+xmin[ ]+([\-\+\.0-9eEdD]+)', line) if mat <> None: try: x0 = float(mat.group(1)) ikeep = False except ValueError: pass mat = re.search('@[ ]+world[ ]+xmax[ ]+([\-\+\.0-9eEdD]+)', line) if mat <> None: try: x1 = float(mat.group(1)) ikeep = False except ValueError: pass mat = re.search('@[ ]+world[ ]+ymin[ ]+([\-\+\.0-9eEdD]+)', line) if mat <> None: try: y0 = float(mat.group(1)) ikeep = False except ValueError: pass mat = re.search('@[ ]+world[ ]+ymax[ ]+([\-\+\.0-9eEdD]+)', line) if mat <> None: try: y1 = float(mat.group(1)) ikeep = False except ValueError: pass if ikeep: fnew.write(line) fpre.close() fnew.close() if None not in (x0, x1, y0, y1): UTMESS('I', 'GRAPH0_10', valk=fich, vali=ns, valr=(x0, x1, y0, y1)) else: UTMESS('A', 'GRAPH0_11', valk=fich) return ns, x0, x1, y0, y1
def _exec_boucle_lapl(self): """Exécute MISS3D dans une boucle sur toutes les fréquences complexes""" L_points = self.L_points dt = self.dt rho = self.rho reduc_factor = self.reducFactor # TODO la règle UN_PARMI(FREQ_MIN, LIST_FREQ, FREQ_IMAG) ne convient pas! # au moins mettre FREQ_MIN à None self.param.set('FREQ_MIN', None) if self.cutOffValue == 1: fc = self.cutOffValue * self.nbr_freq / float(reduc_factor) else: fc = NP.int_( NP.ceil(self.cutOffValue * self.nbr_freq / float(reduc_factor))) freq_list1 = NP.arange(0, fc * reduc_factor) freq_list2 = NP.arange(fc * reduc_factor, self.nbr_freq, reduc_factor) self.freq_list = freq_list1.tolist() + freq_list2.tolist() rank, size = aster_core.MPI_CommRankSize() for k in self.freq_list: # round-robin partition if k % size != rank: UTMESS('I', 'MISS0_24', vali=(k, k % size)) continue UTMESS('I', 'MISS0_25', vali=(k, rank)) if (k == 0) or (k == self.nbr_freq - 1): self.param.set('LIST_FREQ', (0.1E-4,)) self.param.set( 'FREQ_IMAG', (1.5 - 2.0 * rho * cos(2 * pi * k / L_points) + 0.5 * rho * rho * cos(4 * pi * k / L_points)) / dt) else: self.param.set( 'LIST_FREQ', (-(-2.0 * rho * sin(2 * pi * k / L_points) + 0.5 * rho * rho * sin(4 * pi * k / L_points)) / dt / (2 * pi),)) self.param.set( 'FREQ_IMAG', (1.5 - 2.0 * rho * cos(2 * pi * k / L_points) + 0.5 * rho * rho * cos(4 * pi * k / L_points)) / dt) self.param.set('_calc_impe', True) CalculMiss.cree_commande_miss(self) str00 = str(self.param['FREQ_IMAG']) + ' + i . ' + str( self.param['LIST_FREQ'][0]) + ' (' + str(k + 1) + '/' + str(self.nbr_freq) + ')' aster.affiche("MESSAGE", 'FREQUENCE COMPLEXE COURANTE = ' + str00) CalculMiss.execute(self) resname = self._fichier_tmp('resu_impe_%04d' % k) copie_fichier(self._fichier_tmp("resu_impe"), resname) if rank != 0: UTMESS('I', 'PARALLEL_2', valk=( resname, self._results_path[0])) send_file(resname, self._results_path[0]) # libérer la structure contenant les données numériques CalculMiss.init_data(self) aster_core.MPI_Barrier()
def AfficheTexteCommande(self, sortie=sys.stdout): """ Methode : ETAPE.AfficheTexteCommande Intention : afficher sur la sortie standard (par defaut) le cartouche de la commande avant son execution. """ from Utilitai.Utmess import UTMESS voir = not isinstance(self.parent, MACRO_ETAPE) or \ self.jdc.impr_macro == 1 or self.parent.show_children # top départ du chrono de la commande etiq = self.nom # id unique pour l'étape. L'attribut n'est pas déclaré dans # l'__init__... count = (self.icmd or 0) self.id_timer = str(time.time() + count) if isinstance(self.parent, MACRO_ETAPE): etiq = ' . ' + etiq if voir: self.jdc.timer.Start(self.id_timer, name=etiq) # impression du fichier .code : compte rendu des commandes et # mots clés activés par l'ETAPE if self.jdc.fico != None: fcode = CodeVisitor(self.jdc.fico) self.accept(fcode) aster.affiche('CODE', fcode.get_text()) if voir: # Affichage numero de la commande (4 digits) if self.sd != None: type_concept = self.sd.__class__.__name__ else: type_concept = '-' UTMESS('I', 'VIDE_1') UTMESS('I', 'SUPERVIS2_70') if self.icmd != None: UTMESS('I', 'SUPERVIS2_71', vali=self.icmd, valk=type_concept) UTMESS('I', 'SUPERVIS2_70') else: # commande non comptabilisée (INCLUDE) UTMESS('I', 'SUPERVIS2_72', valk=type_concept) # recuperation du texte de la commande courante if self.jdc.ctree: self.accept(self.jdc.ctree) cmdtext = CommandTextVisitor() self.accept(cmdtext) aster.affiche('MESSAGE', convert(cmdtext.get_text())) return
def commun_DEBUT_POURSUITE(jdc, PAR_LOT, IMPR_MACRO, CODE, DEBUG, IGNORE_ALARM, LANG, INFO): """Fonction sdprod partie commune à DEBUT et POURSUITE. (on stocke un entier au lieu du logique) """ global ipass ipass += 1 # deux passages: build et exec if ipass > 2 and aster_exists: UTMESS('F', 'SUPERVIS_2') jdc.set_par_lot(PAR_LOT, user_value=True) jdc.impr_macro = int(IMPR_MACRO == 'OUI') jdc.jxveri = int(CODE != None or (DEBUG != None and DEBUG['JXVERI'] == 'OUI')) jdc.sdveri = int(DEBUG != None and DEBUG['SDVERI'] == 'OUI') jdc.fico = None jdc.sd_checker = CheckLog() jdc.info_level = INFO jdc.hist_etape = (DEBUG != None and DEBUG['HIST_ETAPE'] == 'OUI') if CODE != None: jdc.fico = 'TEST' if aster_exists: if LANG: from code_aster.Cata.Syntax import tr from Execution.i18n import localization translation = localization.install(LANG) tr.set_translator(translation.ugettext) # pb en cas d'erreur dans FIN : appeler reset_print_function dans traiter_fin_exec ? # from functools import partial # asprint = partial(aster.affiche, 'MESSAGE') # message.register_print_function(asprint) # ne faire qu'une fois if not hasattr(jdc, 'msg_init'): # messages d'alarmes désactivés if IGNORE_ALARM: if not type(IGNORE_ALARM) in (list, tuple): IGNORE_ALARM = [IGNORE_ALARM] for idmess in IGNORE_ALARM: MessageLog.disable_alarm(idmess) # en POURSUITE, conserver le catalogue de comportement picklé if not hasattr(jdc, 'catalc'): from Comportement import catalc jdc.catalc = catalc # ne faire qu'une fois if not hasattr(jdc, 'msg_init') and jdc.syntax_check(): if jdc.par_lot == 'NON': UTMESS('A', 'SUPERVIS_11') raise EOFError("can not check syntax with PAR_LOT='NON'.") else: UTMESS('I', 'SUPERVIS_10') jdc.msg_init = True
def _print_alarm(): """Emet une alarme en cas de modification de la version du dépôt""" from Utilitai.Utmess import UTMESS changes = aster_pkginfo.version_info.changes uncommitted = aster_pkginfo.version_info.uncommitted if changes: UTMESS('I', 'SUPERVIS_41', valk=__version__, vali=changes) if uncommitted and type(uncommitted) is list: fnames = ', '.join(uncommitted) UTMESS( 'A', 'SUPERVIS_42', valk=(aster_pkginfo.version_info.parentid, fnames), )
def calcul_F(self, val): """ Calcul de F """ UTMESS('I', 'RECAL0_25', valk=self.Affiche_Param(val)) # Reset les variables deja calculees par les calculs precedents self.reset() # Calcul pour le jeu de parametre val fonctionnelle, gradient = self.calcul_Aster(val, dX=None) # Calcul de l'erreur par rapport aux donnees experimentale E = CALC_ERROR( experience=self.RESU_EXP, X0=val, calcul=self.RESU_CALC, poids=self.Simul.poids, objective_type='vector', info=self.INFO, ) self.erreur = E.CalcError(self.Lcalc) # norme de l'erreur self.norme = NP.sum([x ** 2 for x in self.erreur]) if debug: print "self.reponses=", self.reponses print "F=", E.F print "L_J=", E.L_J print "L_J_init=", E.L_J_init print "J=", E.J print 'erreur=', self.erreur print "norme de l'erreur=", self.norme print "norme de J (fonctionnelle)=", str(E.J) if self.INFO >= 2: UTMESS('I', 'RECAL0_30') if self.evaluation_fonction > 1: UTMESS('I', 'RECAL0_39', valk=str(self.evaluation_fonction)) if self.vector_output: if self.INFO >= 2: UTMESS('I', 'RECAL0_35', valr=self.norme) return self.erreur else: if self.INFO >= 2: UTMESS('I', 'RECAL0_36', valr=self.norme) return self.norme
def __salomeParam(self, param): """ Construit les paramètres salome à partir des paramètres Stanley retourne {} si incorrect """ result = {} try: if param['mode'] == 'LOCAL': lst = ['tmp'] try: amachineName = param['machine_salome'] except: UTMESS('A', 'STANLEY_15') return {} result['machineName'] = amachineName elif param['mode'] == 'DISTANT': lst = ['machine_salome', 'tmp'] key = 'machine_salome' amachineName = param[key] result['machineName'] = amachineName else: raise _( "Erreur MODE non implémenté, choix possible : LOCAL, DISTANT") # Verifications for var in lst: if not param[var].strip(): UTMESS('A', 'STANLEY_16', valk=[var]) return {} # Construction du paramètre 'ORBInitRef' key = 'machine_salome_port' nsPort = param[key] if not nsPort: UTMESS('A', 'STANLEY_17') return {} aORBInitRef = 'NameService=corbaname::%s:%s' % ( amachineName, nsPort) result['ORBInitRef'] = aORBInitRef except KeyError: UTMESS('A', 'STANLEY_16', valk=[key]) return {} except: return {} return result
def affiche_calcul_etat_final(self, para, Hessien, valeurs_propres, vecteurs_propres, sensible, insensible): """ Affichage des informations de l'optimisation (valeurs propres, vecteurs propres, etc.) """ UTMESS('I', 'RECAL0_60', valk=str(valeurs_propres), files=self.get_filename()) UTMESS('I', 'RECAL0_61', valk=str(vecteurs_propres), files=self.get_filename()) UTMESS('I', 'RECAL0_62', files=self.get_filename()) if (len(sensible) != 0 or len(insensible) != 0): UTMESS('I', 'RECAL0_63', files=self.get_filename()) # Parametres sensibles if (len(sensible) != 0): UTMESS('I', 'RECAL0_64', files=self.get_filename()) k = 0 for i in sensible: k = k + 1 colonne = vecteurs_propres[:, i] numero = NP.nonzero( NP.greater(abs(colonne / max(abs(colonne))), 1.E-1))[0] txt = '\n ' + str(k) + ') ' for j in numero: txt += '%+3.1E ' % colonne[j] + '* ' + para[j] + ' ' UTMESS('I', 'RECAL0_65', valk=(txt, str(valeurs_propres[i])), files=self.get_filename()) # Parametres insensibles if (len(insensible) != 0): UTMESS('I', 'RECAL0_66', files=self.get_filename()) k = 0 for i in insensible: k = k + 1 colonne = vecteurs_propres[:, i] numero = NP.nonzero( NP.greater(abs(colonne / max(abs(colonne))), 1.E-1))[0] txt = '\n ' + str(k) + ') ' for j in numero: txt += '%+3.1E ' % colonne[j] + '* ' + para[j] + ' ' UTMESS('I', 'RECAL0_65', valk=(txt, str(valeurs_propres[i])), files=self.get_filename()) if (len(sensible) != 0 or len(insensible) != 0): UTMESS('I', 'RECAL0_62', files=self.get_filename())
def __Show(self, medFilePath, medInfo, entity, visuType, salomeParam): """ Lecture d'un fichier MED par le composant VISU de SALOME. @type medFilePath : string @param medFilePath: chemin du fichier MED. Le chemin medFileName doit etre sur la meme machine que le composant VISU @type medInfo: class @param medInfo: informations sur le fichier MED ( meshName, fieldName, iteration ) @type entity: object ? @param entity: type d'entité @type visuType : integer @param visuType: type de visualisation @type salomeParam: dictionary. @param salomeParam: parametre Salome pour initialistion composant VISU de pylotage """ try: salomeVisu = Visu.Visu(**salomeParam) except Exception, e: UTMESS('A', 'STANLEY_19', valk=[salomeParam['machineName']]) raise _("Erreur lors de la visualisation.\n\nParametres Salome :%s\n\nErreur :\n%s\n\n") % ( salomeParam, e)
def __init_distant(self): """ Stanley fonctionne sur une machine distante de l'utilisateur. Il faut rapatrier le fichier sur la machine contenant salome. """ result = False fichier = os.path.basename(self.fichier) mdis = self.param['machine_salome'] # machine fdis = self.param['tmp'] + '/' + fichier + \ '.pos' # /tmp/fort.33.pos fmdis = self.param['machine_salome_login'] + \ '@' + mdis + ":" + fdis # user@machine:/tmp/fort.33.pos # Protocole de recopie et d'execution distante copie = self.param['protocole'].split( '/')[0] # rcp ou scp # Copie du fichier cmd = copie + " " + fichier + " " + fmdis UTMESS('I', 'STANLEY_9', valk=[cmd]) code, output = commands.getstatusoutput(cmd) if code != 0: raise _("Erreur exécution commande : ") + cmd self.fichier = fdis
def Valeurs(self): """ Retourne deux listes de valeurs : abscisses et ordonnees """ from Utilitai.Utmess import UTMESS if self.accessible(): vale = '%-19s.VALE' % self.get_name() lbl = self.sdj.VALE.get() if lbl == None: UTMESS('F', 'SDVERI_2', valk=[vale]) lbl = list(lbl) dim = len(lbl) / 2 lx = lbl[0:dim] ly = lbl[dim:2 * dim] elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION': if self.etape['VALE'] is not None: lbl = list(self.etape['VALE']) dim = len(lbl) lx = [lbl[i] for i in range(0, dim, 2)] ly = [lbl[i] for i in range(1, dim, 2)] elif self.etape['VALE_PARA'] is not None: lx = self.etape['VALE_PARA'].Valeurs() ly = self.etape['VALE_FONC'].Valeurs() elif self.etape['ABSCISSE'] is not None: lx = self.etape['ABSCISSE'] ly = self.etape['ORDONNEE'] else: raise AsException("Erreur (fonction.Valeurs) : ne fonctionne en " "PAR_LOT='OUI' que sur des fonctions produites " "par DEFI_FONCTION dans le jdc courant.") else: raise AsException("Erreur (fonction.Valeurs) : ne fonctionne en " "PAR_LOT='OUI' que sur des fonctions produites " "par DEFI_FONCTION dans le jdc courant.") return [lx, ly]
def Parametres(self): """ Retourne un dictionnaire contenant les parametres de la nappe, le type jeveux (NAPPE) n'est pas retourne, le dictionnaire peut ainsi etre fourni a CALC_FONC_INTERP tel quel, et une liste de dictionnaire des parametres de chaque fonction. """ from Utilitai.Utmess import UTMESS if not self.accessible(): raise AsException( "Erreur dans nappe.Parametres en PAR_LOT='OUI'") TypeProl = {'E': 'EXCLU', 'L': 'LINEAIRE', 'C': 'CONSTANT'} objev = '%-19s.PROL' % self.get_name() prol = aster.getvectjev(objev) if prol == None: UTMESS('F', 'SDVERI_2', valk=[objev]) dico = { 'INTERPOL': [prol[1][0:3], prol[1][4:7]], 'NOM_PARA': prol[2][0:16].strip(), 'NOM_RESU': prol[3][0:16].strip(), 'PROL_DROITE': TypeProl[prol[4][1]], 'PROL_GAUCHE': TypeProl[prol[4][0]], 'NOM_PARA_FONC': prol[6][0:4].strip(), } lparf = [] nbf = (len(prol) - 7) / 2 for i in range(nbf): dicf = { 'INTERPOL_FONC': [prol[7 + i * 2][0:3], prol[7 + i * 2][4:7]], 'PROL_DROITE_FONC': TypeProl[prol[8 + i * 2][1]], 'PROL_GAUCHE_FONC': TypeProl[prol[8 + i * 2][0]], } lparf.append(dicf) return [dico, lparf]
def Valeurs(self): """ Retourne trois listes de valeurs : abscisses, parties reelles et imaginaires. """ from Utilitai.Utmess import UTMESS if self.accessible(): vale = '%-19s.VALE' % self.get_name() lbl = self.sdj.VALE.get() if lbl == None: UTMESS('F', 'SDVERI_2', valk=[vale]) lbl = list(lbl) dim = len(lbl) / 3 lx = lbl[0:dim] lr = [] li = [] for i in range(dim): lr.append(lbl[dim + 2 * i]) li.append(lbl[dim + 2 * i + 1]) elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION' \ and self.etape['VALE_C'] is not None: lbl = list(self.etape['VALE_C']) dim = len(lbl) lx = [lbl[i] for i in range(0, dim, 3)] lr = [lbl[i] for i in range(1, dim, 3)] li = [lbl[i] for i in range(2, dim, 3)] else: raise AsException("Erreur (fonction_c.Valeurs) : ne fonctionne en " "PAR_LOT='OUI' que sur des fonctions produites " "par DEFI_FONCTION dans le jdc courant.") return [lx, lr, li]
def Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess): """ Sortie de la macro, on renvoie les parametres obtenus """ import aster import Macro from code_aster.Cata.Commands import DEFI_LIST_REEL from code_aster.Cata.Syntax import _F from Macro import reca_message from Macro import reca_algo from Macro import reca_interp from Macro import reca_utilitaires from Macro import reca_calcul_aster from Macro.reca_controles import gestion from Utilitai.Utmess import UTMESS, MessageLog UTMESS('I', 'RECAL0_39', valk=str(CALCUL_ASTER.evaluation_fonction), files=Mess.get_filename()) LIST_NOM_PARA_ALPHA = [para[0] for para in LIST_PARA] LIST_NOM_PARA_ALPHA.sort() lival = [] for i in LIST_NOM_PARA: lival.append(val[LIST_NOM_PARA_ALPHA.index(i)]) nomres = DEFI_LIST_REEL(VALE=lival) return nomres
def orientation_cara_elem(self, ): """ Récupération des orientations des poutres """ dic_gma = {} etapes = self.CARA_ELEM.etape.valeur if not etapes.has_key('ORIENTATION'): return dic_gma orientation = tolist(etapes['ORIENTATION']) for ll in orientation: cara = ll['CARA'] if cara in ['ANGL_VRIL', 'ANGL_NAUT', 'VECT_Y']: if ll.has_key('GROUP_MA'): group_ma = tolist(ll['GROUP_MA']) a = ll['VALE'] for gr in group_ma: if not dic_gma.has_key(gr): dic_gma[gr] = {} dic_gma[gr][cara] = a for gr in dic_gma.keys(): if not dic_gma[gr].has_key('VECT_Y'): if not dic_gma[gr].has_key('ANGL_VRIL'): dic_gma[gr]['ANGL_VRIL'] = 0.0 if dic_gma[gr].has_key('ANGL_NAUT'): UTMESS('F', 'PLEXUS_10') return dic_gma
def Calc_erreur(champ, contexte, numeros, phenomene, options=None): para = { 'reuse': contexte.resultat, 'RESULTAT': contexte.resultat, 'MODELE': contexte.modele, #'OPTION' : champ.nom, 'CHAM_MATER': contexte.cham_mater, 'NUME_ORDRE': tuple(numeros), phenomene: champ.nom } if contexte.cara_elem: para['CARA_ELEM'] = contexte.cara_elem # Options supplementaires passees a la commande if options: for cle in options.keys(): para[cle] = options[cle] # Lancement de la commande try: CALC_ERREUR(**para) except aster.error, err: UTMESS('A', 'STANLEY_4', valk=[str(err)])
def vmis_isot_trac(donnees, para, para_epx, type_para, l_para, l_vale): """ Transforme la fonction associée au paramètre SIGM de TRACTION afin d'obtenir les données attendues par EPX pour les mots-clés ELAS et TRAC du matériau VMIS ISOT. """ # ajout des mots-clés l_para.extend(para_epx) # recuperation de la fonction associé à SIGM car_temp = donnees[para] val = car_temp.Valeurs() eps = val[0] sigm = val[1] # verif de la compatibilité de eps[0] et sigm[0] avec E if l_para[0][:4] != 'YOUN': raise Exception('Erreur de programmation') E = l_vale[0] diff = abs(sigm[0] / E - eps[0]) if diff > 0.001 * eps[0]: nom_fonc = car_temp.get_name() UTMESS('F', 'PLEXUS_40', valk=[ nom_fonc, para], valr=[sigm[0] / E, eps[0]]) # ajout de la valeur de ELAS (limite élastique) l_vale.append(sigm[0]) # préparation des valeurs de trac nb = len(eps) trac = [nb, ] for i in range(nb): trac.extend([sigm[i], eps[i]]) l_vale.append(trac) return l_para, l_vale
def executeCommand(self, capture=True, silent=False): """Execute the program""" cmd = self.cmdBuilder.build([self.prog] + self.args, self.shell) output, error, exitCode = self.executeCmdLine(cmd, capture, silent) ok = self.isOk(exitCode) # print the output if self.debug or not silent: UTMESS('I', 'EXECLOGICIEL0_11', vali=[self.exitCodeMax, exitCode]) if capture: UTMESS('I', 'EXECLOGICIEL0_9', valk=output) # print error in debug mode or if it failed if (self.debug or not ok) and capture: UTMESS('I', 'EXECLOGICIEL0_10', valk=error, print_as='E') # error if not ok: UTMESS('F', 'EXECLOGICIEL0_3', vali=[self.exitCodeMax, exitCode])