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 configure(self, kwargs):
"""Pre-execution function, read the keywords"""
super(ExecSalomeScript, self).configure(kwargs)
factKw = kwargs['SALOME']
if os.environ.get('APPLI'):
local = osp.join(os.environ['HOME'], os.environ['APPLI'], 'salome')
else:
local = osp.join(aster_core.get_option('repout'), 'salome')
if not self.prog or factKw['MACHINE']:
self.prog = local
self.args.insert(0, 'shell')
if factKw['MACHINE']:
self.args.extend(['-m', factKw['MACHINE']])
# suppose the path to salome is the same on the remote host
# if LOGICIEL is not provided
self.args.extend(['-d', kwargs['LOGICIEL'] or local])
self.args.extend(['-u', factKw['UTILISATEUR']])
self.args.extend(['-p', str(factKw['PORT'])])
# change NOM_PARA/VALE in the original script
script = tempfile.NamedTemporaryFile(dir='.', suffix='.py').name
writeSalomeScript(factKw['CHEMIN_SCRIPT'], script, factKw)
self.args.append(script)
# input and output files
inputs = factKw['FICHIERS_ENTREE'] or []
if inputs:
self.args.append('args:' + ','.join(inputs))
outputs = factKw['FICHIERS_SORTIE'] or []
if outputs:
self.args.append('out:' + ','.join(outputs))
safe_remove(*outputs)
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 configure(self, kwargs):
"""Pre-execution function, read the keywords"""
super(ExecGmsh, self).configure(kwargs)
self.format = "MED"
self.fileOut = tempfile.NamedTemporaryFile(dir='.', suffix='.med').name
self.uniteAster.Libre(action='ASSOCIER', nom=self.fileOut)
self.prog = self.prog or osp.join(aster_core.get_option('repout'),
'gmsh')
self.args.extend(
['-3', '-format', 'med', self.fileIn, '-o', self.fileOut])
def _build_coeur(typ_coeur, macro, sdtab):
"""Return a `Coeur` object of the given type"""
datg = aster_core.get_option("repdex")
factory = CoeurFactory(datg)
# prepare the Table object
tab = sdtab.EXTR_TABLE()
name = tab.para[0]
tab.Renomme(name, 'idAC')
coeur = factory.get(typ_coeur)(name, typ_coeur, macro, datg)
coeur.init_from_table(tab)
return coeur
def configure(self, kwargs):
"""Pre-execution function, read the keywords"""
super(ExecGibi, self).configure(kwargs)
self.format = "ASTER"
self.fileTmp = tempfile.NamedTemporaryFile(dir='.',
suffix='.mgib').name
self.fileOut = tempfile.NamedTemporaryFile(dir='.',
suffix='.mail').name
self.prog = self.prog or osp.join(aster_core.get_option('repout'),
'gibi')
self.args.extend([self.fileIn, self.fileTmp])
def configure(self, kwargs):
"""Pre-execution function, read the keywords"""
super(ExecSalome, self).configure(kwargs)
self.format = "MED"
if len(self.args) != 1:
UTMESS('F', 'EXECLOGICIEL0_1')
self.fileOut = self.args[0]
self.uniteAster.Libre(action='ASSOCIER', nom=self.fileOut)
# start a SALOME session
portFile = tempfile.NamedTemporaryFile(dir='.', suffix='.port').name
self.prog = self.prog or osp.join(aster_core.get_option('repout'),
'salome')
self.args = ['start', '-t', '--ns-port-log={}'.format(portFile)]
# do not capture the output, it will block!
self.executeCommand(capture=False, silent=True)
self.pid = open(portFile, 'rb').read().strip()
# prepare the main command
self.args = ['shell', '-p', self.pid, self.fileIn]
def macr_recal(self, UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC,
ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA, UNITE_RESU, PARA_DIFF_FINI,
GRAPHIQUE, METHODE, INFO, **args):
from Utilitai.Utmess import UTMESS
if os.environ.has_key('ASTER_ROOT'):
ASTER_ROOT = os.environ['ASTER_ROOT']
else:
ASTER_ROOT = os.path.join(aster_core.get_option('repout'), '..')
try:
sys.path.append(os.path.join(ASTER_ROOT, 'ASTK', 'ASTK_SERV', 'lib'))
sys.path.append(os.path.join(ASTER_ROOT, 'lib', 'python%s.%s' %
(sys.version_info[0], sys.version_info[1]), 'site-packages'))
except:
pass
try:
from asrun.profil import ASTER_PROFIL
except Exception, e:
print e
UTMESS('F', 'RECAL0_2')
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 POURSUITE(self, PAR_LOT, IMPR_MACRO, CODE, DEBUG, IGNORE_ALARM, LANG, INFO,
**args):
"""
Fonction sdprod de la macro POURSUITE
"""
# La commande POURSUITE ne peut exister qu'au niveau jdc
if self.jdc is not self.parent:
raise Accas.AsException(
"La commande POURSUITE ne peut exister qu'au niveau jdc")
code = None if CODE == 'NON' else 'TEST'
commun_DEBUT_POURSUITE(self.jdc, PAR_LOT, IMPR_MACRO, code, DEBUG,
IGNORE_ALARM, LANG, INFO)
only_syntax = False
if aster_exists:
self.jdc.set_poursuite(True)
only_syntax = self.jdc.syntax_check()
if self.codex:
base = 'glob.1'
if aster_exists:
repglob = aster_core.get_option("repglob")
bhdf = osp.join(repglob, 'bhdf.1')
base = osp.join(repglob, 'glob.1')
if not osp.isfile(base) and not osp.isfile(bhdf) \
and not only_syntax:
UTMESS('F', 'SUPERVIS_89')
# Le module d'execution est accessible et glob.1 est present
# Pour eviter de rappeler plusieurs fois la sequence d'initialisation
# on memorise avec l'attribut fichier_init que l'initialisation
# est réalisée
if hasattr(self, 'fichier_init'):
return
self.fichier_init = 'glob.1'
if not only_syntax:
self.jdc.initexec()
# le sous programme fortran appelé par self.codex.poursu demande le numéro
# de l'operateur (GCECDU->getoper), on lui donne la valeur 0
self.definition.op = 0
self.codex.poursu(self)
# Par la suite pour ne pas executer la commande pendant la phase
# d'execution on le remet à None
self.definition.op = None
self.g_context = {}
# Il peut exister un contexte python sauvegardé sous forme pickled
# On récupère ces objets après la restauration des concepts pour que
# la récupération des objets pickled soit prioritaire.
# On vérifie que les concepts relus dans glob.1 sont bien tous
# presents sous le même nom et du même type dans pick.1
# Le contexte est ensuite updaté (surcharge) et donc enrichi des
# variables qui ne sont pas des concepts.
# On supprime du pickle_context les concepts valant None, ca peut
# être le cas des concepts non executés, placés après FIN.
UTMESS('I', 'SUPERVIS2_1', valk='pick.1')
pickle_context = get_pickled_context()
if pickle_context == None:
UTMESS('F', 'SUPERVIS_86')
return
self.jdc.restore_pickled_attrs(pickle_context)
if not only_syntax:
# vérification cohérence pick/base
savsign = self.jdc._sign
newsign = self.jdc.signature(base)
if args.get('FORMAT_HDF') == 'OUI':
UTMESS('I', 'SUPERVIS_71')
elif newsign != savsign:
UTMESS('A',
'SUPERVIS_69',
valk=(savsign, newsign),
vali=self.jdc.jeveux_sysaddr)
else:
UTMESS('I',
'SUPERVIS_70',
valk=newsign,
vali=self.jdc.jeveux_sysaddr)
from .DataStructure import entier
from Noyau.N_CO import CO
interrupt = []
count = 0
UTMESS('I', 'SUPERVIS_65')
for elem, co in pickle_context.items():
if isinstance(co, ASSD):
count += 1
typnam = co.__class__.__name__
# on rattache chaque assd au nouveau jdc courant (en poursuite)
co.jdc = self.jdc
co.parent = self.jdc
# le marquer comme 'executed'
i_int = ''
if co.executed != 1:
interrupt.append((co.nom, typnam))
i_int = 'exception'
co.executed = 1
UTMESS('I',
'SUPERVIS_66',
valk=(co.nom, typnam.lower(), i_int))
# pour que sds_dict soit cohérent avec g_context
self.jdc.sds_dict[elem] = co
if elem != co.nom:
name = re.sub('_([0-9]+)$', '[\\1]', co.nom)
if self.jdc.info_level > 1:
UTMESS('I',
'SUPERVIS2_3',
valk=(elem, type(co).__name__.upper()))
UTMESS('A',
'SUPERVIS_93',
valk=(elem, name, "del {}".format(elem)))
del pickle_context[elem]
continue
if co == None:
del pickle_context[elem]
if only_syntax:
interrupt = []
if count == 0:
UTMESS('I', 'SUPERVIS_67')
for nom, typnam in interrupt:
UTMESS('I', 'SUPERVIS_76', valk=(nom, typnam))
if not interrupt:
UTMESS('I', 'SUPERVIS_72')
if self.jdc.info_level > 1:
keys = pickle_context.keys()
keys.sort()
for key in keys:
try:
value = str(pickle_context[key])
if len(value) > 1000:
value = value[:1000] + '...'
valk = key, value
except:
valk = key, '...'
UTMESS('I', 'SUPERVIS_73', valk=valk)
self.g_context.update(pickle_context)
return
else:
# Si le module d'execution n est pas accessible ou glob.1 absent on
# demande un fichier (EFICAS)
# Il faut éviter de réinterpréter le fichier à chaque appel de
# POURSUITE
if hasattr(self, 'fichier_init'):
return
self.make_poursuite()
def perm_mac3coeur_ops(self, **args):
"""Corps principal de la macro pour la permutation des AC dans MAC3COEUR"""
import aster
from code_aster.Cata.Syntax import _F
from mac3coeur_ac_permute import MACRO_AC_PERMUTE
from Utilitai.UniteAster import UniteAster
from Utilitai.Utmess import UTMESS
STAT_NON_LINE = self.get_cmd('STAT_NON_LINE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_RESU = self.get_cmd('CREA_RESU')
AFFE_CHAR_CINE = self.get_cmd('AFFE_CHAR_CINE')
self.set_icmd(1)
datg = aster_core.get_option("repdex")
coeur_factory = CoeurFactory(datg)
_typ_coeur_N = self['TYPE_COEUR_N']
_typ_coeur_P = self['TYPE_COEUR_NP1']
_TAB_N = self['TABLE_N']
_l_tabn1 = []
for el in _TAB_N:
_l_tabn1.append(el.EXTR_TABLE())
l_RESUI = self['RESU_N']
assert (len(_TAB_N) == len(l_RESUI))
l_last_i = []
_l_MA_N = []
for RESUI in l_RESUI:
l_last_i.append(RESUI.LIST_PARA()['INST'][-1])
# on recupere le concept maillage
iret, ibid, nom_mo = aster.dismoi('MODELE', RESUI.nom, 'RESULTAT', 'F')
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', nom_mo.strip(),
'MODELE', 'F')
_MA_N = self.get_concept_by_type(nom_ma, maillage_sdaster)
_l_MA_N.append(_MA_N)
_l_coeur = []
for _tabn1 in _l_tabn1:
# on recupere le nom du coeur
name = _tabn1.para[0]
# et on renomme la colonne qui identifie les assemblages
_tabn1.Renomme(name, 'idAC')
_coeur = coeur_factory.get(_typ_coeur_N)(name, _typ_coeur_N, self,
datg)
_coeur.init_from_table(_tabn1)
_l_coeur.append(_coeur)
_TAB_NP1 = self['TABLE_NP1']
_tabp1 = _TAB_NP1.EXTR_TABLE()
# on recupere le nom du coeurq
namep1 = _tabp1.para[0]
# et on renomme la colonne qui identifie les assemblages
_tabp1.Renomme(namep1, 'idAC')
_coeurp1 = coeur_factory.get(_typ_coeur_P)(namep1, _typ_coeur_P, self,
datg)
_coeurp1.init_from_table(_tabp1)
_MA1 = self['MAILLAGE_NP1']
_MA_NP1 = _coeurp1.affectation_maillage(_MA1)
_MO_NP1 = _coeurp1.affectation_modele(_MA_NP1)
_coeurp1.recuperation_donnees_geom(_MA_NP1)
_GFF_NP1 = _coeurp1.definition_geom_fibre()
_CARANP1 = _coeurp1.definition_cara_coeur(_MO_NP1, _GFF_NP1)
_fluence = 0.0
_timep1 = _coeurp1.definition_time(_fluence, 1.)
_FLU_NP1 = _coeurp1.definition_fluence(_fluence, _MA_NP1, 0.)
_CHTHNP1 = _coeurp1.definition_champ_temperature(_MA_NP1)
_AFSCNP1 = _coeurp1.definition_materiau(_MA_NP1,
_GFF_NP1,
_FLU_NP1,
_CHTHNP1,
CONTACT='NON')
_CL_BID = AFFE_CHAR_CINE(MODELE=_MO_NP1,
MECA_IMPO=(_F(
TOUT='OUI',
DX=0.0,
DY=0.0,
DZ=0.0,
DRX=0.0,
DRY=0.0,
DRZ=0.0,
), ))
tran_x = 0.0
indice = 0
# calcul bidon aster pour initialisation de donnees
compor = [
_F(
RELATION='MULTIFIBRE',
GROUP_MA=('CRAYON', 'T_GUIDE'),
PARM_THETA=0.5,
DEFORMATION='GROT_GDEP',
),
_F(
RELATION='DIS_GRICRA',
GROUP_MA='ELA',
),
_F(
RELATION='DIS_CHOC',
GROUP_MA='RES_TOT',
),
_F(
RELATION='ELAS',
GROUP_MA=(
'EBOINF',
'EBOSUP',
'RIG',
'DIL',
),
),
_F(
RELATION='VMIS_ISOT_TRAC',
GROUP_MA='MAINTIEN',
DEFORMATION='PETIT',
),
]
self.DeclareOut('BIDON', self.sd)
__BIDON = STAT_NON_LINE(
MODELE=_MO_NP1,
CHAM_MATER=_AFSCNP1,
CARA_ELEM=_CARANP1,
EXCIT=(_F(CHARGE=_CL_BID, ), ),
COMPORTEMENT=(
_F(
RELATION='MULTIFIBRE',
GROUP_MA=('CRAYON', 'T_GUIDE'),
PARM_THETA=0.5,
DEFORMATION='GROT_GDEP',
),
_F(
RELATION='DIS_GRICRA',
GROUP_MA='ELA',
),
_F(
RELATION='DIS_CHOC',
GROUP_MA='RES_TOT',
),
_F(
RELATION='ELAS',
GROUP_MA=(
'EBOINF',
'EBOSUP',
'RIG',
'DIL',
),
),
_F(
RELATION='VMIS_ISOT_TRAC',
GROUP_MA='MAINTIEN',
DEFORMATION='PETIT',
),
),
INCREMENT=_F(
LIST_INST=_timep1,
NUME_INST_FIN=1,
),
NEWTON=_F(
MATRICE='TANGENTE',
REAC_ITER=1,
),
SOLVEUR=_F(
METHODE='MUMPS',
RENUM='AMF',
GESTION_MEMOIRE='OUT_OF_CORE',
ELIM_LAGR='NON',
PCENT_PIVOT=80,
),
)
# il faut un resultat avec un seul instant : 0.
# on le reconstruit a partir de __BIDON
_tini = __BIDON.LIST_PARA()['INST'][-1]
__CHDEP = CREA_CHAMP(
TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
PRECISION=1.0E-10,
RESULTAT=__BIDON,
NOM_CHAM='DEPL',
INST=_tini,
)
__ASSDEP = CREA_CHAMP(
TYPE_CHAM='NOEU_DEPL_R',
MODELE=_MO_NP1,
OPERATION='ASSE',
ASSE=(_F(TOUT='OUI', CHAM_GD=__CHDEP, CUMUL='NON', COEF_R=0.0), ),
)
#__RESU_F = CREA_RESU(OPERATION='AFFE',
BIDON = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='DEPL',
AFFE=_F(
CHAM_GD=__ASSDEP,
INST=0.0,
MODELE=_MO_NP1,
))
__CHSIE = CREA_CHAMP(
TYPE_CHAM='ELGA_SIEF_R',
OPERATION='EXTR',
PRECISION=1.0E-10,
RESULTAT=__BIDON,
NOM_CHAM='SIEF_ELGA',
INST=_tini,
)
__ASSSIE = CREA_CHAMP(
TYPE_CHAM='ELGA_SIEF_R',
MODELE=_MO_NP1,
OPERATION='ASSE',
ASSE=(_F(TOUT='OUI', CHAM_GD=__CHSIE, CUMUL='NON', COEF_R=0.0), ),
)
CREA_RESU(reuse=BIDON,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='SIEF_ELGA',
AFFE=_F(
CHAM_GD=__ASSSIE,
INST=0.0,
MODELE=_MO_NP1,
))
__CHVAR = CREA_CHAMP(
TYPE_CHAM='ELGA_VARI_R',
OPERATION='EXTR',
PRECISION=1.0E-10,
RESULTAT=__BIDON,
NOM_CHAM='VARI_ELGA',
INST=_tini,
)
__ASSVAR = CREA_CHAMP(
TYPE_CHAM='ELGA_VARI_R',
MODELE=_MO_NP1,
OPERATION='ASSE',
ASSE=(_F(TOUT='OUI', CHAM_GD=__CHVAR, CUMUL='NON', COEF_R=0.0), ),
)
CREA_RESU(reuse=BIDON,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='VARI_ELGA',
AFFE=_F(
CHAM_GD=__ASSVAR,
INST=0.0,
MODELE=_MO_NP1,
))
nbresu = len(l_RESUI)
assert (len(_l_coeur) == nbresu)
assert (len(l_last_i) == nbresu)
assert (len(_l_MA_N) == nbresu)
for nom in _coeurp1.nameAC.keys():
for i in xrange(len(_l_coeur)):
_coeur = _l_coeur[i]
last_i = l_last_i[i]
RESUI = l_RESUI[i]
_MA_N = _l_MA_N[i]
if nom in _coeur.nameAC:
#print 'index z : ',_coeurp1.get_index(_coeurp1.nameAC[nom][0]),_coeurp1.get_index(_coeur.nameAC[nom][0])
#print 'index y : ',_coeurp1.get_index(_coeurp1.nameAC[nom][2]),_coeurp1.get_index(_coeur.nameAC[nom][2])
tran_z = _coeurp1.pas_assemblage * \
(_coeurp1.get_index(_coeurp1.nameAC[nom][
0]) - _coeurp1.get_index(_coeur.nameAC[nom][0]))
tran_y = _coeurp1.pas_assemblage * \
(_coeurp1.get_index(_coeurp1.nameAC[nom][
2]) - _coeurp1.get_index(_coeur.nameAC[nom][2]))
#print 'tran_z, tran_y, tran_x = ',tran_z, tran_y, tran_x
#print 'AC init, AC_fin = ',_coeur.nameAC[nom],_coeurp1.nameAC[nom]
MACRO_AC_PERMUTE(POS_INIT=_coeur.nameAC[nom],
POS_FIN=_coeurp1.nameAC[nom],
RESU_INI=RESUI,
RESU_FIN=BIDON,
MAILLAGE_INIT=_MA_N,
INSTANT=last_i,
MAILLAGE_FINAL=_MA_NP1,
MODELE_FINAL=_MO_NP1,
TRAN=(tran_x, tran_y, tran_z))
UTMESS('I',
'COEUR0_3',
valk=(_coeur.position_todamac(_coeur.nameAC[nom]),
_coeurp1.position_todamac(_coeurp1.nameAC[nom])))
break
UTMESS('I', 'COEUR0_2', vali=(indice))
def calcul_Aster(self, val, dX=None):
# ----------------------------------------------------------------------------
# Commun
# ---------------------------------------------------------------------
self.val = val
info = self.INFO
# MACR_RECAL inputs
parametres = self.LIST_PARA
calcul = self.RESU_CALC
experience = self.RESU_EXP
# Current estimation
X0 = val
dX = dX
# Objet Calcul
C = CALCULS_ASTER(
# MACR_RECAL inputs
parametres=parametres,
calcul=calcul,
experience=experience,
LANCEMENT=self.LANCEMENT,
jdc=self.jdc,
)
# Traitement special pour la dynamique (affichage des MAC dans
# l'esclave)
if self.DYNAMIQUE:
C.SetDynamiqueMode(self.DYNAMIQUE, self.graph_mac)
# ----------------------------------------------------------------------------
# ASRUN distribue
# ---------------------------------------------------------------------
if self.LANCEMENT == 'DISTRIBUTION':
# Creation du repertoire temporaire pour l'execution de l'esclave
tmp_macr_recal = self.Creation_Temporaire_Esclave()
# Creation du fichier .export de l'esclave
self.Creation_Fichier_Export_Esclave(tmp_macr_recal)
# Code_Aster installation
if os.environ.has_key('ASTER_ROOT'):
ASTER_ROOT = os.environ['ASTER_ROOT']
else:
import aster
ASTER_ROOT = os.path.join(
aster_core.get_option('repout'), '..')
as_run = os.path.join(ASTER_ROOT, 'bin', 'as_run')
# General
resudir = None
clean = True
NMAX_SIMULT = self.NMAX_SIMULT
# Study
export = self.new_export
C.follow_output = self.follow_output
C.unity_follow = self.unity_follow
# Lancement des calculs
fonctionnelle, gradient = C.run(
# Current estimation
X0,
dX,
# Code_Aster installation
ASTER_ROOT=ASTER_ROOT,
as_run=as_run,
# General
resudir=resudir,
clean=clean,
info=info,
NMAX_SIMULT=NMAX_SIMULT,
# Study
export=export,
)
# ----------------------------------------------------------------------------
# Aiguillage vers INCLUDE
# ---------------------------------------------------------------------
if self.LANCEMENT == 'INCLUSION':
C.UNITE_ESCL = self.UNITE_ESCL
# Lancement des calculs
fonctionnelle, gradient = C.run(
# Current estimation
X0,
dX,
# General
info,
)
# ----------------------------------------------------------------------------
# Sortie
# ---------------------------------------------------------------------
if dX:
self.evaluation_fonction += 1 + len(dX)
else:
self.evaluation_fonction += 1
self.Lcalc = C.Lcalc
if not dX:
return self.Lcalc[0], {}
else:
return fonctionnelle, gradient
def include_materiau_ops(self, EXTRACTION, UNITE_LONGUEUR, INFO, PROL_GAUCHE,
PROL_DROITE, **args):
"""Macro INCLUDE_MATERIAU"""
import aster
from code_aster.Cata.Syntax import _F
from code_aster.Cata.DataStructure import formule
from Utilitai.Utmess import UTMESS
DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU')
self.set_icmd(1)
self.DeclareOut('MAT', self.sd)
fmat = args.get('FICHIER')
if not fmat:
bnmat = ''.join([
args['NOM_AFNOR'], '_', args['TYPE_MODELE'], '_', args['VARIANTE'],
'.', args['TYPE_VALE']
])
repmat = aster_core.get_option("repmat")
fmat = osp.join(repmat, bnmat)
if not osp.exists(fmat):
UTMESS('F', 'FICHIER_1', valk=fmat)
# extraction à une température donnée
extract = EXTRACTION is not None
if extract:
TEMP_EVAL = EXTRACTION['TEMP_EVAL']
keep_compor = lambda compor: compor in EXTRACTION['COMPOR']
else:
TEMP_EVAL = None
keep_compor = lambda compor: True
# définition du prolongement des fonctions
dict_prol = {
'droite': PROL_DROITE,
'gauche': PROL_GAUCHE,
}
context = build_context(UNITE_LONGUEUR, TEMP_EVAL, dict_prol)
# ajout des commandes autorisées
commandes = dict([(cmd, self.get_cmd(cmd)) for cmd in COMMANDES])
context.update(commandes)
context['_F'] = _F
# exécution du catalogue
execfile(fmat, context)
kwcata = context.get(MOTSCLES)
if kwcata is None:
UTMESS('F', 'SUPERVIS2_6', valk=bnmat)
# certains concepts cachés doivent être connus plus tard (au moins les
# objets FORMULE)
to_add = dict([(v.nom, v) for k, v in context.items()
if isinstance(v, formule)])
self.sdprods.extend(to_add.values())
if INFO == 2:
aster.affiche(
'MESSAGE',
" Mots-clés issus du catalogue : \n%s" % pprint.pformat(kwcata))
aster.affiche('MESSAGE',
'Concepts transmis au contexte global :\n%s' % to_add)
# filtre des mots-clés
for mcf, value in kwcata.items():
if not keep_compor(mcf):
del kwcata[mcf]
continue
if type(value) not in (list, tuple):
value = [
value,
]
if type(value) in (list, tuple) and len(value) != 1:
UTMESS('F', 'SUPERVIS2_7', valk=(bnmat, mcf))
for occ in value:
if occ.get(EXTR) in (None, extract):
if occ.get(EXTR) is not None:
del occ[EXTR]
else:
del kwcata[mcf]
MAT = DEFI_MATERIAU(**kwcata)
return 0
dst = os.path.join(tmp_ecrevisse, 'debits')
if os.path.isfile(src):
try:
shutil.copyfile(src, dst)
except Exception, e:
UTMESS('F', 'ECREVISSE0_24', valk=[src, dst])
# print "ERREUR : copyfile %s -> %s" % (src, dst)
# Executable Ecrevisse
if LOGICIEL:
if not os.path.isfile(str(LOGICIEL)):
UTMESS('F', 'ECREVISSE0_13')
else:
chemin_executable = str(LOGICIEL)
else:
chemin_executable = os.path.join(aster_core.get_option('repout'),
'ecrevisse')
# chemin_executable =
# os.path.join(aster_core.get_option('repout'),version,'ecrevisse')
if debug:
print 'chemin_executable:', chemin_executable
# Soit on fait un lien symbolique (incompatible avec certaines
# plate-formes) soit on recopie l'executable
if not os.path.isfile(os.path.join(tmp_ecrevisse, 'ecrevisse')):
try:
os.symlink(chemin_executable,
os.path.join(tmp_ecrevisse, 'ecrevisse'))
except:
UTMESS('A', 'ECREVISSE0_14')
cmd = 'cp ' + chemin_executable + ' ' + \
def Trace(self):
"""Méthode pour 'tracer' l'objet Graph dans un fichier.
Met en page l'entete, la description des courbes et les valeurs selon
le format et ferme le fichier.
"""
g = self.Graph
if self.PILOTE.startswith('INTERACTIF'):
self.NomFich[0] = 'Trace_%s.dat' % time.strftime(
'%y%m%d%H%M%S', time.localtime())
self.Fich[0] = open(self.NomFich[0], 'w')
# initialise le graph
self._FermFich()
nbsets, x0, x1, y0, y1 = IniGrace(self.NomFich[0])
NumSetIni = nbsets + 1
g.SetExtrema(0.05, x0, x1, y0, y1, force=False)
# si Min/Max incohérents
if g.Echelle_X == 'LOG':
g.Grille_X = 10
if g.Min_X < 0.:
if g.BBXmin < 0.:
UTMESS('A', 'GRAPH0_4')
g.Min_X = g.MinP_X
if g.Echelle_Y == 'LOG':
g.Grille_Y = 10
if g.Min_Y < 0.:
if g.BBYmin < 0.:
UTMESS('A', 'GRAPH0_5')
g.Min_Y = g.MinP_Y
if g.NbCourbe < 1:
self._FermFich()
return
# cohérence des valeurs par défaut
if g.Grille_X < 0 or g.Grille_Y < 0:
deltaX = g.Max_X - g.Min_X
deltaY = g.Max_Y - g.Min_Y
g.Grille_X = deltaX / 5.
g.Grille_Y = deltaY / 5.
if deltaX > 4:
g.Grille_X = int(round(g.Grille_X))
if deltaY > 4:
g.Grille_Y = int(round(g.Grille_Y))
if g.Grille_X == 0.:
g.Grille_X = 1.e-6
if g.Grille_Y == 0.:
g.Grille_Y = 1.e-6
# entete
content = self.Entete()
content.append('')
# valeurs
it = -1
for i in range(g.NbCourbe):
dCi = g.Courbe(i)
for k in range(dCi['NbCol'] - 1):
it = it + 1
dCi['NumSet'] = NumSetIni + it
content.extend(self.DescrCourbe(**dCi))
content.append('')
# partie données (.dat)
it = -1
for i in range(g.NbCourbe):
dCi = g.Courbe(i)
for k in range(dCi['NbCol'] - 1):
it = it + 1
content.append('@target g0.s%d' % (NumSetIni + it))
content.append('@type xy')
listX, listY = Tri(g.Tri, lx=dCi['Abs'], ly=dCi['Ord'][k])
for j in range(dCi['NbPts']):
svX = self.DicForm['formR'] % listX[j]
svY = self.DicForm['formR'] % listY[j]
content.append(self.DicForm['formR'] % listX[j] + ' ' +
self.DicForm['formR'] % listY[j])
content.append('&')
content.append('')
# Production du fichier postscript, jpeg ou lancement interactif
pilo = self.PILOTE
if pilo == '':
self._OuvrFich()
self.Fich[0].write('\n'.join(content))
self._FermFich()
else:
xmgr = os.path.join(aster_core.get_option('repout'), 'xmgrace')
nfwrk = self.NomFich[0] + '.wrk'
open(nfwrk, 'w').write('\n'.join(content))
nfhard = self.NomFich[0] + '.hardcopy'
# nom exact du pilote
bg = pilo == 'INTERACTIF_BG'
if pilo == 'POSTSCRIPT':
pilo = 'PostScript'
elif pilo.startswith('INTERACTIF'):
pilo = 'X11'
# ligne de commande
if pilo == 'X11':
lcmde = '%s %s' % (xmgr, nfwrk)
if bg:
lcmde += ' &'
if not os.environ.has_key(
'DISPLAY') or os.environ['DISPLAY'] == '':
os.environ['DISPLAY'] = ':0.0'
UTMESS('I', 'GRAPH0_7')
UTMESS('I', 'GRAPH0_8', valk=os.environ['DISPLAY'])
else:
if os.path.exists(
os.path.join(aster_core.get_option('repout'),
'gracebat')):
xmgr = os.path.join(aster_core.get_option('repout'),
'gracebat')
lcmde = '%s -hdevice %s -hardcopy -printfile %s %s' % (
xmgr, pilo, nfhard, nfwrk)
# appel xmgrace
UTMESS('I', 'EXECLOGICIEL0_8', valk=lcmde)
if not os.path.exists(xmgr):
UTMESS('S', 'EXECLOGICIEL0_6', valk=xmgr)
iret = os.system(lcmde)
if iret == 0 or os.path.exists(nfhard):
if pilo not in ('', 'X11'):
new = open(nfhard, 'r').read()
open(self.NomFich[0], 'a').write(new)
else:
UTMESS('A', 'GRAPH0_9', valk=pilo)
# menage
if self.PILOTE.startswith('INTERACTIF'):
os.remove(self.NomFich[0])
return
def post_mac3coeur_ops(self, **args):
"""Corps principal de la macro de post-traitement de MAC3COEUR"""
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
from math import sqrt
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_TABLE = self.get_cmd('CREA_TABLE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
EXTR_TABLE = self.get_cmd('EXTR_TABLE')
FORMULE = self.get_cmd('FORMULE')
DEFI_FICHIER = self.get_cmd('DEFI_FICHIER')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
datg = aster_core.get_option("repdex")
coeur_factory = CoeurFactory(datg)
self.set_icmd(1)
_RESU = self['RESULTAT']
_typ_coeur = self['TYPE_COEUR']
POST_LAME = self['LAME']
POST_DEF = self['DEFORMATION']
_inst = self['INST']
_TAB_N = self['TABLE']
_table = _TAB_N.EXTR_TABLE()
nameCoeur = _table.para[0]
# et on renomme la colonne qui identifie les assemblages
_table.Renomme(nameCoeur, 'idAC')
_coeur = coeur_factory.get(_typ_coeur)(nameCoeur, _typ_coeur, self, datg)
_coeur.init_from_table(_table,mater=False)
tableCreated = False
self.DeclareOut('__TAB_OUT', self.sd)
# "
# MOT-CLE FACTEUR LAME
# "
if (POST_LAME != None):
valjeuac = {}
valjeucu = {}
post_table = 0
for attr in POST_LAME:
_typ_post = attr['FORMAT']
if (_typ_post == 'TABLE'):
post_table = 1
_formule = FORMULE(NOM_PARA='V8', VALE='1000.*V8')
# formule qui permet d'associer les COOR_X "presque" identiques (suite a
# un calcul LAME)
_indicat = FORMULE(NOM_PARA='COOR_X', VALE='int(10*COOR_X)')
UTMESS('I', 'COEUR0_5')
k = 0
dim = len(_coeur.nomContactCuve)
for name in _coeur.nomContactCuve:
_TAB2 = CREA_TABLE(
RESU=_F(RESULTAT=_RESU, NOM_CHAM='VARI_ELGA', NOM_CMP='V8', GROUP_MA=name, INST=_inst))
_TAB2 = CALC_TABLE(reuse=_TAB2, TABLE=_TAB2,
ACTION=(
_F(OPERATION='FILTRE', NOM_PARA='POINT',
CRIT_COMP='EQ', VALE_I=1),
_F(OPERATION='TRI', NOM_PARA='COOR_X',
ORDRE='CROISSANT'),
_F(OPERATION='OPER',
FORMULE=_formule, NOM_PARA=name),
_F(OPERATION='OPER', FORMULE=_indicat,
NOM_PARA='INDICAT'),
)
)
if (post_table == 1):
# a la premiere occurence, on cree la table qui sera imprimee
# (_TAB3), sinon, on concatene les tables
if k == 0:
_TAB3 = CALC_TABLE(TABLE=_TAB2,
ACTION=(_F(OPERATION='EXTR', NOM_PARA=('COOR_X', 'INDICAT', name))))
else:
_TABTMP = CALC_TABLE(TABLE=_TAB2,
ACTION=(_F(OPERATION='EXTR', NOM_PARA=('INDICAT', name))))
_TAB3 = CALC_TABLE(TABLE=_TAB3,
ACTION=(_F(OPERATION='COMB', TABLE=_TABTMP, NOM_PARA='INDICAT')))
tab2 = _TAB2.EXTR_TABLE()
tab2.Renomme(name, 'P_LAME')
valjeucu[name] = tab2.P_LAME.values()
k = k + 1
UTMESS('I', 'COEUR0_4')
k = 0
dim = len(_coeur.nomContactAssLame)
if dim != 0:
for name in _coeur.nomContactAssLame:
_TAB1 = CREA_TABLE(
RESU=_F(RESULTAT=_RESU, NOM_CHAM='VARI_ELGA', NOM_CMP='V8', GROUP_MA=name, INST=_inst))
_TAB1 = CALC_TABLE(reuse=_TAB1, TABLE=_TAB1,
ACTION=(
_F(OPERATION='FILTRE', NOM_PARA='POINT',
CRIT_COMP='EQ', VALE_I=1),
_F(OPERATION='TRI',
NOM_PARA='COOR_X', ORDRE='CROISSANT'),
_F(OPERATION='OPER',
FORMULE=_formule, NOM_PARA=name),
_F(OPERATION='OPER',
FORMULE=_indicat, NOM_PARA='INDICAT'),
)
)
if (post_table == 1):
_TABTMP = CALC_TABLE(TABLE=_TAB1,
ACTION=(_F(OPERATION='EXTR', NOM_PARA=('INDICAT', name))))
_TAB3 = CALC_TABLE(TABLE=_TAB3,
ACTION=(_F(OPERATION='COMB', TABLE=_TABTMP, NOM_PARA='INDICAT')))
tab1 = _TAB1.EXTR_TABLE()
tab1.Renomme(name, 'P_LAME')
valjeuac[name] = tab1.P_LAME.values()
k = k + 1
valContactCuve = []
valContactAssLame = []
# pour table globale
for name in _coeur.nomContactCuve:
valContactCuve.append(valjeucu[name])
for name in _coeur.nomContactAssLame:
valContactAssLame.append(valjeuac[name])
valContactCuve=N.array(valContactCuve)
valContactAssLame=N.array(valContactAssLame)
nb_grilles = valContactCuve.shape[1]
valQuantile=[70,80,90,95,99]
liste_out=[]
for i in xrange(nb_grilles) :
valContactCuveGrille = valContactCuve[:,i]
valContactAssLameGrille = valContactAssLame[:,i]
valContactGrille = valContactCuveGrille.tolist()
valContactGrille.extend(valContactAssLameGrille)
for quant in valQuantile :
liste_out.append({
'LISTE_R' : stats.scoreatpercentile(valContactCuveGrille,quant),
'PARA' : 'QuanLE_CU_G%d_%d'%(i+1,quant)
})
liste_out.append({
'LISTE_R' : stats.scoreatpercentile(valContactAssLameGrille,quant),
'PARA' : 'QuanLE_AC_G%d_%d'%(i+1,quant)
})
liste_out.append({
'LISTE_R' : stats.scoreatpercentile(valContactGrille,quant),
'PARA' : 'QuanLE_G%d_%d'%(i+1,quant)
})
valContact = valContactCuve.ravel().tolist()
valContact.extend(valContactAssLame.ravel())
for quant in valQuantile :
liste_out.append({
'LISTE_R' : stats.scoreatpercentile(valContactCuve.ravel(),quant),
'PARA' : 'QuanLE_CU_%d'%(quant,)
})
liste_out.append({
'LISTE_R' : stats.scoreatpercentile(valContactAssLame.ravel(),quant),
'PARA' : 'QuanLE_AC_%d'%(quant,)
})
liste_out.append({
'LISTE_R' : stats.scoreatpercentile(valContact,quant),
'PARA' : 'QuanLE_%d'%(quant,)
})
print 'liste_out : ',liste_out
__TAB_OUT = CREA_TABLE(TITRE='RESU_GLOB_'+nameCoeur,
LISTE=liste_out
)
tableCreated = True
for attr in POST_LAME:
_unit = attr['UNITE']
_typ_post = attr['FORMAT']
#DEFI_FICHIER(ACTION='LIBERER', UNITE=_unit)
if (_typ_post == 'GRACE'):
_num_grille = attr['NUME_GRILLE']
_extremum = attr['TYPE_RESU']
if (_extremum == None):
post = _num_grille
texte = 'sur la grille ' + str(post)
else:
post = _extremum
texte = 'sur la valeur ' + post
makeXMGRACEjeu(_unit, post, _coeur, valjeuac, valjeucu)
elif (_typ_post == 'TABLE'):
# liste des parametres a afficher (dans l'ordre)
# Rq : on affiche la premiere occurence de 'COOR_X'
l_para = ['COOR_X', ] + \
_coeur.nomContactAssLame + _coeur.nomContactCuve
IMPR_TABLE(UNITE=_unit, TABLE=_TAB3, NOM_PARA=l_para,FORMAT_R='E12.6',)
# "
# MOT-CLE FACTEUR DEFORMATION
# "
if (POST_DEF != None):
valdefac = {}
valdirYac = {}
valdirZac = {}
valrho = {}
valforme = {}
val_deport_y = {}
val_deport_z = {}
UTMESS('I', 'COEUR0_6')
POSITION = _coeur.get_geom_coeur()
k = 0
dim = len(POSITION)
for name in POSITION:
name_AC_aster = name[0] + '_' + name[1]
_TAB1 = CREA_TABLE(RESU=_F(RESULTAT=_RESU,
NOM_CHAM='DEPL',
INST=_inst,
NOM_CMP=('DY', 'DZ'),
GROUP_MA='GR_' + name_AC_aster)
)
_TAB1 = CALC_TABLE(reuse=_TAB1, TABLE=_TAB1,
ACTION=(
_F(OPERATION='TRI', NOM_PARA='COOR_X',
ORDRE='CROISSANT'),
))
tab1 = _TAB1.EXTR_TABLE()
l_x_tmp = tab1.COOR_X.values()
l_dy_tmp = tab1.DY.values()
l_dz_tmp = tab1.DZ.values()
# on reduit les listes en supprimant les doublons
nb_grilles = len(l_x_tmp) / 4.
assert (nb_grilles == int(nb_grilles))
nb_grilles = int(nb_grilles)
l_x = [l_x_tmp[4 * i] for i in range(nb_grilles)]
l_dy = [l_dy_tmp[4 * i] for i in range(nb_grilles)]
l_dz = [l_dz_tmp[4 * i] for i in range(nb_grilles)]
# on applique la formule des fleches
l_fy = []
l_fz = []
for i in range(nb_grilles):
fy = l_dy[i] - l_dy[0] - (l_dy[-1] - l_dy[0]) / (
l_x[-1] - l_x[0]) * (l_x[i] - l_x[0])
l_fy.append(fy)
fz = l_dz[i] - l_dz[0] - (l_dz[-1] - l_dz[0]) / (
l_x[-1] - l_x[0]) * (l_x[i] - l_x[0])
l_fz.append(fz)
# on applique la formule de Rho
rho = 0.
for i in range(nb_grilles):
for j in range(nb_grilles):
rho = max(
rho, sqrt((l_fy[i] - l_fy[j]) ** 2 + (l_fz[i] - l_fz[j]) ** 2))
# on applique la formule de la norme des fleches
l_fnor = [sqrt(l_fy[i] ** 2 + l_fz[i] ** 2)
for i in range(nb_grilles)]
# on passe en mm
l_fy_mm = [1000. * fy for fy in l_fy]
l_fz_mm = [1000. * fz for fz in l_fz]
l_fnor_mm = [1000. * fnor for fnor in l_fnor]
rho_mm = 1000. * rho
# calcul des formes (important : a partir des fleches en mm )
formeY = PostForme(l_fy_mm, 'DAMAC')
formeZ = PostForme(l_fz_mm, 'DAMAC')
if formeY == formeZ:
forme = '2' + formeY
else:
forme = 'CS'
# creation des dictionnaires
valdefac[name_AC_aster] = l_fnor_mm
valdirYac[name_AC_aster] = l_fy_mm
valdirZac[name_AC_aster] = l_fz_mm
valrho[name_AC_aster] = rho_mm
valforme[name_AC_aster] = [formeY, formeZ, forme]
val_deport_y[name_AC_aster] = (-l_dy[-1] + l_dy[0])*1000.
val_deport_z[name_AC_aster] = (-l_dz[-1] + l_dz[0])*1000.
k = k + 1
l_nom_AC = []
l_cycle = []
l_repere = []
l_def_max = []
l_XG1 = []
l_XG2 = []
l_XG3 = []
l_XG4 = []
l_XG5 = []
l_XG6 = []
l_XG7 = []
l_XG8 = []
l_XG9 = []
l_XG10 = []
l_YG1 = []
l_YG2 = []
l_YG3 = []
l_YG4 = []
l_YG5 = []
l_YG6 = []
l_YG7 = []
l_YG8 = []
l_YG9 = []
l_YG10 = []
l_milieu = []
l_MinX = []
l_MaxX = []
l_CCX = []
l_MinY = []
l_MaxY = []
l_CCY = []
l_formeX = []
l_formeY = []
l_forme = []
l_valdx = []
l_valdy = []
l_T5 = []
l_T6 = []
# combien de grille ?
nbGrille = 0
for idAC in _coeur.collAC.keys() :
AC = _coeur.collAC[idAC]
altitudeGrilles = AC.altitude
if len(altitudeGrilles) > nbGrille :
nbGrille=len(altitudeGrilles)
moyenneRhoParType = {}
moyenneGraviteParType = {}
maxRho=0.
maxRhoParType = {}
listeGravite = []
maxGravite = 0.
maxGraviteParType = {}
maxDeplGrille = [0]*nbGrille
locMaxDeplGrille = [None]*nbGrille
#for name in POSITION:
for idAC in _coeur.collAC.keys() :
AC = _coeur.collAC[idAC]
altitudeGrilles = AC.altitude
name_AC_aster = AC.idAST
#name_AC_aster = name[0] + '_' + name[1]
name_AC_damac = _coeur.position_todamac(name_AC_aster)
cycle = 1
repere = AC.name
def_max = valrho[name_AC_aster]
XG1 = valdirYac[name_AC_aster][1 - 1]
XG2 = valdirYac[name_AC_aster][2 - 1]
XG3 = valdirYac[name_AC_aster][3 - 1]
XG4 = valdirYac[name_AC_aster][4 - 1]
XG5 = valdirYac[name_AC_aster][5 - 1]
XG6 = valdirYac[name_AC_aster][6 - 1]
XG7 = valdirYac[name_AC_aster][7 - 1]
XG8 = valdirYac[name_AC_aster][8 - 1]
# XG9 = valdirYac[name_AC_aster][9 - 1]
# XG10 = valdirYac[name_AC_aster][10 - 1]
YG1 = valdirZac[name_AC_aster][1 - 1]
YG2 = valdirZac[name_AC_aster][2 - 1]
YG3 = valdirZac[name_AC_aster][3 - 1]
YG4 = valdirZac[name_AC_aster][4 - 1]
YG5 = valdirZac[name_AC_aster][5 - 1]
YG6 = valdirZac[name_AC_aster][6 - 1]
YG7 = valdirZac[name_AC_aster][7 - 1]
YG8 = valdirZac[name_AC_aster][8 - 1]
# YG9 = valdirZac[name_AC_aster][9 - 1]
# YG10 = valdirZac[name_AC_aster][10 - 1]
if (_typ_coeur == '900'):
XG9 = 0.
XG10 = 0.
YG9 = 0.
YG10 = 0.
else :
XG9 = valdirYac[name_AC_aster][9 - 1]
XG10 = valdirYac[name_AC_aster][10 - 1]
YG9 = valdirZac[name_AC_aster][9 - 1]
YG10 = valdirZac[name_AC_aster][10 - 1]
XG=[XG1,XG2,XG3,XG4,XG5,XG6,XG7,XG8,XG9,XG10]
YG=[YG1,YG2,YG3,YG4,YG5,YG6,YG7,YG8,YG9,YG10]
posGrille = []
cosGrille = []
for i in xrange(nbGrille) :
posGrille.append(N.array((XG[i],YG[i],altitudeGrilles[i]*1000)))
for i in xrange(nbGrille-2) :
cosGrille.append(compute_cos_alpha(posGrille[i],posGrille[i+1],posGrille[i+2]))
gravite = K_star*N.sum(1.-N.array(cosGrille))
normeDepl = N.sqrt(N.array(XG)**2+N.array(YG)**2)
Milieu = AC.typeAC
MinX = min(valdirYac[name_AC_aster])
MaxX = max(valdirYac[name_AC_aster])
CCX = MaxX - MinX
MinY = min(valdirZac[name_AC_aster])
MaxY = max(valdirZac[name_AC_aster])
CCY = MaxY - MinY
FormeX = valforme[name_AC_aster][0]
FormeY = valforme[name_AC_aster][1]
Forme = valforme[name_AC_aster][2]
valdx = val_deport_y[name_AC_aster]
valdy = val_deport_z[name_AC_aster]
l_nom_AC.append(name_AC_damac)
l_cycle.append(cycle)
l_repere.append(repere)
l_def_max.append(def_max)
try :
moyenneRhoParType[Milieu].append(def_max)
except KeyError :
moyenneRhoParType[Milieu]=[def_max]
if def_max>maxRho :
maxRho=def_max
locMaxRho = name_AC_damac
try :
if def_max>maxRhoParType[Milieu] :
maxRhoParType[Milieu]=def_max
except KeyError :
maxRhoParType[Milieu] = def_max
listeGravite.append(gravite)
try :
moyenneGraviteParType[Milieu].append(gravite)
except KeyError :
moyenneGraviteParType[Milieu]=[gravite]
if gravite>maxGravite :
maxGravite=gravite
locMaxGravite = name_AC_damac
try :
if gravite>maxGraviteParType[Milieu] :
maxGraviteParType[Milieu]=gravite
except KeyError :
maxGraviteParType[Milieu] = gravite
for i in xrange(nbGrille) :
if normeDepl[i] > maxDeplGrille[i] :
maxDeplGrille[i] = normeDepl[i]
locMaxDeplGrille[i] = name_AC_damac
l_XG1.append(XG1)
l_XG2.append(XG2)
l_XG3.append(XG3)
l_XG4.append(XG4)
l_XG5.append(XG5)
l_XG6.append(XG6)
l_XG7.append(XG7)
l_XG8.append(XG8)
l_XG9.append(XG9)
l_XG10.append(XG10)
l_YG1.append(YG1)
l_YG2.append(YG2)
l_YG3.append(YG3)
l_YG4.append(YG4)
l_YG5.append(YG5)
l_YG6.append(YG6)
l_YG7.append(YG7)
l_YG8.append(YG8)
l_YG9.append(YG9)
l_YG10.append(YG10)
l_milieu.append(Milieu)
l_MinX.append(MinX)
l_MaxX.append(MaxX)
l_CCX.append(CCX)
l_MinY.append(MinY)
l_MaxY.append(MaxY)
l_CCY.append(CCY)
l_formeX.append(FormeX)
l_formeY.append(FormeY)
l_forme.append(Forme)
l_valdx.append(valdx)
l_valdy.append(valdy)
l_T5.append(0.)
l_T6.append(0.)
moyenneRhoCoeur = N.mean(N.array(l_def_max))
for typ in moyenneRhoParType.keys() :
moyenneRhoParType[typ] = N.mean(N.array(moyenneRhoParType[typ]))
moyenneGravite = N.mean(N.array(listeGravite))
sigmaGravite = N.sqrt(N.mean((N.array(listeGravite)-moyenneGravite)**2))
for typ in moyenneGraviteParType.keys() :
moyenneGraviteParType[typ] = N.mean(N.array(moyenneGraviteParType[typ]))
liste_out = []
liste_out.append({'LISTE_R' : moyenneRhoCoeur, 'PARA' : 'moyRhoCoeur' })
for typ in moyenneRhoParType.keys() :
liste_out.append({'LISTE_R' : moyenneRhoParType[typ],
'PARA' : 'moyRho'+typ })
liste_out.append({'LISTE_R' : maxRho, 'PARA' : 'maxRhoCoeur' })
for typ in maxRhoParType.keys() :
liste_out.append({'LISTE_R' : maxRhoParType[typ],
'PARA' : 'maxRho'+typ })
liste_out.append({'LISTE_R' : moyenneGravite, 'PARA' : 'moyGravCoeur' })
liste_out.append({'LISTE_R' : maxGravite, 'PARA' : 'maxGravCoeur' })
liste_out.append({'LISTE_R' : sigmaGravite, 'PARA' : 'sigGravCoeur' })
for typ in maxGraviteParType.keys() :
liste_out.append({'LISTE_R' : maxGraviteParType[typ],
'PARA' : 'maxGrav'+typ })
for typ in moyenneGraviteParType.keys() :
liste_out.append({'LISTE_R' : moyenneGraviteParType[typ],
'PARA' : 'moyGrav'+typ })
for i in xrange(2,len(maxDeplGrille)) :
liste_out.append({'LISTE_R' : maxDeplGrille[i-1],
'PARA' : 'maxDeplGrille%i'%i })
liste_out.append({'LISTE_K' : locMaxRho, 'PARA' : 'locMaxRho', 'TYPE_K' : 'K8' })
liste_out.append({'LISTE_K' : locMaxGravite, 'PARA' : 'locMaxGrav', 'TYPE_K' : 'K8' })
for i in xrange(2,len(maxDeplGrille)) :
liste_out.append({'LISTE_K' : locMaxDeplGrille[i-1],
'PARA' : 'locMaxDeplG%i'%i,
'TYPE_K' : 'K8' })
print 'liste_out : ',liste_out
if tableCreated :
tmp_vale = []
tmp_para = []
for el in liste_out :
try :
tmp_vale.append(el['LISTE_R'])
except KeyError :
tmp_vale.append(el['LISTE_K'])
tmp_para.append(el['PARA'])
__TAB_OUT = CALC_TABLE(reuse=__TAB_OUT,TABLE=__TAB_OUT,
ACTION=(_F(OPERATION = 'AJOUT_COLONNE',
NOM_PARA = tmp_para,
VALE = tmp_vale)))
else :
__TAB_OUT = CREA_TABLE(TITRE='RESU_GLOB_'+nameCoeur,
LISTE=liste_out
)
for attr in POST_DEF:
_unit = attr['UNITE']
_typ_post = attr['FORMAT']
#DEFI_FICHIER(ACTION='LIBERER', UNITE=_unit)
if (_typ_post == 'GRACE'):
_num_grille = attr['NUME_GRILLE']
_extremum = attr['TYPE_RESU']
_autre = attr['TYPE_VISU']
if (_extremum == None):
post = _num_grille
else:
post = _extremum
if (_autre == 'AMPLITUDE'):
makeXMGRACEdef_amp(_unit, post, _coeur, valdefac)
elif (_autre == 'MODULE'):
makeXMGRACEdef_mod(_unit, post, _coeur, valdefac)
elif (_autre == 'VECTEUR'):
makeXMGRACEdef_vec(
_unit, post, _coeur, valdefac, valdirYac, valdirZac)
elif (_autre == 'DEFORME'):
name = attr['POSITION']
typeAC = attr['CONCEPTION']
makeXMGRACEdeforme(_unit, name, typeAC, _coeur, valdefac)
elif (_typ_post == 'TABLE'):
_format_standard = attr['FORMAT_R'] == 'STANDARD'
_nom_site = attr['NOM_SITE']
# creation de la table de sortie
_TABOUT = CREA_TABLE(TITRE=_typ_coeur,
LISTE=(
_F(LISTE_K=l_nom_AC, PARA=_nom_site),
_F(LISTE_I=l_cycle, PARA='Cycle'),
_F(LISTE_R=l_T5, PARA='T5'),
_F(LISTE_R=l_T6, PARA='T6'),
_F(LISTE_K=l_repere,
PARA='Repere', TYPE_K='K16'),
_F(LISTE_R=l_def_max, PARA='Ro'),
_F(LISTE_R=l_valdx, PARA='EinfXgg'),
_F(LISTE_R=l_valdy, PARA='EinfYgg'),
_F(LISTE_R=l_XG1, PARA='XG1'),
_F(LISTE_R=l_XG2, PARA='XG2'),
_F(LISTE_R=l_XG3, PARA='XG3'),
_F(LISTE_R=l_XG4, PARA='XG4'),
_F(LISTE_R=l_XG5, PARA='XG5'),
_F(LISTE_R=l_XG6, PARA='XG6'),
_F(LISTE_R=l_XG7, PARA='XG7'),
_F(LISTE_R=l_XG8, PARA='XG8'),
_F(LISTE_R=l_XG9, PARA='XG9'),
_F(LISTE_R=l_XG10, PARA='XG10'),
_F(LISTE_R=l_YG1, PARA='YG1'),
_F(LISTE_R=l_YG2, PARA='YG2'),
_F(LISTE_R=l_YG3, PARA='YG3'),
_F(LISTE_R=l_YG4, PARA='YG4'),
_F(LISTE_R=l_YG5, PARA='YG5'),
_F(LISTE_R=l_YG6, PARA='YG6'),
_F(LISTE_R=l_YG7, PARA='YG7'),
_F(LISTE_R=l_YG8, PARA='YG8'),
_F(LISTE_R=l_YG9, PARA='YG9'),
_F(LISTE_R=l_YG10, PARA='YG10'),
_F(LISTE_K=l_milieu,
PARA='Milieu', TYPE_K='K16'),
_F(LISTE_R=l_MinX, PARA='Min X'),
_F(LISTE_R=l_MaxX, PARA='Max X'),
_F(LISTE_R=l_CCX, PARA='CC X'),
_F(LISTE_R=l_MinY, PARA='Min Y'),
_F(LISTE_R=l_MaxY, PARA='Max Y'),
_F(LISTE_R=l_CCY, PARA='CC Y'),
_F(LISTE_K=l_formeX,
PARA='Forme X'),
_F(LISTE_K=l_formeY,
PARA='Forme Y'),
_F(LISTE_K=l_forme, PARA='Forme'),
)
)
# impression de la table de sortie
if _format_standard :
formt = 'E12.5'
else :
formt = 'F5.1'
IMPR_TABLE(TABLE=_TABOUT,
TITRE='---',
FORMAT_R=formt,
UNITE=_unit,
COMMENTAIRE='',
SEPARATEUR='\t',
FIN_LIGNE='\r\n',
)
def __init__(self, ETAT_INIT, MODELE, CARA_ELEM, CHAM_MATER, COMPORTEMENT,
FONC_PARASOL, EXCIT, OBSERVATION, ARCHIVAGE, COURBE,
CALCUL, AMORTISSEMENT, DOMAINES, INTERFACES, REPE, EXEC, VERS,
INFO, REPE_epx, NOM_RESU, REPE_tmp, NP, RANK, args):
"""
Met toutes les entrées en attributs.
Crée les directives EPX.
Définie les fichiers de sortie.
"""
import aster_core
from Calc_epx.calc_epx_cata import cata_directives
from Calc_epx.calc_epx_struc import DIRECTIVE
if debug:
print 'args_key %s'%args.keys()
# Récuperation des concepts de la base
macro = CONTEXT.get_current_step()
# Résultat initial
# MODELE, CARA_ELEM, CHAM_MATER
self.ETAT_INIT = ETAT_INIT
if ETAT_INIT is not None:
RESULTAT = ETAT_INIT['RESULTAT']
nom_RESU_INIT = RESULTAT.get_name()
# MODELE
iret, ibid, nomsd = aster.dismoi('MODELE', nom_RESU_INIT,
'RESULTAT', 'F')
nomsd = nomsd.strip()
if nomsd[0] == '#':
UTMESS('F', 'PLEXUS_37', valk='MODELE')
self.MODELE = macro.get_concept(nomsd)
# CARA_ELEM
if CARA_ELEM is None :
iret, ibid, nomsd = aster.dismoi('CARA_ELEM', nom_RESU_INIT, 'RESULTAT', 'F')
nomsd = nomsd.strip()
if nomsd[:8] == '#PLUSIEU':
UTMESS('F', 'PLEXUS_37', valk=[nom_RESU_INIT, 'CARA_ELEM'])
elif nomsd[:6] == '#AUCUN':
self.CARA_ELEM = None
else:
self.CARA_ELEM = macro.get_concept(nomsd)
else:
self.CARA_ELEM = CARA_ELEM
UTMESS('A','PLEXUS_53')
# CHAM_MATER
iret, ibid, nomsd = aster.dismoi('CHAM_MATER', nom_RESU_INIT, 'RESULTAT', 'F')
nomsd = nomsd.strip()
if nomsd[:8] == '#PLUSIEU':
UTMESS('F', 'PLEXUS_37', valk=[nom_RESU_INIT, 'CHAM_MATER'])
self.CHAM_MATER = macro.get_concept(nomsd)
else:
self.MODELE = MODELE
self.CARA_ELEM = CARA_ELEM
self.CHAM_MATER = CHAM_MATER
#
# Recherche dans le jdc la création du concept CARA_ELEM
if ( self.CARA_ELEM != None ):
FindEtape = False
self.CARA_ELEM_CONCEPT = self.CARA_ELEM
nomsd = self.CARA_ELEM.get_name()
jdc = CONTEXT.get_current_step().jdc
for UneEtape in jdc.etapes:
if (UneEtape.nom=='AFFE_CARA_ELEM') and (UneEtape.sdnom==nomsd):
self.CARA_ELEM = UneEtape
FindEtape = True
break
#
if ( not FindEtape ):
UTMESS('F', 'PLEXUS_20', valk=[nomsd, 'CARA_ELEM'])
#
else:
self.CARA_ELEM_CONCEPT = None
#
# récuperation du maillage
nom_MODELE = self.MODELE.get_name()
iret, ibid, nomsd = aster.dismoi('NOM_MAILLA', nom_MODELE, 'MODELE', 'F')
nomsd = nomsd.strip()
self.MAILLAGE = macro.get_concept(nomsd)
# Autres entrées
self.FONC_PARASOL = FONC_PARASOL
self.EXCIT = EXCIT
self.OBSERVATION = OBSERVATION
self.ARCHIVAGE = ARCHIVAGE
self.COURBE = COURBE
self.CALCUL = CALCUL
self.DOMAINES = DOMAINES
self.INTERFACES = INTERFACES
self.VERS = VERS
self.INFO = INFO
self.COMPORTEMENT = COMPORTEMENT
self.AMORTISSEMENT = AMORTISSEMENT
self.REPE_epx = REPE_epx
self.NP = NP
self.RANK=RANK
self.REPE_tmp=REPE_tmp
# Commande d'execution de Europlexus
tooldir = aster_core.get_option('repout')
epxExec = EXEC
if not epxExec:
epxExec = os.environ.get('ASTER_EUROPLEXUS')
if epxExec:
UTMESS('I', 'PLEXUS_13', valk=epxExec)
else:
epxExec = osp.join(tooldir, 'europlexus')
self.EXEC = epxExec
# COURBE
if args.has_key('UNITE_COURBE'):
self.UNITE_COURBE = args['UNITE_COURBE']
else:
self.UNITE_COURBE = None
if args.has_key('PAS_INST_COURBE'):
self.PAS_INST_COURBE = args['PAS_INST_COURBE']
else:
self.PAS_INST_COURBE = None
if args.has_key('PAS_NBRE_COURBE'):
self.PAS_NBRE_COURBE = args['PAS_NBRE_COURBE']
else:
self.PAS_NBRE_COURBE = None
if args.has_key('INST_COURBE'):
self.INST_COURBE = args['INST_COURBE']
else:
self.INST_COURBE = None
if args.has_key('NUME_ORDRE_COURBE'):
self.NUME_ORDRE_COURBE = args['NUME_ORDRE_COURBE']
else:
self.NUME_ORDRE_COURBE = None
if args.has_key('TABLE_COURBE'):
self.TABLE_COURBE = args['TABLE_COURBE']
else:
self.TABLE_COURBE = None
# Création des directives EPX
self.epx = {}
for direc in cata_directives:
titre = cata_directives[direc]['TITRE']
type_dir = cata_directives[direc]['TYPE_DIR']
self.epx[direc] = DIRECTIVE(direc, titre, type_dir)
# Nom des fichiers de Europlexus (commande et sorties)
nom_fichiers = {'COMMANDE': 'commandes_%s.epx'%NOM_RESU,
'MAILLAGE': 'commandes_%s.msh'%NOM_RESU,
'SAUV': 'resu_%s.sau'%NOM_RESU,
'MED': 'champ_%s.med'%NOM_RESU,
'PUN': 'courbes_%s.pun'%NOM_RESU,
}
for fic in nom_fichiers.keys():
nom_fic = nom_fichiers[fic]
nom_fichiers[fic] = os.path.join(self.REPE_epx, nom_fic)
self.nom_fichiers = nom_fichiers
# creation du dictionnaire de données complementaires sur les modélisations
self.info_mode_compl = {}