def init_mpi_error(self):
"""Stocke les informations nécessaires pour la gestion des erreurs en MPI."""
if not aster_exists:
return
rank = aster_core.MPI_CommRankSize()[0]
self._mpi_rank = aster_core._USE_MPI and rank or None
import platform
node = platform.node()
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 init_attr(self):
"""Initialisations"""
rank, size = aster_core.MPI_CommRankSize()
cwd = osp.join(os.getcwd(), self.param['_WRKDIR'])
host = socket.gethostname()
path = "{}:{}".format(host, cwd)
if size > 1:
UTMESS('I', 'PARALLEL_1', vali=(rank, size), valk=path)
ipath = encode_str(path)
# send proc #0 directory to others
self._results_path = []
buffer = aster_core.MPI_Bcast(ipath, 0)
self._results_path.append(decode_str(buffer))
# proc #0 gathers all working directories
alldirs = aster_core.MPI_GatherStr(path, 0)
if rank == 0:
self._results_path.extend(alldirs[1:])
self.dt = self.param['PAS_INST']
N_inst = int(self.param['INST_FIN'] / self.param['PAS_INST'])
self.reducFactor = self.param['FACTEUR_INTERPOL']
self.cutOffValue = self.param['PCENT_FREQ_CALCUL'] / 100.0
if N_inst % 2 != 0:
UTMESS('F', 'MISS0_18')
eps = self.param['PRECISION']
self.rho = eps ** (1. / (2. * N_inst))
factor = self.param['COEF_SURECH']
self.L_points = int(factor * N_inst)
self.nbr_freq = self.L_points / 2 + 1
# Variables à rajouter dans 'param'
self.param.set('LIST_FREQ', None)
self.param.set('FREQ_IMAG', None)
# Nombre de modes (dynamiques) d'interface
modes_nb = self.data.mode_stat_nb
self.param.set('NB_MODE', modes_nb)
# Creation du fichier sol
self.param.set('FICHIER_SOL_INCI', self._fichier_tmp_local("sol.inci"))
def calc_modes_multi_bandes( self, SOLVEUR_MODAL, SOLVEUR,
VERI_MODE, INFO, TITRE, **args):
"""
Macro-command CALC_MODES, case of the simultaneous iterations method
over several frequency bands, with optional parallelization.
Can be used only in the case of vibration modes (TYPE_RESU='DYNAMIQUE')
"""
MATR_RIGI = args['MATR_RIGI']
MATR_MASS = args['MATR_MASS']
CALC_FREQ = args['CALC_FREQ']
METHODE = SOLVEUR_MODAL['METHODE']
STOP_BANDE_VIDE = "NON"
# ----------------------------------------------------------------------
#
# 1a. INITIALISATIONS
#
# ----------------------------------------------------------------------
ier = 0
dbg = False # True si on souhaite faire un IMPR_CO intermediaire, False sinon
lmatphys = True # True si matrices d'entrée de type matr_asse_depl_r, False sinon
if (AsType(MATR_RIGI) != matr_asse_depl_r):
lmatphys = False
# On importe les definitions des commandes a utiliser dans la macro
from Modal.mode_iter_simult import MODE_ITER_SIMULT
EXTR_MODE = self.get_cmd('EXTR_MODE')
INFO_MODE = self.get_cmd('INFO_MODE')
MODI_MODELE = self.get_cmd('MODI_MODELE')
NUME_DDL = self.get_cmd('NUME_DDL')
if (dbg):
IMPR_CO = self.get_cmd('IMPR_CO')
# Recuperation parametres solveur lineaire
dSolveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
for i in dSolveur.keys():
if dSolveur[i] == None:
del dSolveur[i]
if dSolveur.has_key('TYPE_RESU'): # because TYPE_RESU is a keyword with a 'global' position
del dSolveur['TYPE_RESU']
if dSolveur.has_key('OPTION'): # because OPTION is a keyword with a 'global' position
del dSolveur['OPTION']
if dSolveur.has_key('FREQ'): # because FREQ can be a keyword with a 'global' position
del dSolveur['FREQ']
solveur_lineaire = dSolveur.get('METHODE').strip()
dSolveur_infomode = dSolveur
# pour INFO_MODE, le mot-clé facteur SOLVEUR ne doit pas contenir les
# mot-clés POSTTRAITEMENTS et RESI_RELA
if dSolveur_infomode.has_key('POSTTRAITEMENTS'):
del dSolveur_infomode['POSTTRAITEMENTS']
if dSolveur_infomode.has_key('RESI_RELA'):
del dSolveur_infomode['RESI_RELA']
nompro = None
iocc = 0
# Rang du processus MPI et taille du MPI_COMM_WORLD
# Lorsqu'on ne veut q'un niveau de parallelisme (celui du solveur lineaire)
# on bluffe l'algo en posant rang=0/nbproc=1 pour tous les procs.
# Cependant si le solveur est autre que MUMPS on s'arrete en erreur.
if CALC_FREQ['NIVEAU_PARALLELISME'] == 'COMPLET':
rang, nbproc = aster_core.MPI_CommRankSize()
niv_par = 'COMPLET'
elif CALC_FREQ['NIVEAU_PARALLELISME'] == 'PARTIEL':
rang = 0
nbproc = 1
niv_par = 'PARTIEL'
nbproc_real = aster_core.MPI_CommRankSize()[1]
if ((nbproc_real > 1) & (solveur_lineaire != 'MUMPS')):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('F', 'MODAL_14', vali=nbproc_real, valk=solveur_lineaire)
aster.affiche('MESSAGE', 72 * '-')
else:
assert(False) # Pb parametrage NIVEAU_PARALLELISME
# Construction de la liste de frequences
if CALC_FREQ['FREQ']:
lborne = []
nnfreq = len(CALC_FREQ['FREQ'])
for i in range(0, nnfreq):
lborne.append(CALC_FREQ['FREQ'][i])
else:
assert(False) # Pb parametrage CALC_FREQ
# ----------------------------------------------------------------------
#
# 1b. TRAVAUX PREPARATOIRES AU LANCEMENT DE LA BOUCLE
#
# ----------------------------------------------------------------------
# Modification de la sd_partition pour rendre compatible les niveaux de
# parallelisme: celui en frequence et celui des calculs ele/assemblage.
# Pour l'instant on fonctionne en mode 'CENTRALISE' au sein de la macro
# (ds les sous-communicateurs, les calculs elem/assemblages
# ne sont pas parallelises).
# On remettra le mode de fonctionnement initial en fin de Macro.
if (nbproc > 1):
nommod, old_prtk1 = recup_modele_partition(MATR_RIGI, dbg)
sd_modele = None
sd_modele = self.get_concept(nommod)
if (sd_modele == None):
assert(False) # Pb, on arrive pas a recuperer le nom du modele
if (old_prtk1 != None):
motdimo = {}
motdimo['reuse'] = sd_modele
motdimo['MODELE'] = sd_modele
motdimo['DISTRIBUTION'] = _F(METHODE='CENTRALISE')
__modimo = MODI_MODELE(**motdimo)
# INFO_MODE global sur la liste de frequences
# Parametres basiques
motfaci = {}
motfaci['COMPTAGE'] = _F(METHODE='AUTO',
SEUIL_FREQ=CALC_FREQ['SEUIL_FREQ'],
NMAX_ITER_SHIFT=CALC_FREQ['NMAX_ITER_SHIFT'],
PREC_SHIFT=CALC_FREQ['PREC_SHIFT'],)
# Gestion des frequences
ier = gestion_frequence(solveur_lineaire, nnfreq, nbproc)
# Parametrage du parallelisme pour la couche FORTRAN/MPI
if (nbproc > 1):
motfaci['PARALLELISME_MACRO'] = _F(TYPE_COM=1)
__nbmodi = INFO_MODE(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
INFO=INFO,
FREQ=lborne,
NIVEAU_PARALLELISME=niv_par,
SOLVEUR=dSolveur_infomode,
**motfaci)
# Gestion des sous-bandes de frequences et construction (si //) de l'objet
nbmodeth, nbsb_nonvide, proc_sb_nvide = gestion_sous_bande(
solveur_lineaire, __nbmodi, nnfreq, nbproc,
STOP_BANDE_VIDE == "OUI")
# ----------------------------------------------------------------------
#
# 2. BOUCLE DE MODE_ITER_SIMULT(OPTION=BANDE) + NORM_MODE/IMPR_RESU
#
# ----------------------------------------------------------------------
# On ne traite pas les sous-bandes vides (gain de temps et d'affichage!)
# On affiche un message a la place.
# Tous les processeurs font la meme chose pour ces sous-bandes vides, par
# contre, ils se repartissent bien sur les non-vides.
#
# RQ MPI:
# Les procs s'attendent via le MPI_COMM_SPLIT opere en fin de l'INFO_MODE
# precedent. Ce n'est pas la peine de commencer la boucle si un proc
# fait defaut.
# ----------------------------------------------------------------------
nbmodeef = None
freq_ini = 1.E+99
freq_fin = -1.E+99
motscles = {}
motscles['FILTRE_MODE'] = []
numsb_nonvide = 0
for i in range(0, nnfreq - 1):
#--------------------------------------------------------------------
#
# 2. SOUS-BANDE NON VIDE
#
#--------------------------------------------------------------------
sb_vide = None
do_loop = None
if (__nbmodi['NB_MODE', i + 1] == 0):
sb_vide = True
do_loop = False
else:
numsb_nonvide = numsb_nonvide + 1
sb_vide = False
if (((nbproc > 1) & (proc_sb_nvide[rang] == numsb_nonvide)) | (nbproc == 1)):
do_loop = True
else:
do_loop = False
if ((not sb_vide) & do_loop):
motscit = {}
motscfa = {}
if SOLVEUR_MODAL['DIM_SOUS_ESPACE']:
motscfa['DIM_SOUS_ESPACE'] = SOLVEUR_MODAL['DIM_SOUS_ESPACE']
if SOLVEUR_MODAL['COEF_DIM_ESPACE']:
motscfa['COEF_DIM_ESPACE'] = SOLVEUR_MODAL['COEF_DIM_ESPACE']
motscfa['FREQ'] = (lborne[i], lborne[i + 1])
motscfa['TABLE_FREQ'] = __nbmodi
motscit['CALC_FREQ'] = _F(OPTION='BANDE',
SEUIL_FREQ=CALC_FREQ['SEUIL_FREQ'],
NMAX_ITER_SHIFT=CALC_FREQ[
'NMAX_ITER_SHIFT'],
PREC_SHIFT=CALC_FREQ['PREC_SHIFT'],
**motscfa)
if VERI_MODE['STURM'] == 'LOCAL':
motveri = 'OUI'
else:
motveri = 'NON'
motscit['VERI_MODE'] = _F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'],
SEUIL=VERI_MODE['SEUIL'],
STURM=motveri,
PREC_SHIFT=VERI_MODE['PREC_SHIFT'])
motscit['STOP_BANDE_VIDE'] = STOP_BANDE_VIDE
OPTION = 'SANS' # option for detecting rigid body modes
if METHODE == 'TRI_DIAG':
if args.has_key('NMAX_ITER_ORTHO'):
motscit['NMAX_ITER_ORTHO'] = SOLVEUR_MODAL[
'NMAX_ITER_ORTHO']
if args.has_key('PREC_ORTHO'):
motscit['PREC_ORTHO'] = SOLVEUR_MODAL['PREC_ORTHO']
if args.has_key('PREC_LANCZOS'):
motscit['PREC_LANCZOS'] = SOLVEUR_MODAL['PREC_LANCZOS']
if args.has_key('MAX_ITER_QR'):
motscit['NMAX_ITER_QR'] = SOLVEUR_MODAL['NMAX_ITER_QR']
if SOLVEUR_MODAL['MODE_RIGIDE'] == 'OUI':
OPTION = 'MODE_RIGIDE'
elif METHODE == 'JACOBI':
if args.has_key('NMAX_ITER_BATHE'):
motscit['NMAX_ITER_BATHE'] = SOLVEUR_MODAL[
'NMAX_ITER_BATHE']
if args.has_key('PREC_BATHE'):
motscit['PREC_BATHE'] = SOLVEUR_MODAL['PREC_BATHE']
if args.has_key('NMAX_ITER_JACOBI'):
motscit['NMAX_ITER_JACOBI'] = SOLVEUR_MODAL[
'NMAX_ITER_JACOBI']
if args.has_key('PREC_JACOBI'):
motscit['PREC_JACOBI'] = SOLVEUR_MODAL['PREC_JACOBI']
elif METHODE == 'SORENSEN':
if args.has_key('NMAX_ITER_SOREN'):
motscit['NMAX_ITER_SOREN'] = SOLVEUR_MODAL[
'NMAX_ITER_SOREN']
if args.has_key('PARA_ORTHO_SOREN'):
motscit['PARA_ORTHO_SOREN'] = SOLVEUR_MODAL[
'PARA_ORTHO_SOREN']
if args.has_key('PREC_SOREN'):
motscit['PREC_SOREN'] = SOLVEUR_MODAL['PREC_SOREN']
elif METHODE == 'QZ':
motscit['TYPE_QZ'] = SOLVEUR_MODAL['TYPE_QZ']
else:
assert(False) # Pb parametrage METHODE
# Parametrage du parallelisme pour la couche FORTRAN/MPI
# afin d'operer les comm des modes propres et des parametres
# modaux.
if (nbproc > 1):
motscit['PARALLELISME_MACRO'] = _F(TYPE_COM=1,
IPARA1_COM=numsb_nonvide,
IPARA2_COM=nbsb_nonvide,
)
#-----------------------------------------------------------------
#
# 2a. Calcul des modes
#
#----------------------------------------------------------------- )
__nomre0 = MODE_ITER_SIMULT(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
INFO=INFO,
METHODE=METHODE,
OPTION=OPTION,
SOLVEUR=dSolveur,
**motscit)
#-----------------------------------------------------------------
#
# 2b. Preparation du test de Sturm de l'etape 3a.
#
#-----------------------------------------------------------------
if VERI_MODE['STURM'] in ('GLOBAL', 'OUI'): # in the case of CALC_MODES on several bands, OUI is reset to GLOBAL
dicomode = {}
dicomode = __nomre0.LIST_VARI_ACCES()
if (len(dicomode['FREQ']) != 0):
raux_ini = dicomode['FREQ'][0]
raux_fin = dicomode['FREQ'][-1]
if (raux_ini < freq_ini):
freq_ini = raux_ini
if (raux_fin > freq_fin):
freq_fin = raux_fin
else:
assert(False) # Ce test ne marche pas (PB LIST_VARI_ACCES)
#-----------------------------------------------------------------
#
# 2c. Préparation pour la concaténation de l'étape 3b.
#
#-----------------------------------------------------------------
motscles['FILTRE_MODE'].append(_F(MODE=__nomre0,
TOUT_ORDRE='OUI'))
# Pour verification
if (dbg):
IMPR_CO(CONCEPT=_F(NOM=__nomre0))
#--------------------------------------------------------------------
#
# 2. SOUS-BANDE VIDE
#
#--------------------------------------------------------------------
elif (sb_vide):
if (STOP_BANDE_VIDE == 'OUI'):
UTMESS('F', 'MODAL_6', vali=(i + 1,))
elif (STOP_BANDE_VIDE == 'NON'):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_6', vali=(i + 1,))
aster.affiche('MESSAGE', 72 * '-')
else:
assert(False) # Pb parametrage STOP_BANDE_VIDE
#-----------------------------------------------------------------------
#
# 3a. Test de sturm effectif
#
#-----------------------------------------------------------------------
if VERI_MODE['STURM'] == 'NON':
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_2')
aster.affiche('MESSAGE', 72 * '-')
elif VERI_MODE['STURM'] == 'LOCAL':
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_3')
aster.affiche('MESSAGE', 72 * '-')
elif VERI_MODE['STURM'] in ('GLOBAL', 'OUI'): # in the case of CALC_MODES on several bands, OUI is reset to GLOBAL
# Construction des 2 bornes de la bande a tester
if (nbmodeth != 0):
omecor = CALC_FREQ['SEUIL_FREQ']
precshift = VERI_MODE['PREC_SHIFT']
freq_ini = (1.0 - precshift) * freq_ini
freq_fin = (1.0 + precshift) * freq_fin
if (abs(freq_ini) < omecor):
freq_ini = -omecor
if (abs(freq_fin) < omecor):
freq_fin = omecor
# Parametrage du parallelisme pour la couche FORTRAN/MPI
if (nbproc > 1):
motfaci['PARALLELISME_MACRO'] = _F(TYPE_COM=2)
__nbmodf = INFO_MODE(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
INFO=INFO,
FREQ=(freq_ini, freq_fin),
NIVEAU_PARALLELISME = niv_par,
SOLVEUR =dSolveur_infomode,
**motfaci)
# Recuperation du nbre de modes donnes par STURM global
nbmodesg = __nbmodf['NB_MODE', 1]
if (nbmodeth == nbmodesg):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_4', valr=(
freq_ini, freq_fin), vali=(nbmodesg, nbmodeth))
aster.affiche('MESSAGE', 72 * '-')
else:
# Message similaire a ALGELINE5_24 pour le FORTRAN
if (VERI_MODE['STOP_ERREUR'] == 'OUI'):
UTMESS('F', 'MODAL_5', valr=(
freq_ini, freq_fin, precshift), vali=(nbmodesg, nbmodeth))
elif (VERI_MODE['STOP_ERREUR'] == 'NON'):
UTMESS('A', 'MODAL_5', valr=(
freq_ini, freq_fin, precshift), vali=(nbmodesg, nbmodeth))
else:
assert(False) # Pb parametrage VERI_MODE
# La bande globale est vide
else:
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_7', valr=(lborne[0], lborne[nnfreq - 1]))
aster.affiche('MESSAGE', 72 * '-')
else:
assert(False) # Pb parametrage STURM
#-----------------------------------------------------------------------
#
# 3b. Concaténation des résultats
#
#-----------------------------------------------------------------------
self.DeclareOut('modes', self.sd)
modes = EXTR_MODE(**motscles)
# ----------------------------------------------------------------------
#
# 3c. Epilogue
#
# RQ MPI:
# Si la SD_PARTITION existait avant de rentrer ds la Macro on remet ses
# anciennes valeurs pour continuer la suite du fichier de commande.
#----------------------------------------------------------------------
if (nbproc > 1):
if (old_prtk1 != None):
motdimo = {}
motdimo['reuse'] = sd_modele
motdimo['MODELE'] = sd_modele
motdimo['DISTRIBUTION'] = _F(METHODE=old_prtk1)
__modimo = MODI_MODELE(**motdimo)
return modes
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
def init_mpi_error(self):
"""Stocke les informations nécessaires pour la gestion des erreurs en MPI."""
if not aster_core._USE_MPI:
return
self._mpi_rank, self._mpi_nbcpu = aster_core.MPI_CommRankSize()