def lire_table_ops(self, UNITE, FORMAT, SEPARATEUR, NUME_TABLE, RENOMME_PARA,
INFO, TITRE, **args):
"""Méthode corps de la macro LIRE_TABLE
"""
import aster
from Utilitai.Utmess import UTMESS, raise_UTMESS
from Utilitai.UniteAster import UniteAster
from Utilitai.TableReader import TableReaderFactory, unique_parameters
ier = 0
# On importe les definitions des commandes a utiliser dans la macro
CREA_TABLE = self.get_cmd('CREA_TABLE')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Lecture de la table dans un fichier d unité logique UNITE
UL = UniteAster()
nomfich = UL.Nom(UNITE)
if not osp.isfile(nomfich):
UTMESS('F', 'FONCT0_41', valk=nomfich)
texte = open(nomfich, 'r').read()
# remet UNITE dans son état initial
UL.EtatInit()
check_para = None
if RENOMME_PARA == "UNIQUE":
check_para = unique_parameters
reader = TableReaderFactory(texte, FORMAT, SEPARATEUR, debug=(INFO == 2))
try:
tab = reader.read(NUME_TABLE, check_para=check_para)
except TypeError, exc:
UTMESS('F', 'TABLE0_45', valk=str(exc))
def configure(self, kwargs):
"""Pre-execution function, read the keywords"""
super(ExecMesher, self).configure(kwargs)
self.uniteAster = UniteAster()
self.fileIn = self.uniteAster.Nom(kwargs['MAILLAGE']['UNITE_GEOM'])
self.fileOut = None
self.format = None
class ExecMesher(ExecProgram):
"""Execute a mesher
fileIn --[ mesher ]--> fileOut --[ LIRE_MAILLAGE ]--> mesh
Additional attributes:
:fileIn: the data file used by the mesher
:fileOut: the file that Code_Aster will read
:format: format of the mesh that will be read by Code_Aster (not the
format of fileOut)
:uniteAster: UniteAster object
"""
def configure(self, kwargs):
"""Pre-execution function, read the keywords"""
super(ExecMesher, self).configure(kwargs)
self.uniteAster = UniteAster()
self.fileIn = self.uniteAster.Nom(kwargs['MAILLAGE']['UNITE_GEOM'])
self.fileOut = None
self.format = None
def cleanUp(self):
"""Cleanup function"""
self.uniteAster.EtatInit()
def post(self):
"""Create the mesh object"""
self.step.DeclareOut('mesh', self.step.sd)
ulMesh = self.uniteAster.Unite(self.fileOut)
assert ulMesh, \
"file '{}' not associated to a logical unit".format(self.fileOut)
mesh = LIRE_MAILLAGE(UNITE=ulMesh,
FORMAT=self.format,
INFO=2 if self.debug else 1)
def read_thyc(coeur, model, unit):
"""Read a file containing THYC results"""
res = None
try:
UL = UniteAster()
fname = UL.Nom(unit)
res = lire_resu_thyc(coeur, model, fname)
finally:
UL.EtatInit()
return res
def crea_sd_mail(self, mailString):
from Utilitai.UniteAster import UniteAster
LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
nomFichierSortie = os.path.join(os.getcwd(), 'maillage.mail')
fproc = open(nomFichierSortie, 'w')
fproc.write(mailString)
fproc.close()
UL = UniteAster()
uniteMail = UL.Libre(action='ASSOCIER', nom=nomFichierSortie)
_MAI = LIRE_MAILLAGE(FORMAT='ASTER', UNITE=uniteMail)
UL.EtatInit(uniteMail)
return _MAI
def __init__(self, initial_dir, **kwargs):
"""Enregistrement des valeurs des mots-clés.
- Comme il n'y a qu'une occurrence de PARAMETRE, cela permet de
remonter tous les mots-clés dans un seul dictionnaire.
- On peut ajouter des vérifications infaisables dans le capy.
- On ajoute des paramètres internes.
"""
# defauts hors du mot-clé PARAMETRE
self._defaults = {
'_INIDIR': initial_dir,
'_WRKDIR': osp.join(initial_dir, 'tmp_miss3d'),
'_NBM_DYN': None,
'_NBM_STAT': None,
'_exec_Miss': False,
'EXCIT_HARMO': None,
'INST_FIN': None,
'PAS_INST': None,
'FICHIER_SOL_INCI': 'NON',
# tâches élémentaires à la demande
'_calc_impe': False,
'_calc_forc': False,
'_hasPC': False,
'_nbPC': 0,
'_nbfreq': 0,
'_auto_first_LT': None,
}
self._keywords = {}
# une seule occurence du mcfact
mcfact = kwargs.get('PARAMETRE')
if mcfact is not None:
mcfact = mcfact[0]
self._keywords.update(mcfact.cree_dict_valeurs(mcfact.mc_liste))
# autres mots-clés
others = kwargs.keys()
others.remove('PARAMETRE')
for key in others + self._defaults.keys():
val = kwargs.get(key)
if val is None:
val = self._defaults.get(key)
self._keywords[key] = val
if self['REPERTOIRE']:
self._keywords['_WRKDIR'] = self['REPERTOIRE']
self.UL = UniteAster()
self.check()
# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
#
# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
# person_in_charge: samuel.geniaut at edf.fr
import aster_core
from mac3coeur_coeur import CoeurFactory
from Utilitai.UniteAster import UniteAster
import numpy as N
import numpy.linalg as LA
from scipy import stats
UL=UniteAster()
K_star = 100000.
def NodePos(coeur,k):
return coeur.get_XYOut('%s_%s'%(k[0],k[1]))
def compute_cos_alpha(G_0,G_1,G_2):
a=G_1-G_0
b=G_2-G_1
cos_alpha_ = N.dot(a,b)/LA.norm(a)/LA.norm(b)
# cos_alpha_ = dotProduct(coorVect(G_0,G_1),coorVect(G_1,G_2))/(norm(G_0,G_1)*norm(G_1,G_2))
return cos_alpha_
def impr_resu_sp_ops(self,
RESULTAT, NUME_ORDRE, INST, LIST_INST,
GROUP_MA, RESU, UNITE, **args):
"""
Visualisation des sous-points pour MED
"""
import os.path as OSP
import numpy as NP
from Utilitai.UniteAster import UniteAster
import string as ST
import tempfile
from code_aster.Cata.Syntax import _F
#
ier = 0
# On importe les définitions des commandes à utiliser dans la macro
DEFI_FICHIER = self.get_cmd('DEFI_FICHIER')
CREA_TABLE = self.get_cmd('CREA_TABLE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
DETRUIRE = self.get_cmd('DETRUIRE')
# La macro compte pour 1 dans la numérotation des commandes
self.set_icmd(1)
# Pas de concept sortant
#
# Extraction des INST, NUME_ORDRE, CHAMP du résultat
Resultemps=RESULTAT.LIST_PARA()['INST']
Resulordre=RESULTAT.LIST_PARA()['NUME_ORDRE']
ResuName = RESULTAT.nom
#
# lestemps : les temps d'extraction des champs
if ( INST != None ):
lestempsextrac = INST
elif ( LIST_INST != None ):
lestempsextrac = LIST_INST.Valeurs()
#
# Fabrique de list_numeordre_instant = [ (nume_ordre, temps), ... ]
if ( NUME_ORDRE != None ):
tmp = []
for nume in NUME_ORDRE:
if ( nume in Resulordre ):
indx = Resulordre.index( nume )
tmp.append( (Resulordre[indx],Resultemps[indx]) )
else:
valk = ( ResuName, )
vali = ( nume,)
UTMESS('F','IMPRRESUSP_1', valk=valk, vali=vali)
list_numeordre_instant = NP.array( tmp )
elif ( INST != None or LIST_INST != None ):
tmp = []
for inst in lestempsextrac:
indx = DedansListe( inst, Resultemps, precision=1.0E-08 )
if ( indx >= 0 ):
tmp.append( (Resulordre[indx],Resultemps[indx]) )
else:
valk = ( ResuName, )
valr = ( inst, )
UTMESS('F','IMPRRESUSP_2', valk=valk, valr=valr)
list_numeordre_instant = NP.array( tmp )
else:
list_numeordre_instant = NP.transpose(NP.array([Resulordre , Resultemps]))
# Triage suivant les nume_ordre croissant
list_numeordre_instant[list_numeordre_instant[:,0].argsort()]
# Les champs et leur composantes
Resulchamp=RESULTAT.LIST_CHAMPS()
Resulcompo=RESULTAT.LIST_NOM_CMP()
#
LesChampsComposantes = []
motclef = RESU.List_F()
for ii in range(len(motclef)):
mclf = motclef[ii]
nom_cham = mclf['NOM_CHAM']
nom_cmp = mclf['NOM_CMP']
# Champ dans le RESULTAT ?
if ( not nom_cham in Resulchamp.keys() ):
valk = ( ResuName, nom_cham )
UTMESS('F','IMPRRESUSP_3', valk=valk)
# Composante dans le CHAMP ?
for ncmp in nom_cmp:
if ( not ncmp in Resulcompo[nom_cham] ):
valk = ( ResuName, nom_cham, ncmp )
UTMESS('F','IMPRRESUSP_4', valk=valk)
# nume_ordre existe pour le champ ?
for nume,inst in list_numeordre_instant:
if ( not int(nume) in Resulchamp[nom_cham] ):
valk = ( ResuName, nom_cham )
vali = ( nume, )
valr = ( inst, )
UTMESS('F','IMPRRESUSP_5', valk=valk, vali=vali, valr=valr)
#
LesChampsComposantes.append( ( ii+1, nom_cham , list(nom_cmp) ) )
#
Group_MA = list( GROUP_MA )
# création du répertoire
RepertoireSauve = tempfile.mkdtemp( prefix='Visu_Sous_Point', dir='.' )
# On commence la macro
LignepvdData = {}
for UnChamp in LesChampsComposantes:
iocc, Nom_Champ, LNom_Cmp = UnChamp
#
# Liste informations : [ (Fichier Resultat Champ Composante Nume_Ordre instant), .... ]
clef = '%s-%s-%04d' % (ResuName, Nom_Champ, iocc)
LignepvdData[clef] = []
# Boucle sur les numéros d'ordre
for nume_ordre_instant in list_numeordre_instant:
nordre, instant = nume_ordre_instant
nume_ordre = int( nordre )
Nom_Fic= '%s-%04d' % (clef ,nume_ordre)
#
LignepvdData[clef].append( (Nom_Fic, ResuName, Nom_Champ, LNom_Cmp, nume_ordre, instant) )
#
__unit = DEFI_FICHIER(ACTION='ASSOCIER', FICHIER=OSP.join(RepertoireSauve,'%s.table' % Nom_Fic), ACCES='NEW', TYPE='ASCII')
__tbresu=CREA_TABLE(
RESU=_F(RESULTAT=RESULTAT, NOM_CHAM=Nom_Champ.upper() , NUME_ORDRE=nume_ordre, GROUP_MA=Group_MA, NOM_CMP=LNom_Cmp,),)
#
# Vérification que toutes les composantes existent
NomColonnes = __tbresu.get_nom_para()
for icmp in ['SOUS_POINT','COOR_X','COOR_Y','COOR_Z'] + LNom_Cmp:
if ( not icmp in NomColonnes ):
UTMESS('F','IMPRRESUSP_6', valk=(icmp,Nom_Champ.upper()))
#
IMPR_TABLE(FORMAT='TABLEAU', UNITE=__unit, TABLE=__tbresu, NOM_PARA=['COOR_X','COOR_Y','COOR_Z'] + LNom_Cmp,)
DEFI_FICHIER(ACTION='LIBERER', UNITE=__unit)
DETRUIRE(CONCEPT=_F(NOM=__tbresu,), INFO=1,)
DETRUIRE(CONCEPT=_F(NOM=__unit,), INFO=1,)
#
# Fichier de l'unité logique UNITE
UL = UniteAster()
nomfich = UL.Nom(UNITE)
# Fabrication du pvd et des vtu dans un fichier "tgz"
Table2vtu(nomfich,RepertoireSauve,LignepvdData)
# Remet UNITE dans son état initial
UL.EtatInit()
return ier
class MISS_PARAMETER(object):
"""Stocke les paramètres nécessaires au calcul à partir des mots-clés.
"""
def __init__(self, initial_dir, **kwargs):
"""Enregistrement des valeurs des mots-clés.
- Comme il n'y a qu'une occurrence de PARAMETRE, cela permet de
remonter tous les mots-clés dans un seul dictionnaire.
- On peut ajouter des vérifications infaisables dans le capy.
- On ajoute des paramètres internes.
"""
# defauts hors du mot-clé PARAMETRE
self._defaults = {
'_INIDIR': initial_dir,
'_WRKDIR': osp.join(initial_dir, 'tmp_miss3d'),
'_NBM_DYN': None,
'_NBM_STAT': None,
'_exec_Miss': False,
'EXCIT_HARMO': None,
'INST_FIN': None,
'PAS_INST': None,
'FICHIER_SOL_INCI': 'NON',
# tâches élémentaires à la demande
'_calc_impe': False,
'_calc_forc': False,
'_hasPC': False,
'_nbPC': 0,
'_nbfreq': 0,
'_auto_first_LT': None,
}
self._keywords = {}
# une seule occurence du mcfact
mcfact = kwargs.get('PARAMETRE')
if mcfact is not None:
mcfact = mcfact[0]
self._keywords.update(mcfact.cree_dict_valeurs(mcfact.mc_liste))
# autres mots-clés
others = kwargs.keys()
others.remove('PARAMETRE')
for key in others + self._defaults.keys():
val = kwargs.get(key)
if val is None:
val = self._defaults.get(key)
self._keywords[key] = val
if self['REPERTOIRE']:
self._keywords['_WRKDIR'] = self['REPERTOIRE']
self.UL = UniteAster()
self.check()
def __del__(self):
"""A la destruction."""
self.UL.EtatInit()
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 __iter__(self):
"""Itérateur simple sur le dict des mots-clés"""
return iter(self._keywords)
def __getitem__(self, key):
return self._keywords[key]
def __setitem__(self, key, value):
ASSERT(self.get(key) is None)
self.set(key, value)
def set(self, key, value):
self._keywords[key] = value
def get(self, key):
return self._keywords.get(key)
def __repr__(self):
return pprint.pformat(self._keywords)
def lire_inte_spec_ops(self,
UNITE=None,
FORMAT=None,
FORMAT_C=None,
NOM_PARA=None,
NOM_RESU=None,
INTERPOL=None,
PROL_DROITE=None,
PROL_GAUCHE=None,
TITRE=None,
INFO=None,
**args):
ier = 0
from code_aster.Cata.Syntax import _F
import os
from math import cos, sin, sqrt
from Utilitai.Utmess import UTMESS
from Utilitai.UniteAster import UniteAster
# On importe les definitions des commandes a utiliser dans la macro
DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
DEFI_INTE_SPEC = self.get_cmd('DEFI_INTE_SPEC')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
nompro = 'LIRE_INTE_SPEC'
# Lecture de la fonction dans un fichier d unité logique UNITE
UL = UniteAster()
nomfich = UL.Nom(UNITE)
if not os.path.isfile(nomfich):
UTMESS('F', 'SPECTRAL0_4', valk=nomfich)
file = open(nomfich, 'r')
texte = file.read()
file.close()
if FORMAT == 'IDEAS':
# fabrication d'une liste de data sets 58
list_fonc = texte.split(' -1')
j = 0
for ind_fonc in range(len(list_fonc)):
try:
tmp = list_fonc[j].split()
if tmp[0] == '58':
j = j + 1
else:
list_fonc.pop(j)
except IndexError:
list_fonc.pop(j)
nb_fonc = len(list_fonc)
if nb_fonc == 0:
UTMESS('F', 'SPECTRAL0_9')
l_fonc = []
l_noi = []
l_noj = []
l_cmpi = []
l_cmpj = []
for ind_fonc in range(nb_fonc):
# Extraction des en-tete : nom des noeuds, composantes (=ddl), de
# leur sens
fonc = list_fonc[ind_fonc]
ligne = fonc.split('\n')
record_6 = ligne[7].split()
if record_6[0] != '2' and record_6[0] != '3' and record_6[0] != '9':
UTMESS('F', 'SPECTRAL0_10')
nono = record_6[4] # nom du noeud
nuno = int(record_6[5]) # numero
ddlno = float(record_6[6]) / 10 # DDL
noref = record_6[7] # nom du noeud de reference
nuref = int(record_6[8]) # numero
ddlref = float(record_6[9]) / 10 # DDL
# On traduit les ddl "chiffres" en vrais ddl. Avec le sens des
# capteurs.
sens_no, ddl_no = comp(ddlno)
sens_ref, ddl_ref = comp(ddlref)
signe = sens_no * sens_ref
# On ne garde que la triang sup de la matrice inter-spectrale
crit1 = nuno + ddlno
crit2 = nuref + ddlref
if crit1 > crit2:
continue
record_7 = ligne[8].split()
nbpairs = int(record_7[1])
if record_7[2] == 0:
UTMESS('F', 'SPECTRAL0_11')
f0 = float(record_7[3])
df = float(record_7[4])
# Liste des valeurs
liste = fonc.split('\n')
valeurs = ''
for ind in range(13):
liste.pop(0)
for ind_lign in range(len(liste)):
valeurs = valeurs + liste[ind_lign]
tmp = valeurs.split()
valeurs = [signe * float(tmp[ind]) for ind in range(len(tmp))]
liste = []
freq = f0
for ind_freq in range(nbpairs):
liste.append(freq)
liste.append(valeurs[2 * ind_freq])
liste.append(valeurs[2 * ind_freq + 1])
freq = freq + df
# création de la fonction ASTER :
_fonc = DEFI_FONCTION(
NOM_PARA=NOM_PARA,
NOM_RESU=NOM_RESU,
PROL_DROITE=PROL_DROITE,
PROL_GAUCHE=PROL_GAUCHE,
INTERPOL=INTERPOL,
INFO=INFO,
TITRE=TITRE,
VALE_C=liste,
)
l_fonc.append(_fonc) # Liste des fonctions
l_noi.append('N' + str(nuno)) # Liste des noeuds de mesure
l_cmpi.append(ddl_no) # DDL associes
l_noj.append('N' + str(nuref)) # Liste des noeuds de ref
l_cmpj.append(ddl_ref) # DDL associes
# Verification a posteriori de la dimension de l'inter-spectre
tmp = 0.5 * (-1 + sqrt(1 + 8 * len(l_fonc)))
dim = int(tmp)
nb_fonc = dim * (dim + 1) / 2
if dim != tmp:
UTMESS('F', 'SPECTRAL0_6')
mcfact = []
for i in range(dim * (dim + 1) / 2):
mcfact.append(
_F(
NOEUD_I=l_noi[i],
NOM_CMP_I=l_cmpi[i],
NOEUD_J=l_noj[i],
NOM_CMP_J=l_cmpj[i],
FONCTION=l_fonc[i],
))
self.DeclareOut('inte_out', self.sd)
inte_out = DEFI_INTE_SPEC(
PAR_FONCTION=mcfact,
TITRE=TITRE,
)
elif FORMAT == 'ASTER':
list_fonc = texte.split('FONCTION_C')
entete = list_fonc.pop(0)
try:
entete = entete[entete.index('DIM'):]
dim = int(entete[entete.index('=') + 1:entete.index('\n')])
except ValueError:
UTMESS('F', 'SPECTRAL0_5')
if len(list_fonc) != (dim * (dim + 1) / 2):
UTMESS('F', 'SPECTRAL0_6')
nume_i = []
nume_j = []
l_fonc = []
for i in range(dim * (dim + 1) / 2):
numi = list_fonc[i][list_fonc[i].index('I =') + 3:]
numi = numi[:numi.index('\n')]
nume_i.append(int(numi))
numj = list_fonc[i][list_fonc[i].index('J =') + 3:]
numj = numj[:numj.index('\n')]
nume_j.append(int(numj))
try:
vale_fonc = list_fonc[i][list_fonc[i].index('VALEUR =\n') +
9:list_fonc[i].index('FINSF\n')]
vale_fonc = vale_fonc.replace('\n', ' ')
vale_fonc = map(float, vale_fonc.split())
except ValueError:
UTMESS('F', 'SPECTRAL0_7')
liste = []
if FORMAT_C == 'REEL_IMAG':
liste = vale_fonc
elif FORMAT_C == 'MODULE_PHASE':
for i in range(len(vale_fonc) / 3):
module = vale_fonc[3 * i + 1]
phase = vale_fonc[3 * i + 2]
liste = liste + \
[vale_fonc[3 * i], module * cos(
phase), module * sin(phase)]
# création de la fonction ASTER :
_fonc = DEFI_FONCTION(
NOM_PARA=NOM_PARA,
NOM_RESU=NOM_RESU,
PROL_DROITE=PROL_DROITE,
PROL_GAUCHE=PROL_GAUCHE,
INTERPOL=INTERPOL,
INFO=INFO,
TITRE=TITRE,
VALE_C=liste,
)
l_fonc.append(_fonc)
nume_ib = []
nume_jb = []
for i in range(dim):
for j in range(i, dim):
nume_ib.append(i + 1)
nume_jb.append(j + 1)
if nume_i != nume_ib or nume_j != nume_jb:
UTMESS('F', 'SPECTRAL0_3')
mcfact = []
for i in range(dim * (dim + 1) / 2):
mcfact.append(
_F(
NUME_ORDRE_I=nume_i[i],
NUME_ORDRE_J=nume_j[i],
FONCTION=l_fonc[i],
))
self.DeclareOut('inte_out', self.sd)
inte_out = DEFI_INTE_SPEC(
PAR_FONCTION=mcfact,
TITRE=TITRE,
)
else:
# mot-clé != 'ASTER', ou 'IDEAS' => ERREUR !
UTMESS('F', 'SPECTRAL0_12')
# remet UNITE dans son état initial
UL.EtatInit()
return ier
def impr_table_ops(self, FORMAT, TABLE, INFO, **args):
"""
Macro IMPR_TABLE permettant d'imprimer une table dans un fichier.
Erreurs<S> dans IMPR_TABLE pour ne pas perdre la base.
"""
macro = 'IMPR_TABLE'
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
from Utilitai.UniteAster import UniteAster
from Utilitai.utils import fmtF2PY
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
DETRUIRE = self.get_cmd('DETRUIRE')
RECU_FONCTION = self.get_cmd('RECU_FONCTION')
#----------------------------------------------
# 0. Traitement des arguments, initialisations
# unité logique des fichiers réservés
ul_reserve = (8, )
UL = UniteAster()
# 0.1. Fichier
nomfich = None
if args['UNITE'] and args['UNITE'] <> 6:
nomfich = UL.Nom(args['UNITE'])
if nomfich and os.path.exists(nomfich) and os.stat(nomfich).st_size <> 0:
if FORMAT == 'XMGRACE':
UTMESS('A', 'TABLE0_6', valk=nomfich)
# 0.2. Création des dictionnaires des FILTRES
Filtre = []
if args['FILTRE']:
for Fi in args['FILTRE']:
dF = Fi.cree_dict_valeurs(Fi.mc_liste)
for mc in dF.keys():
if dF[mc] == None:
del dF[mc]
Filtre.append(dF)
# format pour l'impression des filtres
form_filtre = '\nFILTRE -> NOM_PARA: %-16s CRIT_COMP: %-4s VALE: %s'
# 0.3. Création de la liste des tables
# on conserve la liste même si aujourd'hui, on n'en imprime qu'une à la
# fois
ltab = [[TABLE.EXTR_TABLE(), TABLE]]
# 0.4.1. liste des paramètres à conserver
nom_para = ltab[0][0].para
if args['NOM_PARA']:
nom_para = args['NOM_PARA']
if not type(nom_para) in (list, tuple):
nom_para = [
nom_para,
]
# 0.4.2. Traiter le cas des UL réservées
if args['UNITE'] and args['UNITE'] in ul_reserve:
UL.Etat(args['UNITE'], etat='F')
#----------------------------------------------
# Boucle sur les tables
for tab, sdtab in ltab:
# ----- 1. Infos de base
if INFO == 2:
print 'IMPRESSION DE LA TABLE : %s' % sdtab.get_name()
if args['TITRE']:
# tab.titr = os.linesep.join(args['TITRE'] + (tab.titr, ))
tab.titr = args['TITRE'] + tab.titr
# ----- 2. Filtres
for Fi in Filtre:
col = getattr(tab, Fi['NOM_PARA'])
# peu importe le type
opts = [
Fi[k] for k in ('VALE', 'VALE_I', 'VALE_C', 'VALE_K')
if Fi.has_key(k)
]
kargs = {}
for k in ('CRITERE', 'PRECISION'):
if Fi.has_key(k):
kargs[k] = Fi[k]
tab = tab & (getattr(col, Fi['CRIT_COMP'])(*opts, **kargs))
# trace l'operation dans le titre
# if FORMAT in ('TABLEAU','ASTER'):
tab.titr += form_filtre % (Fi['NOM_PARA'], Fi['CRIT_COMP'],
' '.join([str(v) for v in opts]))
# ----- 3. Tris
if args['TRI']:
# une seule occurence de TRI
T0 = args['TRI'][0]
dT = T0.cree_dict_valeurs(T0.mc_liste)
tab.sort(CLES=dT['NOM_PARA'], ORDRE=dT['ORDRE'])
# ----- 4. Impression
# vérification des paramètres
for p in nom_para:
if not p in tab.para:
UTMESS('A', 'TABLE0_7', valk=p)
# sélection des paramètres et suppression des colonnes vides
timp = tab.SansColonneVide(nom_para)
# passage des mots-clés de mise en forme à la méthode Impr
kargs = args.copy()
kargs.update({
'FORMAT': FORMAT,
'FICHIER': nomfich,
'dform': {},
})
# pour l'impression des fonctions
kfonc = {
'FORMAT': FORMAT,
'FICHIER': nomfich,
}
# 4.1. au format TABLEAU
if FORMAT == 'TABLEAU':
# surcharge par les formats de l'utilisateur
kargs['dform'] = {
'chead': args.get('DEBUT_TABLE'), # None est traité par Table
'cfoot': args['FIN_TABLE'],
'csep': args['SEPARATEUR'],
'ccom': args['COMMENTAIRE'],
'ccpara': args['COMM_PARA'],
'cdeb': args['DEBUT_LIGNE'],
'cfin': args['FIN_LIGNE'],
}
# 4.2. au format AGRAF
elif FORMAT == 'AGRAF':
kargs['dform'] = {'formR': '%12.5E'}
kfonc['FORMAT'] = 'TABLEAU'
# 4.3. au format XMGRACE et dérivés
elif FORMAT == 'XMGRACE':
kargs['dform'] = {'formR': '%.8g'}
kargs['PILOTE'] = args['PILOTE']
kfonc['PILOTE'] = args['PILOTE']
# 4.4. format spécifié dans les arguments
if args['FORMAT_R']:
kargs['dform'].update({'formR': fmtF2PY(args['FORMAT_R'])})
# 4.5. regroupement par paramètre : PAGINATION
if args['PAGINATION']:
l_ppag = args['PAGINATION']
if not type(l_ppag) in (list, tuple):
l_ppag = [
l_ppag,
]
kargs['PAGINATION'] = [p for p in l_ppag if p in nom_para]
l_para_err = [p for p in l_ppag if not p in nom_para]
if len(l_para_err) > 0:
UTMESS('A', 'TABLE0_8', valk=l_para_err)
timp.Impr(**kargs)
# ----- 5. IMPR_FONCTION='OUI'
if args['IMPR_FONCTION'] == 'OUI':
# cherche parmi les cellules celles qui contiennent un nom de
# fonction
dfon = []
p_extr = set(['FONCTION', 'FONCTION_C'])
p_extr.intersection_update(timp.para)
if len(p_extr) > 0:
# on réduit timp aux colonnes FONCTION et FONCTION_C
textr = timp.__getitem__(list(p_extr))
for row in textr:
for par, cell in row.items():
if type(cell) in (str, unicode):
cell = cell.strip()
if aster.getvectjev('%-19s.PROL' % cell) != None:
dfon.append(['%-19s' % cell, par])
# impression des fonctions trouvées
for f, par in dfon:
__fonc = RECU_FONCTION(
TABLE=sdtab,
FILTRE=_F(
NOM_PARA=par,
VALE_K=f,
),
NOM_PARA_TABL=par,
TITRE='Fonction %s' % f,
)
__fonc.Trace(**kfonc)
DETRUIRE(
CONCEPT=_F(NOM=(__fonc, ), ),
INFO=1,
)
# 99. Traiter le cas des UL réservées
UL.EtatInit()
return ier
def macr_lign_coupe_ops(self, RESULTAT, CHAM_GD, UNITE_MAILLAGE, LIGN_COUPE,
NOM_CHAM, MODELE, **args):
"""
Ecriture de la macro MACR_LIGN_COUPE
"""
from code_aster.Cata.Syntax import _F
from Noyau.N_utils import AsType
import aster
import math
from Utilitai.UniteAster import UniteAster
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
ier = 0
# On importe les definitions des commandes a utiliser dans la macro
LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
DEFI_GROUP = self.get_cmd('DEFI_GROUP')
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
CREA_TABLE = self.get_cmd('CREA_TABLE')
CREA_RESU = self.get_cmd('CREA_RESU')
COPIER = self.get_cmd('COPIER')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
#
MasquerAlarme('ALGORITH12_43')
MasquerAlarme('CALCULEL2_63')
MasquerAlarme('CALCULEL2_64')
MasquerAlarme('MODELISA5_53')
MasquerAlarme('MODELE1_58')
MasquerAlarme('MODELE1_63')
MasquerAlarme('MODELE1_64')
mcORDR = {}
l_mode_meca_sans_modele = False
if RESULTAT != None:
if args['NUME_ORDRE'] != None:
mcORDR['NUME_ORDRE'] = args['NUME_ORDRE']
elif args['NUME_MODE'] != None:
mcORDR['NUME_MODE'] = args['NUME_MODE']
elif args['LIST_ORDRE'] != None:
mcORDR['LIST_ORDRE'] = args['LIST_ORDRE']
elif args['INST'] != None:
mcORDR['INST'] = args['INST']
elif args['INST'] != None:
mcORDR['INST'] = args['INST']
elif args['LIST_INST'] != None:
mcORDR['LIST_INST'] = args['LIST_INST']
else:
mcORDR['TOUT_ORDRE'] = 'OUI'
nomresu = RESULTAT.nom
type_resu = AsType(RESULTAT).__name__
iret, ibid, n_modele = aster.dismoi('MODELE', nomresu, 'RESULTAT', 'F')
n_modele = n_modele.strip()
if n_modele in ('', '#AUCUN'):
if MODELE == None:
if (type_resu != 'mode_meca'):
UTMESS('F', 'POST0_9', valk=nomresu)
# si le résultat en entrée est un mode_meca et qu'il ne contient pas de modèle (il est obtenu par sous-structuration, par exemple)
# on passe le message fatal et on récupérera directement le
# maillage (ou squelette)
else:
l_mode_meca_sans_modele = True
UTMESS('I', 'POST0_23', valk=nomresu)
else:
n_modele = MODELE.nom
iret, ibid, l_mailla = aster.dismoi(
'NOM_MAILLA', nomresu, 'RESULTAT', 'F')
elif CHAM_GD != None:
mcORDR['TOUT_ORDRE'] = 'OUI'
if MODELE == None:
UTMESS('F', 'POST0_10')
else:
n_modele = MODELE.nom
# récupération de la grandeur du champ
n_cham = CHAM_GD.nom
catagd = aster.getvectjev("&CATA.GD.NOMGD")
desc = aster.getvectjev('%-19s.DESC' % n_cham)
if desc != None:
nomgd = catagd[desc[0] - 1]
else:
celd = aster.getvectjev('%-19s.CELD' % n_cham)
nomgd = catagd[celd[0] - 1]
# détermination du type de résultat à créer
if nomgd[:6] == 'TEMP_R':
TYPE_RESU = 'EVOL_THER'
if not NOM_CHAM:
NOM_CHAM = 'TEMP'
elif nomgd[:6] == 'DEPL_R':
TYPE_RESU = 'EVOL_ELAS'
if not NOM_CHAM:
NOM_CHAM = 'DEPL'
elif nomgd[:6] == 'NEUT_R':
TYPE_RESU = 'EVOL_VARC'
if not NOM_CHAM:
NOM_CHAM = 'NEUT'
elif nomgd[:6] == 'EPSI_R':
TYPE_RESU = 'EVOL_ELAS'
elif nomgd[:6] == 'VAR2_R':
TYPE_RESU = 'EVOL_NOLI'
elif nomgd[:6] == 'VARI_R':
TYPE_RESU = 'EVOL_NOLI'
elif nomgd[:6] == 'SIEF_R':
if not NOM_CHAM:
TYPE_RESU = 'EVOL_ELAS'
NOM_CHAM = 'DEPL'
elif NOM_CHAM[:4] == 'SIGM':
TYPE_RESU = 'EVOL_ELAS'
elif NOM_CHAM[:4] == 'SIEF':
TYPE_RESU = 'EVOL_NOLI'
else:
assert 0, 'grandeur imprevue : ' + nomgf
# création d'un concept résultat à partir du champ CHAM_GD
__resuch = CREA_RESU(OPERATION='AFFE',
NOM_CHAM=NOM_CHAM, TYPE_RESU=TYPE_RESU,
AFFE=_F(CHAM_GD=CHAM_GD, INST=0.),)
RESULTAT = __resuch
iret, ibid, l_mailla = aster.dismoi('NOM_MAILLA', n_cham, 'CHAMP', 'F')
# Maillage sur lequel s'appuie le résultat à projeter
n_mailla = l_mailla.strip()
# le maillage est-il 2D ou 3D ?
iret, dime, kbid = aster.dismoi('DIM_GEOM', n_mailla, 'MAILLAGE', 'F')
collgrma = aster.getcolljev(n_mailla.ljust(8) + '.GROUPEMA')
typma = aster.getvectjev(n_mailla.ljust(8) + '.TYPMAIL')
connex = aster.getcolljev(n_mailla.ljust(8) + '.CONNEX')
ltyma = aster.getvectjev("&CATA.TM.NOMTM")
lignes = []
groups = []
arcs = []
minidim = dime
for m in LIGN_COUPE:
if m['TYPE'] == 'SEGMENT':
lignes.append((m['COOR_ORIG'], m['COOR_EXTR'], m['NB_POINTS']))
minidim = min(minidim, len(m['COOR_ORIG']), len(m['COOR_EXTR']))
if minidim != dime:
UTMESS('F', 'POST0_11')
elif m['TYPE'] == 'ARC':
minidim = min(minidim, len(m['COOR_ORIG']), len(m['CENTRE']))
if minidim != dime:
UTMESS('F', 'POST0_11')
if dime == 2:
arcs.append(
(m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'],))
elif dime == 3:
if str(m['DNOR']) == 'None':
UTMESS('F', 'POST0_12')
arcs.append(
(m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'], m['DNOR']))
elif m['TYPE'] == 'GROUP_NO':
ngrno = m['GROUP_NO'].ljust(24)
collgrno = aster.getcolljev(n_mailla.ljust(8) + '.GROUPENO')
if ngrno not in collgrno.keys():
UTMESS('F', 'POST0_13', valk=[ngrno, n_mailla])
grpn = collgrno[ngrno]
l_coor_group = [ngrno, ]
for node in grpn:
l_coor_group.append(
aster.getvectjev(n_mailla.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3))
groups.append(l_coor_group)
elif m['TYPE'] == 'GROUP_MA':
ngrma = m['GROUP_MA'].ljust(24)
if ngrma not in collgrma.keys():
UTMESS('F', 'POST0_14', valk=[ngrma, n_mailla])
grpm = collgrma[ngrma]
for ma in grpm:
if ltyma[typma[ma - 1] - 1][:3] != 'SEG':
nomma = aster.getvectjev(n_mailla.ljust(8) + '.NOMMAI')
UTMESS('F', 'POST0_15', valk=[ngrma, nomma[ma - 1]])
__mailla = COPIER(CONCEPT=m['MAILLAGE'])
m2 = m.cree_dict_valeurs(m.mc_liste)
argsup = {}
if m2.get('GROUP_NO_ORIG'):
argsup['GROUP_NO_ORIG'] = m2.get('GROUP_NO_ORIG')
if m2.get('GROUP_NO_EXTR'):
argsup['GROUP_NO_EXTR'] = m2.get('GROUP_NO_EXTR')
if m2.get('NOEUD_ORIG'):
argsup['NOEUD_ORIG'] = m2.get('NOEUD_ORIG')
if m2.get('NOEUD_EXTR'):
argsup['NOEUD_EXTR'] = m2.get('NOEUD_EXTR')
if m2.get('VECT_ORIE'):
argsup['VECT_ORIE'] = m2.get('VECT_ORIE')
__mailla = DEFI_GROUP(reuse=__mailla, MAILLAGE=__mailla,
DETR_GROUP_NO=_F(NOM=str(m['GROUP_MA'])),
CREA_GROUP_NO=_F(OPTION='NOEUD_ORDO', NOM=str(m['GROUP_MA']),
GROUP_MA=m['GROUP_MA'], ORIGINE='SANS', **argsup))
collgrno = aster.getcolljev(__mailla.nom.ljust(8) + '.GROUPENO')
grpn = collgrno[str(m['GROUP_MA']).ljust(24)]
l_coor_group = [ngrma, ]
for node in grpn:
l_coor_group.append(
aster.getvectjev(n_mailla.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3))
groups.append(l_coor_group)
if arcs != [] and (lignes != [] or groups != []):
UTMESS('F', 'POST0_16')
# Création du maillage des NB_POINTS segments entre COOR_ORIG et COOR_EXTR
# ainsi que des segments reliant les noeuds issus des group_no demandés
# par appel au script python crea_mail_lig_coup
# le maillage est ensuite recopié dans l unité logique UNITE_MAILLAGE
resu_mail, arcgma, angles, nbno = crea_mail_lig_coup(
dime, lignes, groups, arcs)
UL = UniteAster()
nomFichierSortie = UL.Nom(UNITE_MAILLAGE)
fproc = open(nomFichierSortie, 'w')
fproc.write(os.linesep.join(resu_mail))
fproc.close()
UL.EtatInit(UNITE_MAILLAGE)
# Lecture du maillage de seg2 contenant toutes les lignes de coupe
__macou = LIRE_MAILLAGE(FORMAT='ASTER',UNITE=UNITE_MAILLAGE,)
# distance min entre 2 points de la ligne de coupe (utile pour PROJ_CHAMP)
dmin = dist_min_deux_points(__macou)
motscles = {}
iocc = 1
motscles['CREA_GROUP_NO'] = []
for m in LIGN_COUPE:
if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'):
motscles['CREA_GROUP_NO'].append(
_F(GROUP_MA=m[m['TYPE']].ljust(24),))
else:
motscles['CREA_GROUP_NO'].append(_F(GROUP_MA='LICOU' + str(iocc),))
iocc = iocc + 1
__macou = DEFI_GROUP(reuse=__macou, MAILLAGE=__macou, **motscles)
if AsType(RESULTAT).__name__ in ('evol_elas', 'evol_noli', 'mode_meca',
'comb_fourier', 'mult_elas', 'fourier_elas'):
__mocou = AFFE_MODELE(MAILLAGE=__macou,
AFFE=_F(TOUT='OUI',
PHENOMENE='MECANIQUE',
MODELISATION='BARRE',),
DISTRIBUTION=_F(METHODE='CENTRALISE'),
)
elif AsType(RESULTAT).__name__ in ('evol_ther', 'evol_varc',):
__mocou = AFFE_MODELE(MAILLAGE=__macou,
AFFE=_F(TOUT='OUI',
PHENOMENE='THERMIQUE',
MODELISATION='PLAN',),)
motscles = {}
motscles['VIS_A_VIS'] = []
motscles[mcORDR.keys()[0]] = mcORDR.values()[0]
if args['VIS_A_VIS'] != None:
for v in args['VIS_A_VIS']:
if v['GROUP_MA_1'] != None:
motscles['VIS_A_VIS'].append(
_F(GROUP_MA_1=v['GROUP_MA_1'], TOUT_2='OUI'),)
elif v['MAILLE_1'] != None:
motscles['VIS_A_VIS'].append(
_F(MAILLE_1=v['MAILLE_1'], TOUT_2='OUI'),)
if NOM_CHAM[5:9] == 'ELGA':
UTMESS('A', 'POST0_18', valk=[NOM_CHAM, ])
if (l_mode_meca_sans_modele == False):
# on utilise le modèle pour projeter le champ
if n_modele in self.get_global_contexte().keys():
MODELE_1 = self.get_global_contexte()[n_modele]
else:
MODELE_1 = self.jdc.current_context[n_modele]
__recou = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=RESULTAT,
MODELE_1=MODELE_1,
DISTANCE_MAX=m['DISTANCE_MAX'],
MODELE_2=__mocou,
TYPE_CHAM='NOEU',
NOM_CHAM=NOM_CHAM, **motscles)
else:
# on utilise directement le maillage (ou squelette) pour projeter le
# champ
if n_mailla in self.get_global_contexte().keys():
MAILLAGE_1 = self.get_global_contexte()[n_mailla]
else:
MAILLAGE_1 = self.jdc.current_context[n_mailla]
__recou = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=RESULTAT,
MAILLAGE_1=MAILLAGE_1,
DISTANCE_MAX=m['DISTANCE_MAX'],
MODELE_2=__mocou,
TYPE_CHAM='NOEU',
NOM_CHAM=NOM_CHAM, **motscles)
__remodr = __recou
icham = 0
ioc2 = 0
mcACTION = []
angtab = []
if AsType(RESULTAT).__name__ in ('evol_ther', 'evol_elas', 'evol_noli', 'mode_meca', 'evol_varc',
'comb_fourier', 'mult_elas', 'fourier_elas'):
if NOM_CHAM in ('DEPL', 'SIEF_ELNO', 'SIGM_NOEU', 'SIGM_ELNO', 'FLUX_ELNO', 'FLUX_NOEU'):
icham = 1
iocc = 0
for m in LIGN_COUPE:
iocc = iocc + 1
motscles = {}
motscles['OPERATION'] = m['OPERATION']
if m['NOM_CMP'] != None:
motscles['NOM_CMP'] = m['NOM_CMP']
if m['TRAC_NOR'] != None:
motscles['TRAC_NOR'] = m['TRAC_NOR']
elif m['TRAC_DIR'] != None:
motscles['TRAC_DIR'] = m['TRAC_DIR']
motscles['DIRECTION'] = m['DIRECTION']
elif m['INVARIANT'] != None:
motscles['INVARIANT'] = m['INVARIANT']
elif m['RESULTANTE'] != None:
motscles['RESULTANTE'] = m['RESULTANTE']
elif m['ELEM_PRINCIPAUX'] != None:
motscles['ELEM_PRINCIPAUX'] = m['ELEM_PRINCIPAUX']
else:
motscles['TOUT_CMP'] = 'OUI'
# on définit le groupe de noeud pour post_releve_t
if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'):
groupe = m[m['TYPE']].ljust(8)
nomgrma = groupe
else:
ioc2 = ioc2 + 1
groupe = 'LICOU' + str(ioc2)
nomgrma = ' '
newgrp = 'LICOF' + str(ioc2)
crea_grp_matiere(
self, groupe, newgrp, iocc, m, __remodr, NOM_CHAM, LIGN_COUPE, __macou)
groupe = newgrp
# on definit l'intitulé
if m['INTITULE'] != None:
intitl = m['INTITULE']
elif m['TYPE'] in ('GROUP_NO', 'GROUP_MA'):
intitl = groupe
else:
intitl = 'l.coupe' + str(ioc2)
# Expression des contraintes aux noeuds ou des déplacements dans le
# repere local
if m['REPERE'] != 'GLOBAL':
if icham == 1:
if m['REPERE'] == 'POLAIRE':
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__remodr,
REPERE=m['REPERE'],
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
else:
__remodr = crea_resu_local(
self, dime, NOM_CHAM, m, __recou, __macou, nomgrma)
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__remodr,
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
else:
UTMESS('A', 'POST0_17', valk=[NOM_CHAM, m['REPERE']])
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__recou,
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
# Expression des contraintes aux noeuds ou des déplacements dans le
# repere global
else:
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__recou,
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
else:
assert 0
__tabitm = POST_RELEVE_T(ACTION=mcACTION,)
# on repasse par les tables python pour supprimer les paramètres inutiles
# NOEUD (car il est propre au maillage de la ligne) et RESU
self.DeclareOut('nomres', self.sd)
dictab = __tabitm.EXTR_TABLE()
# Ajout de la colonne theta
if len(arcgma) > 0:
coltab = []
val = dictab['ABSC_CURV'].values()['ABSC_CURV']
nbi = len(val) / nbno
nba = len(angles)
tmp = []
for k in range(nba):
for j in range(nbi):
for i in range(len(angles[k])):
tmp.append(angles[k][i])
dictab['ANGLE'] = tmp
if 'RESU' in dictab.para:
del dictab['RESU']
if 'NOEUD' in dictab.para:
del dictab['NOEUD']
dprod = dictab.dict_CREA_TABLE()
nomres = CREA_TABLE(**dprod)
RetablirAlarme('ALGORITH12_43')
RetablirAlarme('CALCULEL2_63')
RetablirAlarme('CALCULEL2_64')
RetablirAlarme('MODELISA5_53')
RetablirAlarme('MODELE1_58')
RetablirAlarme('MODELE1_63')
RetablirAlarme('MODELE1_64')
return ier
def lire_fonction_ops(self, FORMAT, TYPE, SEPAR, INDIC_PARA, UNITE,
NOM_PARA, NOM_RESU, INTERPOL, PROL_DROITE,
PROL_GAUCHE, VERIF, INFO, TITRE, **args):
"""Méthode corps de la macro
"""
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
from Utilitai.UniteAster import UniteAster
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# On recopie le mot cle defi_fonction pour le proteger
if TYPE == 'NAPPE':
mc_DEFI_FONCTION = args['DEFI_FONCTION']
# On importe les definitions des commandes a utiliser dans la macro
DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
DEFI_NAPPE = self.get_cmd('DEFI_NAPPE')
assert FORMAT in ('LIBRE', 'NUMPY')
nompro = 'LIRE_FONCTION'
# Lecture de la fonction dans un fichier d unité logique UNITE
UL = UniteAster()
nomfich = UL.Nom(UNITE)
if not osp.isfile(nomfich):
UTMESS('F', 'FONCT0_41', valk=nomfich)
# fonction(_c) ou nappe en sortie
self.DeclareOut('ut_fonc', self.sd)
if TYPE == 'FONCTION':
values = function_values(FORMAT, nomfich, INDIC_PARA,
args['INDIC_RESU'], SEPAR, INFO)
# création de la fonction ASTER :
ut_fonc = DEFI_FONCTION(NOM_PARA=NOM_PARA,
NOM_RESU=NOM_RESU,
PROL_DROITE=PROL_DROITE,
PROL_GAUCHE=PROL_GAUCHE,
INTERPOL=INTERPOL,
INFO=INFO,
TITRE=TITRE,
VERIF=VERIF,
VALE=values)
elif TYPE == 'FONCTION_C':
# mise en forme de la liste de valeurs suivant le format choisi :
if FORMAT == 'LIBRE':
if 'INDIC_REEL' in args:
indic1 = args['INDIC_REEL']
indic2 = args['INDIC_IMAG']
if 'INDIC_MODU' in args:
indic1 = args['INDIC_MODU']
indic2 = args['INDIC_PHAS']
try:
liste_vale_r = liste_double(nomfich, INDIC_PARA, indic1, SEPAR, INFO)
except LectureBlocError, exc:
UTMESS('F', 'FONCT0_42', valk=exc.args)
try:
liste_vale_i = liste_double(nomfich, INDIC_PARA, indic2, SEPAR, INFO)
except LectureBlocError, exc:
UTMESS('F', 'FONCT0_42', valk=exc.args)
liste = []
if 'INDIC_REEL' in args:
for i in range(len(liste_vale_r) / 2):
liste.extend(
[liste_vale_r[2 * i], liste_vale_r[2 * i + 1], liste_vale_i[2 * i + 1]])
elif 'INDIC_MODU' in args:
for i in range(len(liste_vale_r) / 2):
module = liste_vale_r[2 * i + 1]
phase = liste_vale_i[2 * i + 1]
liste.extend(
[liste_vale_r[2 * i], module * cos(phase), module * sin(phase)])
def post_endo_fiss_ops(self, TABLE, OUVERTURE, NOM_CMP, NOM_CHAM, RECHERCHE,
**args):
import aster
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from code_aster.Cata.Syntax import _F
# --------------------------------------------------
# DEVELOPER OPTIONS
#
# "strong_flag" must be set to True if computing crack opening with the "strong" method
strong_flag = False
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
MasquerAlarme('CALCULEL5_48')
MasquerAlarme('ALGORITH12_43')
MasquerAlarme('CALCULEL2_12')
MasquerAlarme('CALCULEL5_7')
# --------------------------------------------------
# OUTPUT DECLARATION
#
self.DeclareOut('MAFISS', self.sd)
self.DeclareOut('tabRes', TABLE)
# --------------------------------------------------
# IMPORT OF ASTER COMMANDS
#
LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
CREA_TABLE = self.get_cmd('CREA_TABLE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CO = self.get_cmd('CO')
IMPR_RESU = self.get_cmd('IMPR_RESU')
RECU_TABLE = self.get_cmd('RECU_TABLE')
# --------------------------------------------------
# INPUT PARAMETERS
#
l_dRECHERCHE = []
for recherche in RECHERCHE:
dRECHERCHE = recherche.cree_dict_valeurs(recherche.mc_liste)
for i in dRECHERCHE.keys():
if dRECHERCHE[i] == None:
del dRECHERCHE[i]
l_dRECHERCHE.append(dRECHERCHE)
# --------------------------------------------------
# INPUT PARAMETERS, MESH AND MODEL
#
motscles = {}
for dRECHERCHE in l_dRECHERCHE:
if (OUVERTURE == 'OUI') and ('BORNE_MAX' not in dRECHERCHE.keys()):
UTMESS('F', 'POST0_44')
if args['CHAM_GD'] != None:
build = 'champ'
__ENDO = args['CHAM_GD']
inst = 1.
motscles['INST'] = inst
n_mail = __ENDO.sdj.REFE.get()[0].strip()
__mail = self.get_concept(n_mail)
else:
build = 'resu'
__RESUIN = args['RESULTAT']
nomresu = __RESUIN.nom
dicResu = __RESUIN.LIST_PARA()
dicVarAcc = __RESUIN.LIST_VARI_ACCES()
if args['NUME_ORDRE'] != None:
nume_ordre = args['NUME_ORDRE']
if nume_ordre not in dicVarAcc['NUME_ORDRE']:
UTMESS('F', 'POST0_41')
else:
inst = (dicVarAcc['INST'])[nume_ordre]
motscles['NUME_ORDRE'] = nume_ordre
else:
inst = args['INST']
motscles['INST'] = inst
nume_ordre = None
for champ_inst_index, champ_inst in enumerate(dicVarAcc['INST']):
if round(champ_inst, 12) == round(inst, 12):
nume_ordre = dicVarAcc['NUME_ORDRE'][champ_inst_index]
break
if nume_ordre is None:
UTMESS('F', 'POST0_41')
# Maillage pour projections
iret, ibid, n_mail = aster.dismoi('NOM_MAILLA', __RESUIN.nom,
'RESULTAT', 'F')
__mail = self.get_concept(n_mail)
dime = __mail.sdj.DIME.get()[5]
# --------------------------------------------------
# CONTROLS ON THE INPUT FIELDS
#
if build == 'resu':
ChampsResu = __RESUIN.LIST_CHAMPS()
lstChampsResu = ChampsResu.keys()
if (NOM_CHAM not in lstChampsResu):
UTMESS('F', 'POST0_42')
elif (nume_ordre not in ChampsResu[NOM_CHAM]):
UTMESS('F', 'POST0_41')
else:
pass
if build == 'champ' and OUVERTURE == 'OUI':
UTMESS('F', 'POST0_43')
if ('NOEU' in NOM_CHAM) or (NOM_CHAM == 'DEPL'):
typeChampTrajet = 'NOEU' + '_' + NOM_CHAM[0:4] + '_R'
if NOM_CHAM == 'VARI_NOEU':
typeChampTrajet = 'NOEU_VAR2_R'
else:
UTMESS('F', 'POST0_35')
# --------------------------------------------------
# QUANTITIES FOR THE 2D PROCEDURE
#
__TABG = RECU_TABLE(
CO=__mail,
NOM_TABLE='CARA_GEOM',
)
xmin = __TABG['X_MIN', 1]
xmax = __TABG['X_MAX', 1]
ymin = __TABG['Y_MIN', 1]
ymax = __TABG['Y_MAX', 1]
zmin = __TABG['Z_MIN', 1]
zmax = __TABG['Z_MAX', 1]
nbPrec = NP.finfo(NP.float).precision
delta_x = NP.round(xmax - xmin, nbPrec)
delta_y = NP.round(ymax - ymin, nbPrec)
delta_z = NP.round(zmax - zmin, nbPrec)
Ddim = [delta_x, delta_y, delta_z]
delta_min = min(Ddim)
if NP.round(delta_min, nbPrec - 2) != 0.:
UTMESS('F', 'POST0_34')
else:
idx_plan = Ddim.index(delta_min)
# PLAN == 'XY' :
if idx_plan == 2:
coorIni1 = 0
coorIni2 = 1
dnor = NP.array([0., 0., 1.], float)
dplan1 = NP.array([1., 0., 0.], float)
dplan2 = NP.array([0., 1., 0.], float)
# PLAN == 'XZ':
elif idx_plan == 1:
coorIni1 = 0
coorIni2 = 2
dnor = NP.array([0., 1., 0.], float)
dplan1 = NP.array([1., 0., 0.], float)
dplan2 = NP.array([0., 0., 1.], float)
# PLAN == 'YZ':
else:
coorIni1 = 1
coorIni2 = 2
dnor = NP.array([1., 0., 0.], float)
dplan1 = NP.array([0., 1., 0.], float)
dplan2 = NP.array([0., 0., 1.], float)
infoPlan = (coorIni1, coorIni2, dnor, dplan1, dplan2)
# --------------------------------------------------
# FIELD FOR CRACK PATH SEARCH
#
if build == 'resu':
__ENDO = CREA_CHAMP(TYPE_CHAM=typeChampTrajet,
OPERATION='EXTR',
RESULTAT=__RESUIN,
NOM_CHAM=NOM_CHAM,
**motscles)
# --------------------------------------------------
# LOOP ON THE FPZs (INSTANCES OF KEYWORD "RECHERCHE")
#
XcreteTot = []
YcreteTot = []
ZcreteTot = []
ConnTot = []
EndocreteTot = []
lstFissure = []
lstOuverture = []
lstErreur = []
lstNomFiss = []
for idxRech in range(len(l_dRECHERCHE)):
dRECHERCHE = l_dRECHERCHE[idxRech]
(CoxCrete, CoyCrete, CozCrete, EndoCrete,
Connex) = cherche_trajet(self, NOM_CMP, NOM_CHAM, dRECHERCHE, __ENDO,
__mail, typeChampTrajet, infoPlan, inst)
if OUVERTURE == 'OUI':
if strong_flag == False:
lstOuvFiss = calcul_ouverture(self, NOM_CHAM, NOM_CMP,
dRECHERCHE, __RESUIN, __mail,
infoPlan, inst, CoxCrete,
CoyCrete, CozCrete, dime,
strong_flag)
else:
lstOuvFiss, lstErr = calcul_ouverture(self, NOM_CHAM, NOM_CMP,
dRECHERCHE, __RESUIN,
__mail, infoPlan, inst,
nume_ordre, CoxCrete,
CoyCrete, CozCrete, dime,
strong_flag)
XcreteTot.append(CoxCrete)
YcreteTot.append(CoyCrete)
ZcreteTot.append(CozCrete)
EndocreteTot.append(EndoCrete)
ConnTot.append(Connex)
if 'GROUP_MA' in dRECHERCHE.keys():
nomFissure = dRECHERCHE['GROUP_MA']
else:
nomFissure = 'FISS' + str(idxRech + 1)
lstFissure = lstFissure + ([nomFissure] * len(CoxCrete))
lstNomFiss.append(nomFissure)
if OUVERTURE == 'OUI':
if '-' in lstOuvFiss:
UTMESS('A', 'POST0_33', nomFissure)
lstOuverture.append(lstOuvFiss)
if strong_flag == True:
lstErreur.append(lstErr)
lstX = []
lstY = []
lstZ = []
lstEndo = []
if OUVERTURE == 'OUI':
lstO = []
if strong_flag == True:
lstE = []
for i in range(len(XcreteTot)):
lstX = lstX + XcreteTot[i]
lstY = lstY + YcreteTot[i]
lstZ = lstZ + ZcreteTot[i]
lstEndo = lstEndo + EndocreteTot[i]
if OUVERTURE == 'OUI':
lstO = lstO + lstOuverture[i]
if strong_flag == True:
lstE = lstE + lstErreur[i]
# -----------------------------------------------------
# CREATION OF A TABLE TO STOCK CRACK PATH COORDINATES
# AND CRACK OPENING
#
if OUVERTURE == 'NON':
tabRes = CREA_TABLE(LISTE=(
_F(PARA='FISSURE', LISTE_K=lstFissure),
_F(PARA='COORX', LISTE_R=lstX),
_F(PARA='COORY', LISTE_R=lstY),
_F(PARA='COORZ', LISTE_R=lstZ),
_F(PARA='CHAMP', LISTE_R=lstEndo),
), )
else:
if strong_flag == False:
tabRes = CREA_TABLE(LISTE=(
_F(PARA='FISSURE', LISTE_K=lstFissure),
_F(PARA='COORX', LISTE_R=lstX),
_F(PARA='COORY', LISTE_R=lstY),
_F(PARA='COORZ', LISTE_R=lstZ),
_F(PARA='CHAMP', LISTE_R=lstEndo),
_F(PARA='OUVERTURE', LISTE_R=lstO),
), )
else: # STRONG Method
tabRes = CREA_TABLE(LISTE=(
_F(PARA='FISSURE', LISTE_K=lstFissure),
_F(PARA='COORX', LISTE_R=lstX),
_F(PARA='COORY', LISTE_R=lstY),
_F(PARA='COORZ', LISTE_R=lstZ),
_F(PARA='CHAMP', LISTE_R=lstEndo),
_F(PARA='OUVERTURE', LISTE_R=lstO),
_F(PARA='ERREUR', LISTE_R=lstE),
), )
# --------------------------------------------------
# CREATION OF DATA STRUCTURE "MESH"
#
resu_mail0 = crea_mail_lin(XcreteTot, YcreteTot, ZcreteTot, ConnTot,
lstNomFiss, dime)
nomFichierSortie = os.path.join(os.getcwd(), 'maillage.mail')
fproc = open(nomFichierSortie, 'w')
fproc.write(resu_mail0)
fproc.close()
UL = UniteAster()
uniteMail = UL.Libre(action='ASSOCIER', nom=nomFichierSortie)
MAFISS = LIRE_MAILLAGE(
FORMAT='ASTER',
UNITE=uniteMail,
)
UL.EtatInit(uniteMail)
RetablirAlarme('CALCULEL5_48')
RetablirAlarme('ALGORITH12_43')
RetablirAlarme('CALCULEL2_12')
RetablirAlarme('CALCULEL5_7')
return ier
def simu_point_mat_ops(self, MATER, INCREMENT, SIGM_IMPOSE, EPSI_IMPOSE,
SIGM_INIT, EPSI_INIT, VARI_INIT, NEWTON, CONVERGENCE,
MASSIF, ANGLE, COMPORTEMENT, INFO, ARCHIVAGE, SUPPORT,
**args):
"""Simulation de la reponse d'un point materiel"""
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
import math
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
AFFE_CARA_ELEM = self.get_cmd('AFFE_CARA_ELEM')
AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA')
AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU')
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
CALC_TABLE = self.get_cmd('CALC_TABLE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_RESU = self.get_cmd('CREA_RESU')
DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
MODI_MAILLAGE = self.get_cmd('MODI_MAILLAGE')
MODI_REPERE = self.get_cmd('MODI_REPERE')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
STAT_NON_LINE = self.get_cmd('STAT_NON_LINE')
IMPR_RESU = self.get_cmd('IMPR_RESU')
from Contrib.calc_point_mat import CALC_POINT_MAT
from code_aster.Cata.Syntax import _F
from Utilitai.UniteAster import UniteAster
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from Noyau.N_types import is_sequence
# alarme de STAT_NON_LINE si les mot-cles de COMPORTEMENT sont renseignes
# a tort
MasquerAlarme('COMPOR4_70')
# -- Tests de cohérence
__fonczero = DEFI_FONCTION(NOM_PARA='INST',
VALE=(0, 0, 10, 0),
PROL_DROITE='CONSTANT',
PROL_GAUCHE='CONSTANT')
EPS = {}
SIG = {}
itetra = 0
CMP_EPS = ['EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ']
CMP_SIG = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ']
if COMPORTEMENT:
lcomp = COMPORTEMENT.List_F()[0]
if SUPPORT != None:
if SUPPORT == 'ELEMENT':
itetra = 1
if itetra == 0:
if lcomp['DEFORMATION'] != 'PETIT':
if args.has_key('GRAD_IMPOSE'):
if args['GRAD_IMPOSE'] != None:
if lcomp['DEFORMATION'] != 'SIMO_MIEHE':
UTMESS('F', 'COMPOR2_22', valk=lcomp['DEFORMATION'])
itetra = 0
else:
itetra = 1
UTMESS('A', 'COMPOR2_1', valk=lcomp['DEFORMATION'])
#===============================================================
# cas ou il n'y a pas d'élement fini : appel à CALC_POINT_MAT
#===============================================================
if itetra == 0:
isig = 0
ieps = 0
igrd = 0
ic1c2 = 0
if SIGM_IMPOSE:
SIG = SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste)
isig = 1
if EPSI_IMPOSE:
EPS = EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste)
ieps = 1
if args.has_key('GRAD_IMPOSE'):
if args['GRAD_IMPOSE'] != None:
FIJ = args['GRAD_IMPOSE'][0].cree_dict_valeurs(
args['GRAD_IMPOSE'][0].mc_liste)
igrd = 1
if args.has_key('MATR_C1'):
if args['MATR_C1'] != None:
ic1c2 = 1
if args.has_key('MATR_C2'):
if args['MATR_C2'] != None:
ic1c2 = 1
motscles = {}
if igrd:
for i in FIJ.keys():
motscles[i] = FIJ[i]
elif ic1c2:
if args.has_key('MATR_C1'):
if args['MATR_C1'] != None:
motscles['MATR_C1'] = args['MATR_C1'].List_F()
if args.has_key('MATR_C2'):
if args['MATR_C2'] != None:
motscles['MATR_C2'] = args['MATR_C2'].List_F()
if args.has_key('VECT_IMPO'):
if args['VECT_IMPO'] != None:
motscles['VECT_IMPO'] = args['VECT_IMPO'].List_F()
else:
nbsig = 6
for index in range(nbsig):
iks = CMP_SIG[index]
ike = CMP_EPS[index]
inds = 0
inde = 0
if ieps:
if EPS[ike] != None:
inde = 1
if isig:
if SIG[iks] != None:
inds = 1
if inde * inds != 0:
UTMESS('F', 'COMPOR2_2', valk=iks)
if inde == 1:
motscles[ike] = EPS[ike]
elif inds == 1:
motscles[iks] = SIG[iks]
else:
motscles[iks] = __fonczero
# Etat initial
etatinit = 0
if SIGM_INIT != None:
motscles['SIGM_INIT'] = SIGM_INIT.List_F()
if EPSI_INIT != None:
motscles['EPSI_INIT'] = EPSI_INIT.List_F()
if VARI_INIT != None:
motscles['VARI_INIT'] = VARI_INIT.List_F()
if NEWTON != None:
motscles['NEWTON'] = NEWTON.List_F()
if CONVERGENCE != None:
motscles['CONVERGENCE'] = CONVERGENCE.List_F()
if MASSIF != None:
motscles['MASSIF'] = MASSIF.List_F()
if COMPORTEMENT:
motscles['COMPORTEMENT'] = COMPORTEMENT.List_F()
# -- Deroulement du calcul
motscles['INCREMENT'] = INCREMENT.List_F()
if args.has_key('FORMAT_TABLE'):
if args['FORMAT_TABLE'] != None:
motscles['FORMAT_TABLE'] = args['FORMAT_TABLE']
if args.has_key('OPER_TANGENT'):
if args['OPER_TANGENT'] != None:
motscles['OPER_TANGENT'] = args['OPER_TANGENT']
if args.has_key('NB_VARI_TABLE'):
if args['NB_VARI_TABLE'] != None:
motscles['NB_VARI_TABLE'] = args['NB_VARI_TABLE']
if ARCHIVAGE:
motscles['ARCHIVAGE'] = ARCHIVAGE.List_F()
# variables de commande
if args.has_key('AFFE_VARC'):
if args['AFFE_VARC'] != None:
lvarc = args['AFFE_VARC'].List_F()
nbvarc = len(lvarc)
lmotcle = []
for ivarc in range(nbvarc):
dico = {}
if (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'):
dico['NOM_VARC'] = 'ALPHPUR'
dico['VALE_FONC'] = lvarc[ivarc]['V1']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'ALPHBETA'
dico['VALE_FONC'] = lvarc[ivarc]['V2']
lmotcle.append(dico)
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'):
dico['NOM_VARC'] = 'PFERRITE'
dico['VALE_FONC'] = lvarc[ivarc]['V1']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'PPERLITE'
dico['VALE_FONC'] = lvarc[ivarc]['V2']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'PBAINITE'
dico['VALE_FONC'] = lvarc[ivarc]['V3']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'PMARTENS'
dico['VALE_FONC'] = lvarc[ivarc]['V4']
lmotcle.append(dico)
else:
dico['NOM_VARC'] = lvarc[ivarc]['NOM_VARC']
dico['VALE_FONC'] = lvarc[ivarc]['VALE_FONC']
if str(lvarc[ivarc]['NOM_VARC']) == 'TEMP' or str(
lvarc[ivarc]['NOM_VARC']) == 'SECH':
dico['VALE_REF'] = lvarc[ivarc]['VALE_REF']
lmotcle.append(dico)
motscles['AFFE_VARC'] = lmotcle
if lcomp['RELATION'] == 'META_LEMA_ANI':
UTMESS('F', 'COMPOR2_91', valk=lcomp['RELATION'])
self.DeclareOut('REPONSE', self.sd)
Titre = 'CALC_POINT_MAT'
if ARCHIVAGE != None:
# on ne prend en compte que ARCHIVAGE / LIST_INST
if ARCHIVAGE['LIST_INST'] != None:
__REP1 = CALC_POINT_MAT(INFO=INFO,
MATER=MATER,
ANGLE=ANGLE,
**motscles)
lr8 = ARCHIVAGE['LIST_INST']
lr = lr8.Valeurs()
REPONSE = CALC_TABLE(
TABLE=__REP1,
TITRE=Titre,
ACTION=_F(OPERATION='FILTRE',
NOM_PARA='INST',
VALE=lr,
PRECISION=ARCHIVAGE['PRECISION']),
)
else:
REPONSE = CALC_POINT_MAT(INFO=INFO,
MATER=MATER,
ANGLE=ANGLE,
**motscles)
else:
REPONSE = CALC_POINT_MAT(INFO=INFO,
MATER=MATER,
ANGLE=ANGLE,
**motscles)
#===============================================================
# cas ou on fait le calcul sur un TETRA4 A UN SEUL POINT DE GAUSS
#===============================================================
elif itetra == 1:
EPS = {}
SIG = {}
MODELISATION = "3D"
if args.has_key('MODELISATION'):
if args['MODELISATION'] != None:
MODELISATION = args['MODELISATION']
if MODELISATION == "3D":
nbsig = 6
CMP_EPS = ['EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ']
CMP_SIG = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ']
else:
nbsig = 3
CMP_EPS = ['EPXX', 'EPYY', 'EPXY']
CMP_SIG = ['SIXX', 'SIYY', 'SIXY']
if SIGM_IMPOSE:
SIG = SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste)
for i in SIG.keys():
if SIG[i] == None:
SIG[i] = __fonczero
else:
for i in range(nbsig):
SIG[CMP_SIG[i]] = __fonczero
if EPSI_IMPOSE:
EPS = EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste)
else:
for i in range(nbsig):
EPS[CMP_EPS[i]] = None
for index in range(nbsig):
iks = CMP_SIG[index]
ike = CMP_EPS[index]
if EPS[ike] != None and SIG[iks] != __fonczero:
UTMESS('F', 'COMPOR2_3', valk=str(iks) + ' ' + str(ike))
# -- Definition du maillage
if MODELISATION == "3D":
texte_ma = """
COOR_3D
P0 0.0 0.0 0.0
P1 1.0 0.0 0.0
P2 0.0 1.0 0.0
P3 0.0 0.0 1.0
FINSF
TRIA3
F1 P0 P3 P2
F2 P0 P1 P3
F3 P0 P2 P1
F4 P1 P2 P3
FINSF
TETRA4
VOLUME = P0 P1 P2 P3
FINSF
GROUP_MA
TOUT VOLUME
FINSF
GROUP_NO
TOUT P1 P2 P0 P3
FINSF
FIN
"""
else:
texte_ma = """
COOR_2D
P0 0.0 0.0
P1 1.0 0.0
P2 0.0 1.0
FINSF
SEG2
S1 P2 P0
S2 P0 P1
S3 P1 P2
FINSF
TRIA3
VOLUME = P0 P1 P2
FINSF
GROUP_MA
TOUT VOLUME
FINSF
GROUP_NO
TOUT P1 P2 P0
FINSF
FIN
"""
fi_mail = open('simu.mail', 'w')
fi_mail.write(texte_ma)
fi_mail.close()
UL = UniteAster()
umail = UL.Libre(action='ASSOCIER', nom='simu.mail')
__MA = LIRE_MAILLAGE(FORMAT='ASTER', UNITE=umail)
UL.EtatInit()
if MODELISATION == "3D":
__MO = AFFE_MODELE(MAILLAGE=__MA,
AFFE=_F(
MAILLE=('VOLUME', 'F1', 'F2', 'F3', 'F4'),
PHENOMENE='MECANIQUE',
MODELISATION='3D',
))
# ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations
# imposées.
if ANGLE != 0.:
__MA = MODI_MAILLAGE(
reuse=__MA,
MAILLAGE=__MA,
ROTATION=_F(POIN_1=(0., 0.), ANGLE=ANGLE),
)
c = math.cos(ANGLE * math.pi / 180.)
s = math.sin(ANGLE * math.pi / 180.)
__C_RIGIDE = AFFE_CHAR_MECA(
MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0., DZ=0.),
LIAISON_DDL=(
_F(NOEUD=('P1', 'P1', 'P2', 'P2'),
DDL=('DX', 'DY', 'DX', 'DY'),
COEF_MULT=(s, -c, c, s),
COEF_IMPO=0),
_F(NOEUD=('P1', 'P3', 'P3'),
DDL=('DZ', 'DX', 'DY'),
COEF_MULT=(-1.0, c, s),
COEF_IMPO=0),
_F(NOEUD=('P2', 'P3', 'P3'),
DDL=('DZ', 'DX', 'DY'),
COEF_MULT=(-1.0, -s, c),
COEF_IMPO=0),
),
)
else:
# -- Mouvement de corps rigide
__C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0',
DX=0,
DY=0,
DZ=0),
LIAISON_DDL=(
_F(NOEUD=('P2', 'P1'),
DDL=('DX', 'DY'),
COEF_MULT=(1, -1),
COEF_IMPO=0),
_F(NOEUD=('P3', 'P1'),
DDL=('DX', 'DZ'),
COEF_MULT=(1, -1),
COEF_IMPO=0),
_F(NOEUD=('P3', 'P2'),
DDL=('DY', 'DZ'),
COEF_MULT=(1, -1),
COEF_IMPO=0),
))
else:
# MODELISATION 2D
__MO = AFFE_MODELE(MAILLAGE=__MA,
AFFE=_F(MAILLE=('VOLUME', 'S1', 'S2', 'S3'),
PHENOMENE='MECANIQUE',
MODELISATION=MODELISATION))
# ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations
# imposées.
if ANGLE != 0.:
__MA = MODI_MAILLAGE(
reuse=__MA,
MAILLAGE=__MA,
ROTATION=_F(POIN_1=(0., 0.), ANGLE=ANGLE),
)
c = math.cos(ANGLE * math.pi / 180.)
s = math.sin(ANGLE * math.pi / 180.)
__C_RIGIDE = AFFE_CHAR_MECA(
MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0.),
LIAISON_DDL=(_F(NOEUD=('P1', 'P1', 'P2', 'P2'),
DDL=('DX', 'DY', 'DX', 'DY'),
COEF_MULT=(s, -c, c, s),
COEF_IMPO=0), ),
)
else:
__C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0', DX=0,
DY=0),
LIAISON_DDL=(_F(NOEUD=('P2', 'P1'),
DDL=('DX', 'DY'),
COEF_MULT=(1, -1),
COEF_IMPO=0), ))
# --MASSIF : orientation du materiau (monocristal, orthotropie)
if MASSIF:
ANGMAS = MASSIF[0].cree_dict_valeurs(MASSIF[0].mc_liste)
if ANGMAS["ANGL_REP"] == None:
__CARA = AFFE_CARA_ELEM(
MODELE=__MO,
MASSIF=_F(MAILLE='VOLUME',
ANGL_EULER=ANGMAS["ANGL_EULER"]),
)
else:
__CARA = AFFE_CARA_ELEM(
MODELE=__MO,
MASSIF=_F(MAILLE='VOLUME', ANGL_REP=ANGMAS["ANGL_REP"]),
)
# -- Chargement en deformation
__E = [None] * nbsig
__E[0] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1',
DX=1,
ANGL_NAUT=ANGLE))
__E[1] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P2',
DY=1,
ANGL_NAUT=ANGLE))
if MODELISATION == "3D":
__E[2] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P3',
DZ=1,
ANGL_NAUT=ANGLE))
__E[3] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1',
DY=1,
ANGL_NAUT=ANGLE))
__E[4] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1',
DZ=1,
ANGL_NAUT=ANGLE))
__E[5] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P2',
DZ=1,
ANGL_NAUT=ANGLE))
else:
c = math.cos(ANGLE * math.pi / 180.)
s = math.sin(ANGLE * math.pi / 180.)
__E[2] = AFFE_CHAR_MECA(
MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE),
)
# -- Chargement en contrainte
__S = [None] * nbsig
if MODELISATION == "3D":
r33 = 3**-0.5
__S[0] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F1', FX=-1),
_F(MAILLE='F4', FX=r33),
))
__S[1] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F2', FY=-1),
_F(MAILLE='F4', FY=r33),
))
__S[2] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F3', FZ=-1),
_F(MAILLE='F4', FZ=r33),
))
__S[3] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F1', FY=-1),
_F(MAILLE='F2', FX=-1),
_F(MAILLE='F4', FX=r33, FY=r33),
))
__S[4] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F1', FZ=-1),
_F(MAILLE='F3', FX=-1),
_F(MAILLE='F4', FX=r33, FZ=r33),
))
__S[5] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F2', FZ=-1),
_F(MAILLE='F3', FY=-1),
_F(MAILLE='F4', FY=r33, FZ=r33),
))
else:
r22 = 2**-0.5
__S[0] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_CONTOUR=(
_F(MAILLE='S1', FX=-1),
_F(MAILLE='S3', FX=r22),
))
__S[1] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_CONTOUR=(
_F(MAILLE='S2', FY=-1),
_F(MAILLE='S3', FY=r22),
))
__S[2] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_CONTOUR=(
_F(MAILLE='S1', FY=-1),
_F(MAILLE='S2', FX=-1),
_F(MAILLE='S3', FX=r22, FY=r22),
))
# -- Construction de la charge
l_char = [_F(CHARGE=__C_RIGIDE)]
for i in xrange(nbsig):
ike = CMP_EPS[i]
if EPS[ike]:
l_char.append(_F(CHARGE=__E[i], FONC_MULT=EPS[ike]))
for i in xrange(nbsig):
iks = CMP_SIG[i]
l_char.append(_F(CHARGE=__S[i], FONC_MULT=SIG[iks]))
# variables de commande
mcvarc = []
if args.has_key('AFFE_VARC'):
if args['AFFE_VARC'] != None:
lvarc = args['AFFE_VARC'].List_F()
nbvarc = len(lvarc)
for ivarc in range(nbvarc):
dico = {}
if (str(lvarc[ivarc]['NOM_VARC']) == 'SECH'):
typech = 'NOEU_TEMP_R'
labsc = lvarc[ivarc]['VALE_FONC'].Absc()
lordo = lvarc[ivarc]['VALE_FONC'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHV[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
MAILLAGE=__MA,
AFFE=_F(
MAILLE='VOLUME',
NOM_CMP='TEMP',
VALE=lordo[it],
),
),
dicoch = {}
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_VARC',
NOM_CHAM='TEMP',
AFFE=l_affe_cham)
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'):
typech = 'ELNO_NEUT_R'
labsc = lvarc[ivarc]['V1'].Absc()
lordo1 = lvarc[ivarc]['V1'].Ordo()
lordo2 = lvarc[ivarc]['V2'].Ordo()
lordo3 = lvarc[ivarc]['V3'].Ordo()
lordo4 = lvarc[ivarc]['V4'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
__CHN = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHN[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
PROL_ZERO='OUI',
MODELE=__MO,
AFFE=(
_F(
MAILLE='VOLUME',
NOM_CMP='X1',
VALE=lordo1[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X2',
VALE=lordo2[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X3',
VALE=lordo3[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X4',
VALE=lordo4[it],
),
),
),
dicoch = {}
__CHV[it] = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELNO_VARI_R',
MODELE=__MO,
PROL_ZERO='OUI',
ASSE=(
_F(CHAM_GD=__CHN[it],
NOM_CMP='X1',
NOM_CMP_RESU='V1',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X2',
NOM_CMP_RESU='V2',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X3',
NOM_CMP_RESU='V3',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X4',
NOM_CMP_RESU='V4',
GROUP_MA='TOUT'),
))
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_THER',
NOM_CHAM=str('META_ELNO'),
AFFE=l_affe_cham)
IMPR_RESU(FORMAT='RESULTAT', RESU=_F(RESULTAT=__EVOV))
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'):
typech = 'ELNO_NEUT_R'
labsc = lvarc[ivarc]['V1'].Absc()
lordo1 = lvarc[ivarc]['V1'].Ordo()
lordo2 = lvarc[ivarc]['V2'].Ordo()
lordo3 = lvarc[ivarc]['V3'].Ordo()
lordo4 = lvarc[ivarc]['V4'].Ordo()
lordo5 = lvarc[ivarc]['V5'].Ordo()
lordo6 = lvarc[ivarc]['V6'].Ordo()
lordo7 = lvarc[ivarc]['V7'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
__CHN = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHN[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
PROL_ZERO='OUI',
MODELE=__MO,
AFFE=(
_F(
MAILLE='VOLUME',
NOM_CMP='X1',
VALE=lordo1[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X2',
VALE=lordo2[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X3',
VALE=lordo3[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X4',
VALE=lordo4[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X5',
VALE=lordo5[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X6',
VALE=lordo6[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X7',
VALE=lordo7[it],
),
),
),
dicoch = {}
__CHV[it] = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELNO_VARI_R',
MODELE=__MO,
PROL_ZERO='OUI',
ASSE=(
_F(CHAM_GD=__CHN[it],
NOM_CMP='X1',
NOM_CMP_RESU='V1',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X2',
NOM_CMP_RESU='V2',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X3',
NOM_CMP_RESU='V3',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X4',
NOM_CMP_RESU='V4',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X5',
NOM_CMP_RESU='V5',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X6',
NOM_CMP_RESU='V6',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X7',
NOM_CMP_RESU='V7',
GROUP_MA='TOUT'),
))
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_THER',
NOM_CHAM=str('META_ELNO'),
AFFE=l_affe_cham)
IMPR_RESU(FORMAT='RESULTAT', RESU=_F(RESULTAT=__EVOV))
else:
typech = 'NOEU_' + str(lvarc[ivarc]['NOM_VARC']) + '_R'
labsc = lvarc[ivarc]['VALE_FONC'].Absc()
lordo = lvarc[ivarc]['VALE_FONC'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHV[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
MAILLAGE=__MA,
AFFE=_F(
MAILLE='VOLUME',
NOM_CMP=lvarc[ivarc]['NOM_VARC'],
VALE=lordo[it],
),
),
dicoch = {}
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_VARC',
NOM_CHAM=str(
lvarc[ivarc]['NOM_VARC']),
AFFE=l_affe_cham)
dico["MAILLE"] = 'VOLUME'
dico["EVOL"] = __EVOV
if (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'):
dico["NOM_VARC"] = "M_ZIRC"
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'):
dico["NOM_VARC"] = "M_ACIER"
else:
dico["NOM_VARC"] = lvarc[ivarc]['NOM_VARC']
if lvarc[ivarc]['VALE_REF'] != None:
dico["VALE_REF"] = lvarc[ivarc]['VALE_REF']
mcvarc.append(dico)
# -- Materiau et modele
if len(mcvarc) > 0:
__CHMAT = AFFE_MATERIAU(
MAILLAGE=__MA,
AFFE=_F(MAILLE='VOLUME', MATER=MATER),
AFFE_VARC=mcvarc,
)
else:
__CHMAT = AFFE_MATERIAU(MAILLAGE=__MA,
AFFE=_F(MAILLE='VOLUME', MATER=MATER))
# Etat initial
SIGINI = {}
VARINI = {}
LCSIG = []
LVSIG = []
init_dico = {}
etatinit = 0
# --contraintes initiales
if SIGM_INIT:
etatinit = 1
SIGINI = SIGM_INIT[0].cree_dict_valeurs(SIGM_INIT[0].mc_liste)
for i in SIGINI.keys():
if SIGINI[i] != None:
LCSIG.append(i)
LVSIG.append(SIGINI[i])
__SIG_INIT = CREA_CHAMP(MAILLAGE=__MA,
OPERATION='AFFE',
TYPE_CHAM='CART_SIEF_R',
AFFE=_F(
TOUT='OUI',
NOM_CMP=LCSIG,
VALE=LVSIG,
))
init_dico['SIGM'] = __SIG_INIT
# --variables internes initiales
if VARI_INIT:
etatinit = 1
lnomneu = []
lnomvar = []
VARINI = VARI_INIT[0].cree_dict_valeurs(VARI_INIT[0].mc_liste)
if (not is_sequence(VARINI['VALE'])):
VARINI['VALE'] = [
VARINI['VALE'],
]
nbvari = len(VARINI['VALE'])
for i in range(nbvari):
lnomneu.append('X' + str(i + 1))
lnomvar.append('V' + str(i + 1))
__NEUT = CREA_CHAMP(OPERATION='AFFE',
TYPE_CHAM='CART_N480_R',
MAILLAGE=__MA,
AFFE=_F(MAILLE='VOLUME',
NOM_CMP=lnomneu,
VALE=VARINI['VALE']))
__VAR_INIT = CREA_CHAMP(MODELE=__MO,
OPERATION='ASSE',
TYPE_CHAM='ELGA_VARI_R',
ASSE=_F(TOUT='OUI',
CHAM_GD=__NEUT,
NOM_CMP=lnomneu,
NOM_CMP_RESU=lnomvar))
init_dico['VARI'] = __VAR_INIT
# --deformations initiales
if EPSI_INIT:
etatinit = 1
EPSINI = {}
LCDEPL = []
LNDEPL = []
LVDEPL = []
LIST_AFFE = []
mon_dico = {}
mon_dico["NOEUD"] = 'P0'
mon_dico["NOM_CMP"] = ("DX", "DY", "DZ")
mon_dico["VALE"] = (0., 0., 0.)
LIST_AFFE.append(mon_dico)
EPSINI = EPSI_INIT[0].cree_dict_valeurs(EPSI_INIT[0].mc_liste)
mon_dico = {}
mon_dico["NOEUD"] = 'P1'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXX']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPYY']
LIST_AFFE.append(mon_dico)
if MODELISATION == "3D":
mon_dico = {}
mon_dico["NOEUD"] = 'P3'
mon_dico["NOM_CMP"] = 'DZ'
mon_dico["VALE"] = EPSINI['EPZZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P1'
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P1'
mon_dico["NOM_CMP"] = 'DZ'
mon_dico["VALE"] = EPSINI['EPXZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P3'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DZ'
mon_dico["VALE"] = EPSINI['EPYZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P3'
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPYZ']
LIST_AFFE.append(mon_dico)
else:
mon_dico = {}
mon_dico["NOEUD"] = 'P1',
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
__DEP_INI = CREA_CHAMP(MAILLAGE=__MA,
OPERATION='AFFE',
TYPE_CHAM='NOEU_DEPL_R',
AFFE=LIST_AFFE)
init_dico['DEPL'] = __DEP_INI
# -- Deroulement du calcul
motscles = {}
if COMPORTEMENT:
motscles['COMPORTEMENT'] = COMPORTEMENT.List_F()
if lcomp['RELATION'] == 'META_LEMA_ANI':
UTMESS('A', 'COMPOR2_92', valk=lcomp['RELATION'])
motscles['CONVERGENCE'] = CONVERGENCE.List_F()
motscles['NEWTON'] = NEWTON.List_F()
if args.has_key('RECH_LINEAIRE'):
if args['RECH_LINEAIRE'] != None:
motscles['RECH_LINEAIRE'] = args['RECH_LINEAIRE'].List_F()
motscles['INCREMENT'] = INCREMENT.List_F()
if ARCHIVAGE:
motscles['ARCHIVAGE'] = ARCHIVAGE.List_F()
if args.has_key('SUIVI_DDL'):
if args['SUIVI_DDL'] != None:
motscles['SUIVI_DDL'] = args['SUIVI_DDL'].List_F()
if etatinit == 1:
if MASSIF:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
CARA_ELEM=__CARA,
MODELE=__MO,
CHAM_MATER=__CHMAT,
ETAT_INIT=init_dico,
EXCIT=l_char,
**motscles)
else:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
MODELE=__MO,
CHAM_MATER=__CHMAT,
ETAT_INIT=init_dico,
EXCIT=l_char,
**motscles)
else:
if MASSIF:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
MODELE=__MO,
CARA_ELEM=__CARA,
CHAM_MATER=__CHMAT,
EXCIT=l_char,
**motscles)
else:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
MODELE=__MO,
CHAM_MATER=__CHMAT,
EXCIT=l_char,
**motscles)
if lcomp['DEFORMATION'] != 'PETIT':
nomepsi = 'EPSG_ELNO'
else:
nomepsi = 'EPSI_ELNO'
__EVOL1 = CALC_CHAMP(
reuse=__EVOL1,
RESULTAT=__EVOL1,
CONTRAINTE='SIGM_ELNO',
DEFORMATION=nomepsi,
VARI_INTERNE='VARI_ELNO',
)
if MODELISATION == "3D":
angles = (ANGLE, 0, 0)
__EVOL = MODI_REPERE(
RESULTAT=__EVOL1,
MODI_CHAM=(
_F(
NOM_CHAM='DEPL',
NOM_CMP=('DX', 'DY', 'DZ'),
TYPE_CHAM='VECT_3D',
),
_F(
NOM_CHAM='SIGM_ELNO',
NOM_CMP=('SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ',
'SIYZ'),
TYPE_CHAM='TENS_3D',
),
_F(
NOM_CHAM=nomepsi,
NOM_CMP=('EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ',
'EPYZ'),
TYPE_CHAM='TENS_3D',
),
),
REPERE='UTILISATEUR',
AFFE=_F(ANGL_NAUT=angles),
)
else:
angles = ANGLE
__EVOL = MODI_REPERE(
RESULTAT=__EVOL1,
MODI_CHAM=(
_F(
NOM_CHAM='DEPL',
NOM_CMP=('DX', 'DY'),
TYPE_CHAM='VECT_2D',
),
_F(
NOM_CHAM='SIGM_ELNO',
NOM_CMP=('SIXX', 'SIYY', 'SIZZ', 'SIXY'),
TYPE_CHAM='TENS_2D',
),
_F(
NOM_CHAM=nomepsi,
NOM_CMP=('EPXX', 'EPYY', 'EPZZ', 'EPXY'),
TYPE_CHAM='TENS_2D',
),
),
REPERE='UTILISATEUR',
AFFE=_F(ANGL_NAUT=angles),
)
# -- Recuperation des courbes
__REP_VARI = POST_RELEVE_T(ACTION=(_F(INTITULE='VARI_INT',
RESULTAT=__EVOL1,
NOM_CHAM='VARI_ELNO',
TOUT_CMP='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_EPSI = POST_RELEVE_T(ACTION=(_F(INTITULE='EPSILON',
RESULTAT=__EVOL,
NOM_CHAM=nomepsi,
TOUT_CMP='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_SIGM = POST_RELEVE_T(ACTION=(_F(INTITULE='SIGMA',
RESULTAT=__EVOL,
NOM_CHAM='SIGM_ELNO',
TOUT_CMP='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_INV = POST_RELEVE_T(ACTION=(_F(INTITULE='INV',
RESULTAT=__EVOL,
NOM_CHAM='SIGM_ELNO',
INVARIANT='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_INV = CALC_TABLE(TABLE=__REP_INV,
reuse=__REP_INV,
ACTION=_F(
OPERATION='EXTR',
NOM_PARA=('INST', 'TRACE', 'VMIS'),
))
self.DeclareOut('REPONSE', self.sd)
REPONSE = CALC_TABLE(TABLE=__REP_EPSI,
TITRE='TABLE ',
ACTION=(
_F(
OPERATION='COMB',
TABLE=__REP_SIGM,
NOM_PARA=('INST'),
),
_F(
OPERATION='COMB',
TABLE=__REP_INV,
NOM_PARA=('INST'),
),
_F(
OPERATION='COMB',
TABLE=__REP_VARI,
NOM_PARA=('INST'),
),
))
RetablirAlarme('COMPOR4_70')
return ier
def impr_fonction_ops(self, FORMAT, COURBE, INFO, **args):
"""
Macro IMPR_FONCTION permettant d'imprimer dans un fichier des fonctions,
colonnes de table...
Erreurs<S> dans IMPR_FONCTION pour ne pas perdre la base.
"""
macro = 'IMPR_FONCTION'
import pprint
import aster
from code_aster.Cata.Syntax import _F
from code_aster.Cata.DataStructure import (nappe_sdaster, fonction_c,
formule, formule_c)
from Utilitai import Graph
from Utilitai.Utmess import UTMESS
from Utilitai.UniteAster import UniteAster
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
CALC_FONC_INTERP = self.get_cmd('CALC_FONC_INTERP')
DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
#----------------------------------------------
# 0. Traitement des arguments, initialisations
# unité logique des fichiers réservés
ul_reserve = (8, )
UL = UniteAster()
# 0.1. Fichier
nomfich = None
if args['UNITE'] and args['UNITE'] != 6:
nomfich = UL.Nom(args['UNITE'])
if INFO == 2:
aster.affiche('MESSAGE', ' Nom du fichier :' + nomfich)
if nomfich and os.path.exists(nomfich) and os.stat(nomfich).st_size != 0:
if FORMAT == 'XMGRACE':
niv = 'I'
else:
niv = 'I'
UTMESS(niv, 'FONCT0_1', valk=nomfich)
# 0.2. Récupération des valeurs sous COURBE
unparmi = ('FONCTION', 'LIST_RESU', 'FONC_X', 'ABSCISSE', 'NAPPE',
'NAPPE_LISSEE')
# i0 : indice du mot-clé facteur qui contient LIST_PARA, sinon i0=0
i0 = 0
Courbe = []
iocc = -1
for Ci in COURBE:
iocc += 1
dC = Ci.cree_dict_valeurs(Ci.mc_liste)
if dC.has_key('LIST_PARA') and dC['LIST_PARA'] != None and i0 == 0:
i0 = iocc
for mc in dC.keys():
if dC[mc] == None:
del dC[mc]
Courbe.append(dC)
if INFO == 2:
aster.affiche('MESSAGE',
' Nombre de fonctions à analyser : ' + str(len(Courbe)))
# 0.3. Devra-t-on interpoler globalement ?
# Dans ce cas, __linter est le LIST_PARA
# ou, à défaut, les abscisses de la première courbe
interp = False
if FORMAT == 'TABLEAU':
interp = True
dCi = Courbe[i0]
if dCi.has_key('LIST_PARA'):
__linter = dCi['LIST_PARA']
else:
obj = None
for typi in unparmi:
if dCi.has_key(typi):
obj = dCi[typi]
break
if obj == None:
UTMESS('S', 'SUPERVIS_56')
if typi == 'FONCTION' or typi == 'NAPPE' or typi == 'NAPPE_LISSEE':
if isinstance(obj, nappe_sdaster):
lpar, lval = obj.Valeurs()
linterp = lval[0][0]
else:
linterp = obj.Valeurs()[0]
elif typi == 'FONC_X':
lbid, linterp = obj.Valeurs()
elif typi == 'ABSCISSE':
linterp = obj
__linter = DEFI_LIST_REEL(VALE=linterp)
if INFO == 2:
aster.affiche('MESSAGE', ' Interpolation globale sur la liste :')
aster.affiche('MESSAGE', pprint.pformat(__linter.Valeurs()))
#----------------------------------------------
# 1. Récupération des valeurs des N courbes sous forme
# d'une liste de N listes
#----------------------------------------------
graph = Graph.Graph()
iocc = -1
for dCi in Courbe:
iocc += 1
# 1.1. Type d'objet à traiter
obj = None
for typi in unparmi:
if dCi.has_key(typi):
obj = dCi[typi]
break
if not dCi.has_key('LEGENDE') and hasattr(obj, 'get_name'):
dCi['LEGENDE'] = obj.get_name()
if obj == None:
UTMESS('S', 'SUPERVIS_56')
# 1.2. Extraction des valeurs
# 1.2.1. Mot-clé FONCTION
if typi == 'FONCTION' or typi == 'NAPPE' or typi == 'NAPPE_LISSEE':
# formule à un paramètre seulement
if isinstance(obj, formule):
dpar = obj.Parametres()
if len(dpar['NOM_PARA']) != 1:
UTMESS('S',
'FONCT0_50',
valk=obj.nom,
vali=len(dpar['NOM_PARA']))
if isinstance(obj, nappe_sdaster):
lpar, lval = obj.Valeurs()
dico, ldicf = obj.Parametres()
Leg = dCi['LEGENDE']
for i in range(len(lpar)):
p = lpar[i]
lx = lval[i][0]
ly = lval[i][1]
# sur quelle liste interpoler chaque fonction
if i == 0:
if interp:
__li = __linter
elif dCi.has_key('LIST_PARA'):
__li = dCi['LIST_PARA']
else:
__li = DEFI_LIST_REEL(VALE=lx)
# compléter les paramètres d'interpolation
dic = dico.copy()
dic.update(ldicf[i])
if (interp or dCi.has_key('LIST_PARA')) and i > 0:
try:
__ftmp = CALC_FONC_INTERP(FONCTION=obj,
VALE_PARA=p,
LIST_PARA_FONC=__li,
**dic)
pv, lv2 = __ftmp.Valeurs()
lx = lv2[0][0]
ly = lv2[0][1]
except aster.error, err:
# on verifie que la bonne exception a ete levee
assert err.id_message == "FONCT0_9", 'unexpected id : %s' % err.id_message
continue
# on stocke les données dans le Graph
nomresu = dic['NOM_RESU'].strip() + '_' + str(
len(graph.Legendes))
dicC = {
'Val': [lx, ly],
'Lab': [dic['NOM_PARA_FONC'], nomresu]
}
# ajoute la valeur du paramètre
dCi['LEGENDE'] = '%s %s=%g' % (Leg,
dic['NOM_PARA'].strip(), p)
if typi == 'NAPPE':
dCi['LEGENDE'] = '%s %s=%g' % (
Leg, dic['NOM_PARA'].strip(), p)
if typi == 'NAPPE_LISSEE':
dCi['LEGENDE'] = 'NAPPE_LISSEE %s %s=%g' % (
Leg, dic['NOM_PARA'].strip(), p)
Graph.AjoutParaCourbe(dicC, args=dCi)
graph.AjoutCourbe(**dicC)
else:
__ftmp = obj
dpar = __ftmp.Parametres()
# pour les formules à un paramètre (test plus haut)
if type(dpar['NOM_PARA']) in (list, tuple):
dpar['NOM_PARA'] = dpar['NOM_PARA'][0]
if interp:
try:
__ftmp = CALC_FONC_INTERP(FONCTION=obj,
LIST_PARA=__linter,
**dpar)
except aster.error, err:
# on verifie que la bonne exception a ete levee
assert err.id_message == "FONCT0_9", 'unexpected id : %s' % err.id_message
continue
elif dCi.has_key('LIST_PARA'):
try:
__ftmp = CALC_FONC_INTERP(FONCTION=obj,
LIST_PARA=dCi['LIST_PARA'],
**dpar)
except aster.error, err:
# on verifie que la bonne exception a ete levee
assert err.id_message == "FONCT0_9", 'unexpected id : %s' % err.id_message
continue