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 build_global_file(self):
"""Build the file by concatenating those on each frequency"""
rank, size = aster_core.MPI_CommRankSize()
if rank == 0:
fimpe = self._fichier_tmp("impe_Laplace")
fd = open(fimpe, 'w')
for k in self.freq_list:
resname = self._fichier_tmp('resu_impe_%04d' % k)
fd.write(open(resname, 'r').read())
fd.close()
for k in range(1, size):
UTMESS('I', 'PARALLEL_2', valk=(fimpe, self._results_path[k]))
send_file(fimpe, self._results_path[k])
aster_core.MPI_Barrier()
def calc_europlexus_ops(self, EXCIT, COMPORTEMENT, ARCHIVAGE, CALCUL,
CARA_ELEM=None, MODELE=None,
CHAM_MATER=None, FONC_PARASOL=None,
OBSERVATION=None, COURBE=None,
DOMAINES=None, INTERFACES=None,
ETAT_INIT=None, AMORTISSEMENT=None,
INFO=1, **args):
"""
Macro-commande CALC_EUROPLEXUS.
"""
#
# PREPARATION
#
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
global DEFI_FICHIER
DEFI_FICHIER = self.get_cmd('DEFI_FICHIER')
# Pour la gestion des Exceptions
prev_onFatalError = aster.onFatalError()
aster.onFatalError('EXCEPTION')
# Pour masquer certaines alarmes
from Utilitai.Utmess import MasquerAlarme, RetablirAlarme
MasquerAlarme('MED_1')
MasquerAlarme('ALGELINE4_43')
MasquerAlarme('JEVEUX_57')
# Ligne de commande d'Europlexus
EXEC = args['LOGICIEL']
# Version d'Europlexus
VERS = args['VERSION_EUROPLEXUS']
# Chemin du repertoire REPE_OUT de l'execution courante d'Aster
REPE_OUT = os.path.join(os.getcwd(), 'REPE_OUT')
# Chemin du repertoire temporaire pour l'execution d'EPX
# (un lien vers REPE_OUT)
REPE_epx = tempfile.mkdtemp(suffix='_epx')
os.rmdir(REPE_epx)
os.symlink(REPE_OUT, REPE_epx)
# Le concept sortant (de type evol_noli) est nomme 'resu'.
# Le nom de ce concept sera celui defini par l'utilisateur.
self.DeclareOut('resu', self.sd)
global resu
# On récupère ce nom pour le nommage des fichiers dans REPE_OUT.
nom_resu = self.sd.get_name()
#Commandes pour le cas parallele
rank, np = aster_core.MPI_CommRankSize()
# Creation d'un repertoire commun pour les echanges de donnees entre procs
user=getpass.getuser()
name_tmp = uuid.uuid4()
run = AsRunFactory()
os.mkdir('%s/EPX_%s'%(run['shared_tmp'],name_tmp))
rep_tmp='%s/EPX_%s'%(run['shared_tmp'],name_tmp)
#
# TRADUCTION DES INFORMATIONS
#
EPX = EUROPLEXUS(ETAT_INIT, MODELE, CARA_ELEM, CHAM_MATER, COMPORTEMENT,
FONC_PARASOL, EXCIT, OBSERVATION, ARCHIVAGE, COURBE,
CALCUL, AMORTISSEMENT, DOMAINES, INTERFACES, REPE='REPE_OUT',
EXEC=EXEC, VERS=VERS, INFO=INFO, REPE_epx=REPE_epx, NOM_RESU=nom_resu,
REPE_tmp=rep_tmp, NP=np, RANK=rank,
args=args)
#
# ERITURE DU FICHIER DE COMMANDE EUROPLEXUS
#
EPX.ecrire_fichier()
#
# LANCEMENT DU CALCUL
#
#Commandes pour le cas parallele
#rank, np = aster_core.MPI_CommRankSize()
if args['LANCEMENT'] == 'OUI':
if np > 1 :
# Commandes pour que le processeur 0 voit les autres processeurs
cwd = osp.join(os.getcwd(), 'REPE_OUT')
host = socket.gethostname()
path = "{}:{}".format(host, cwd)
alldirs = aster_core.MPI_GatherStr(path, 0)
if rank==0 :
# Execution d Europlexus
EPX.lancer_calcul()
# Envoie des donnees sur les autres processeurs
name_epx='%s/commandes_%s.epx'%(cwd,nom_resu)
name_msh='%s/commandes_%s.msh'%(cwd,nom_resu)
name_sau='%s/resu_%s.sau'%(cwd,nom_resu)
name_med='%s/champ_%s.med'%(cwd,nom_resu)
if COURBE is not None:
name_pun='%s/courbes_%s.pun'%(cwd,nom_resu)
for i in alldirs[1:] :
send_file(name_epx, i)
send_file(name_msh, i)
send_file(name_sau, i)
send_file(name_med, i)
if COURBE is not None:
send_file(name_pun, i)
else :
print "PROCESSOR 0 IS RUNNING EUROPLEXUS!"
aster_core.MPI_Barrier()
else :
EPX.lancer_calcul()
#
# COPIE DES RESULTATS EPX DANS LE CONCEPT ASTER
#
EPX.get_resu()
#
# RECUPERER LES CONCEPTS TABLE
#
if COURBE is not None:
global table
self.DeclareOut('table', args['TABLE_COURBE'])
EPX.get_table()
#
# MENAGE
#
# Pour la gestion des Exceptions
aster.onFatalError(prev_onFatalError)
# Pour la gestion des alarmes
RetablirAlarme('MED_1')
RetablirAlarme('ALGELINE4_43')
RetablirAlarme('JEVEUX_57')
# Suppression du lien symbolique
os.remove(REPE_epx)
# Suppression du repertoire temporaire
shutil.rmtree(rep_tmp)
return ier