def cree_resultat_aster(self):
"""Produit le(s) fichier(s) issu(s) d'Aster."""
self._dbg_trace("Start")
ulaster = self.param.UL.Libre(action='ASSOCIER')
mael = self.param['MACR_ELEM_DYNA']
if mael is None:
opts = {}
if self.param['MATR_RIGI']:
opts['MATR_RIGI'] = self.param['MATR_RIGI']
if self.param['MATR_MASS']:
opts['MATR_MASS'] = self.param['MATR_MASS']
__mael = MACR_ELEM_DYNA(BASE_MODALE=self.param['BASE_MODALE'],
**opts)
mael = __mael
if self.param['_hasPC']:
grma = self.param['GROUP_MA_CONTROL']
self.param.set('_nbPC', get_number_PC(self.parent, mael, grma))
other_groups = {}
if self.param['ISSF'] == 'OUI':
other_groups = _F(
GROUP_MA_FLU_STR=self.param['GROUP_MA_FLU_STR'],
GROUP_MA_FLU_SOL=self.param['GROUP_MA_FLU_SOL'],
GROUP_MA_SOL_SOL=self.param['GROUP_MA_SOL_SOL'],)
IMPR_MACR_ELEM(MACR_ELEM_DYNA=mael,
FORMAT='MISS_3D',
GROUP_MA_INTERF=self.param['GROUP_MA_INTERF'],
GROUP_MA_CONTROL=self.param.get('GROUP_MA_CONTROL'),
FORMAT_R='1PE16.9',
SOUS_TITRE='PRODUIT PAR CALC_MISS',
UNITE=ulaster,
**other_groups)
self.param.UL.EtatInit(ulaster)
copie_fichier(self.param.UL.Nom(ulaster), self._fichier_tmp("aster"))
self.data = self.resu_aster_reader.read(self._fichier_tmp("aster"))
self._dbg_trace("Stop")
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 execute(self):
"""Exécute MISS3D : calcul du champ incident + boucle sur les fréquences complexes"""
self.init_attr()
if self.param['EXCIT_SOL']:
copie_fichier(self._fichier_tmp("inci"), self._fichier_tmp("in"))
aster.affiche(
"MESSAGE", 'LANCEMENT DU CALCUL DE LA FORCE SISMIQUE EN FREQUENCE')
CalculMiss.execute(self)
copie_fichier(
self._fichier_tmp("OUT"), self._fichier_tmp("OUT.inci"))
copie_fichier(
self._fichier_tmp("sol"), self._fichier_tmp("sol.inci"))
copie_fichier(self._fichier_tmp("resu_forc"),
self._fichier_tmp("forc_Laplace"))
copie_fichier(self._fichier_tmp("resu_forc"),
self._fichier_aster(self.param['EXCIT_SOL']['UNITE_RESU_FORC']))
CalculMiss.cree_fichier_sol(self)
aster.affiche("MESSAGE", 'BOUCLE SUR LES FREQUENCES COMPLEXES')
self._exec_boucle_lapl()
self.build_global_file()
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 fichier_resultat(self):
"""Copie les fichiers résultats dans les unités logiques."""
if self.param['UNITE_IMPR_ASTER'] and osp.exists(self._fichier_tmp("aster")):
copie_fichier(self._fichier_tmp("aster"),
self._fichier_aster(self.param['UNITE_IMPR_ASTER']))
if osp.exists(self._fichier_tmp("resu_impe")):
copie_fichier(self._fichier_tmp("resu_impe"),
self._fichier_aster(self.param['UNITE_RESU_IMPE']))
if osp.exists(self._fichier_tmp("resu_forc")):
copie_fichier(self._fichier_tmp("resu_forc"),
self._fichier_aster(self.param['UNITE_RESU_FORC']))
def fichier_resultat(self):
"""Libérer la structure contenant les données numériques
"""
if self.param['UNITE_IMPR_ASTER'] and osp.exists(self._fichier_tmp("aster")):
copie_fichier(self._fichier_tmp("aster"),
self._fichier_aster(self.param['UNITE_IMPR_ASTER']))