def copie_fichier(src, dst):
"""Copie d'un fichier.
"""
if src and dst:
try:
shutil.copyfile(src, dst)
except:
raise aster.error('MISS0_6', valk=(src, dst))
def get_max_dabsc(fonction):
"""Retourne le maximum et le pas des abscisses de la fonction."""
tfunc = fonction.convert()
dx = tfunc.vale_x[1:] - tfunc.vale_x[:-1]
dxmax = max(dx)
dxmin = min(dx)
if abs((dxmax - dxmin) / dxmax) > 1.e-3:
raise aster.error('MISS0_9', valk=fonction.nom)
return max(tfunc.vale_x), dxmax
def execute(self):
"""Exécute MISS3D.
"""
self._dbg_trace("Start")
copie_fichier(self._fichier_tmp("in"),
osp.join(self.param['_WRKDIR'], "MISS.IN"))
cmd = osp.join(aster_core.get_option('repout'), "run_miss3d") + \
" " + self.param['VERSION']
iret = 4
try:
os.chdir(self.param['_WRKDIR'])
if self.verbose:
_print("Exécution de MISS3D dans :", self.param['_WRKDIR'])
os.system('ls -la')
comment = "Lancement de la commande :\n%s" % cmd
if self.verbose:
aster.affiche("MESSAGE", comment)
iret, output, error = ExecCommand(cmd, alt_comment=comment,
verbose=False, separated_stderr=True)
if self.verbose:
_print("Contenu du répertoire après l'exécution de MISS3D :")
os.system('ls -la')
finally:
os.chdir(self.param['_INIDIR'])
UTMESS('I', 'EXECLOGICIEL0_9', valk=output)
miss_out = ""
if osp.exists(self._fichier_tmp("OUT")):
miss_out = open(self._fichier_tmp("OUT"), "r").read()
is_ok = iret == 0 and \
(miss_out.find("INSUFFISAN") < 0 and miss_out.find("*** STOP") < 0)
if not is_ok or self.verbose:
aster.affiche("MESSAGE", miss_out)
if not is_ok:
UTMESS('I', 'EXECLOGICIEL0_10', valk=error, print_as='E')
raise aster.error('EXECLOGICIEL0_3', vali=[0, iret])
self._dbg_trace("Stop")
def check(self):
"""Vérification des règles impossible à écrire dans le .capy"""
# tâches à la demande
if self['TYPE_RESU'] in ('HARM_GENE', 'TRAN_GENE', 'TABLE', 'CHARGE'):
self.set('_calc_impe', True)
self.set('_calc_forc', True)
elif self['TYPE_RESU'] in ('FICHIER', 'TABLE_CONTROL'):
if self.get('UNITE_RESU_IMPE') is not None:
self.set('_calc_impe', True)
if self.get('UNITE_RESU_FORC') is not None:
self.set('_calc_forc', True)
else:
if self['EXCIT_SOL'] is not None:
self.set('_calc_forc', True)
self.set('_hasPC', self.get('GROUP_MA_CONTROL') is not None)
# unités logiques
if self.get('UNITE_RESU_IMPE') is None:
self.set('_exec_Miss', True)
self['UNITE_RESU_IMPE'] = self.UL.Libre(action='ASSOCIER')
if self.get('UNITE_RESU_FORC') is None:
self.set('_exec_Miss', True)
self['UNITE_RESU_FORC'] = self.UL.Libre(action='ASSOCIER')
# fréquences
if self['TYPE_RESU'] not in ('CHARGE'):
if self['LIST_FREQ'] is not None \
and self['TYPE_RESU'] not in ('FICHIER', 'HARM_GENE', 'TABLE_CONTROL'):
raise aster.error('MISS0_17')
# si base modale, vérifier/compléter les amortissements réduits
if self['TYPE_RESU'] not in ('CHARGE'):
if self['BASE_MODALE']:
res = aster.dismoi('NB_MODES_DYN', self['BASE_MODALE'].nom,
'RESULTAT', 'C')
ASSERT(res[0] == 0)
self['_NBM_DYN'] = res[1]
res = aster.dismoi('NB_MODES_STA', self['BASE_MODALE'].nom,
'RESULTAT', 'C')
ASSERT(res[0] == 0)
self['_NBM_STAT'] = res[1]
if self['AMOR_REDUIT']:
self.set('AMOR_REDUIT', force_list(self['AMOR_REDUIT']))
nval = len(self['AMOR_REDUIT'])
if nval < self['_NBM_DYN']:
# complète avec le dernier
nadd = self['_NBM_DYN'] - nval
self._keywords['AMOR_REDUIT'].extend([
self['AMOR_REDUIT'][-1],
] * nadd)
nval = self['_NBM_DYN']
if nval < self['_NBM_DYN'] + self['_NBM_STAT']:
# on ajoute 0.
self._keywords['AMOR_REDUIT'].append(0.)
# la règle ENSEMBLE garantit que les 3 GROUP_MA_xxx sont tous absents
# ou tous présents
if self['TYPE_RESU'] not in ('CHARGE'):
if self['ISSF'] != 'NON':
if self['GROUP_MA_FLU_STR'] is None:
UTMESS('F', 'MISS0_22')
if self['MATER_FLUIDE'] is None:
UTMESS('F', 'MISS0_23')
def fichier_sol(tab, struct, param=None):
"""Retourne le contenu du fichier de sol construit à partir de
la table des données de sol et éventuellement des paramètres du calcul.
"""
# vérification de la table
for p in ("NUME_COUCHE", "NUME_MATE", "E", "NU", "RHO", "EPAIS",
"AMOR_HYST", "RECEPTEUR", "SUBSTRATUM"):
if not p in tab.para:
raise aster.error('TABLE0_2', valk=(p, 'de sol'))
nb_couche = len(tab)
if max(tab.NUME_COUCHE.values()) != nb_couche:
raise aster.error('MISS0_5')
tsubstr = (tab.SUBSTRATUM == "OUI")
if len(tsubstr) != 1:
raise aster.error('MISS0_3')
# complète la table
tsol = tab.copy()
# ... niveau récepteur
def f_recep(v):
res = ""
if v.strip() == "OUI":
res = "RECEP"
return res
tsol.fromfunction("s_RECEP", f_recep, "RECEPTEUR")
# ... niveau source
def f_force(num, v):
res = 0
if v.strip() == "OUI":
res = num
return res
tsol.fromfunction("s_FORCE", f_force, ("NUME_COUCHE", "SOURCE"))
# ... êta
tsol.fromfunction("ETA", lambda x: 0., "NUME_COUCHE")
content = []
# titre de la table
content.append("TITRE")
content.append(tsol.titr)
# materiaux
tsol.sort(CLES=[
"NUME_MATE",
])
nb_mate = max(tsol.NUME_MATE.values())
content.append("MATERIAU %8d" % nb_mate)
content.append("RO E NU BETA ETA")
format = "%%(RHO)%(R)s %%(E)%(R)s %%(NU)%(R)s %%(AMOR_HYST)%(R)s %%(ETA)%(R)s" \
% dict_format
last_id_mate = 0
for row in tsol:
if row['NUME_MATE'] == last_id_mate: # déjà vu, on saute
continue
last_id_mate = row['NUME_MATE']
content.append(format % row)
# couches
tsol.sort(CLES=[
"NUME_COUCHE",
])
content.append("COUCHE %8d" % (nb_couche - 1))
format = "%%(EPAIS)%(R)s MATE %%(NUME_MATE)8d %%(s_RECEP)s" % dict_format
for ic, row in enumerate(tsol):
if ic == nb_couche - 1:
continue
content.append(format % row)
# substratum
substr = tsubstr.rows[0]
content.append("SUBS MATE %8d" % substr['NUME_MATE'])
# sources
nb_source = len(tsol.SOURCE == "OUI")
content.append("SOURCE %8d 3D" % nb_source)
# forces
format = "FORCE HORIZ POSI %(s_FORCE)8d"
if param and param.get('TYPE_RESU') == 'FICHIER_TEMPS' \
and param.get('FICHIER_SOL_INCI') is None:
# champ incident au substratum
content.append("FORCE PLANE POSI %8d" % nb_couche)
else:
for ic, row in enumerate(tsol):
if row["s_FORCE"] != 0:
content.append(format % row)
# complément des paramètres du calcul
spec_max_auto = False
# Gestion automatique de certains parametres
if param and param.get('AUTO') == "OUI" and param.get(
'_auto_first_LT') == None:
l_coor_nodes = struct.noeud_coor
l_coor_x, l_coor_y, l_coor_z = l_coor_sort(l_coor_nodes)
surf = param['SURF']
coef_offset = param['COEF_OFFSET']
dref_auto, rfic_auto, offset_max_auto, offset_nb_auto = calc_param_auto(
l_coor_x, l_coor_y, l_coor_z, surf, coef_offset)
sol_homo, vs = verif_sol_homogene(tab)
if param['SURF'] == "OUI" and sol_homo:
spec_max_auto = True
spec_max = vs / 15.
if param['OFFSET_MAX'] is None:
param['OFFSET_MAX'] = offset_max_auto
else:
UTMESS('A', 'MISS0_43', valk='OFFSET_MAX')
if param['OFFSET_NB'] is None:
param['OFFSET_NB'] = offset_nb_auto
else:
UTMESS('A', 'MISS0_43', valk='OFFSET_NB')
if param['OPTION_DREF'] == "OUI":
if param['DREF'] == None:
param['DREF'] = dref_auto
else:
UTMESS('A', 'MISS0_43', valk='DREF')
if param['OPTION_RFIC'] == "OUI":
if param['RFIC'] == None:
param['RFIC'] = rfic_auto
else:
UTMESS('A', 'MISS0_43', valk='RFIC')
else:
param['RFIC'] = 0.
if spec_max_auto:
if param['SPEC_MAX'] == None:
param['SPEC_MAX'] = spec_max
else:
UTMESS('A', 'MISS0_43', valk='SPEC_MAX')
#
print 'Mode automatique :'
print '- OFFSET_MAX auto = ', param['OFFSET_MAX']
print '- OFFSET_NB auto = ', param['OFFSET_NB']
print '- DREF auto = ', param['DREF']
print '- RFIC auto = ', param['RFIC']
if spec_max_auto:
print '- SPEC_MAX auto = ', param['SPEC_MAX']
# Pour Laplace-temps, on ne recalcule les parametre qu'une fois
if param['_auto_first_LT'] == None:
param['_auto_first_LT'] = False
#
if (param and param.get('OFFSET_MAX')) or (param
and param.get('AUTO') == "OUI"):
# ALGO
if param and param.get('ALGO'):
content.append("ALGO %s" % param['ALGO'])
elif param['SURF'] == "OUI":
content.append("ALGO DEPL")
else:
content.append("ALGO REGU")
# DREF / SPEC / OFFSET
if param['DREF']:
content.append(("DREF" + sfmt) % param['DREF'])
if param['SPEC_MAX']:
content.append(("SPEC" + sfmt + " / %d") %
(param['SPEC_MAX'], param['SPEC_NB']))
else:
content.append("SPEC AUTO")
content.append(("OFFSET" + sfmt + " / %d") %
(param['OFFSET_MAX'], param['OFFSET_NB']))
content.append("FIND")
# terminer le fichier par un retour chariot
content.append("")
return os.linesep.join(content)
def print_message(self,
code,
idmess,
valk=(),
vali=(),
valr=(),
exc_num=None,
exception=False,
print_as=None,
files=None,
cc=True):
"""Appelé par la routine fortran U2MESG ou à la fonction python UTMESS
pour afficher un message.
L'impression de ce message est différée si le `code` est suivi d'un "+".
code : 'A', 'E', 'S', 'F', 'I'
idmess : identificateur du message
valk, vali, valr : liste des chaines, entiers ou réels.
Si exception==True, on lève une exception en cas d'erreur, sinon
c'est l'appelant qui devra s'en charger (dans le C a priori).
'print_as', 'files', 'cc' : cf. print_buffer_content.
"""
idmess = idmess.strip()
# le '+' n'a pas de sens pour les messages 'I'.
if code == "I+":
code = "I"
if code == 'I':
msg = self._cache_txt.get(idmess)
if msg:
try:
self.affiche('MESSAGE',
msg % self.build_dict_args(valk, vali, valr))
return
except:
# le formattage 'brut' échoue, on passera par une
# conversion complète
pass
if self._parent is None:
self.set_parent(idmess)
if not self.update_counter(code, idmess):
return
# récupération du texte du message
dictmess = self.get_message(code, idmess, valk, vali, valr, exc_num)
# on le met dans le buffer
self.add_to_buffer(dictmess)
# si on n'attend pas une suite, ...
if is_last_message(code):
id0 = self.get_current_id().strip()
# vérification des compteurs
self.check_limit()
# on imprime le message en attente
self.print_buffer_content(print_as, files, cc)
if exception and code[0] in ('S', 'F'):
if self._mpi_rank is not None:
aster_core.MPI_Warn()
if self._mpi_rank == 0:
l_unit = list_unit('F')
txt = _(
u"On ne peut pas lever d'exception dans une exécution MPI."
)
for unite in l_unit:
self.affiche(unite, txt)
exc_typ = dictmess.get('exc_typ')
if exc_typ:
raise exc_typ(id0, valk, vali, valr)
raise error(id0, valk, vali, valr)
return None