def periodic_cond(self):
"""Define the boundary conditions of periodicity"""
from code_aster.Cata.Commands import AFFE_CHAR_MECA
def equal(ddl, grno1, grno2):
"""Return keyword to set ddl(grno1) = ddl(grno2)"""
return _F(GROUP_NO_1=grno1,
GROUP_NO_2=grno2,
SOMMET='OUI',
DDL_1=ddl,
DDL_2=ddl,
COEF_MULT_1=1.,
COEF_MULT_2=-1.,
COEF_IMPO=0.)
liaison_group = [
equal('DY', 'PMNT_S', 'PEBO_S'),
equal('DZ', 'PMNT_S', 'PEBO_S'),
equal('DY', 'PSUP', 'PEBO_S'),
equal('DZ', 'PSUP', 'PEBO_S'),
equal('DY', 'PINF', 'FIX'),
equal('DZ', 'PINF', 'FIX'),
]
_excit = AFFE_CHAR_MECA(MODELE=self.model, LIAISON_GROUP=liaison_group)
return [
_F(CHARGE=_excit),
]
def rigid_load(self):
"""Compute the rigid body loading"""
from code_aster.Cata.Commands import AFFE_CHAR_MECA
coeur = self.coeur
_excit_rigid = AFFE_CHAR_MECA(
MODELE=self.model, LIAISON_SOLIDE=coeur.cl_rigidite_grille())
return [
_F(CHARGE=_excit_rigid),
]
def dechargePSC(self, RESU):
from code_aster.Cata.Commands import (CALC_CHAMP, POST_RELEVE_T,
DEFI_FONCTION, AFFE_CHAR_MECA)
coeur = self.coeur
CALC_CHAMP(
reuse=RESU,
RESULTAT=RESU,
INST=coeur.temps_simu['T8'],
FORCE=('FORC_NODA', ),
)
__SPRING = POST_RELEVE_T(ACTION=_F(
INTITULE='FORCES',
GROUP_NO=('PMNT_S'),
RESULTAT=RESU,
NOM_CHAM='FORC_NODA',
NOM_CMP=('DX', ),
REPERE='GLOBAL',
OPERATION='EXTRACTION',
), )
tab2 = __SPRING.EXTR_TABLE()
valeurs = tab2.values()
inst = valeurs['INST'][-1]
fx = valeurs['DX']
noeuds = valeurs['NOEUD']
listarg = []
for el in zip(fx, noeuds):
listarg.append(_F(NOEUD=el[1], FX=el[0]))
assert (inst == coeur.temps_simu['T8'])
_LI2 = DEFI_FONCTION(
NOM_PARA='INST',
PROL_DROITE='CONSTANT',
VALE=(coeur.temps_simu['T8'], 1., coeur.temps_simu['T8b'], 0.),
)
_F_EMB2 = AFFE_CHAR_MECA(
MODELE=self.model,
FORCE_NODALE=listarg,
)
return (_LI2, _F_EMB2)
def symetric_cond(self):
"""Define the boundary conditions of symetry"""
from code_aster.Cata.Commands import AFFE_CHAR_MECA
def block(grma=None, grno=None, ddl=None):
"""Block 'ddl' of 'grma/grno' to zero"""
kddl = {}.fromkeys(ddl, 0.)
kddl['GROUP_MA' if grma else 'GROUP_NO'] = grma or grno
return kddl
ddl_impo = [
block(grma='CRAYON', ddl=['DRX']),
block(grno='LISPG', ddl=['DRX', 'DRY', 'DRZ']),
block(grma=('EBOSUP', 'EBOINF'), ddl=['DRX', 'DRY', 'DRZ']),
]
_excit = AFFE_CHAR_MECA(MODELE=self.model, DDL_IMPO=ddl_impo)
return [
_F(CHARGE=_excit),
]
def Global(E=100000., Nu=0., fx=5., fy=0.):
### Lecture du maillage
asMeshG = LIRE_MAILLAGE(
FORMAT='MED',
UNITE=20, # Unité logique du fichier de maillage
NOM_MED='global', # Nom du maillage au sein du fichier
INFO=1,
)
# Nombre de noeuds physiques du maillage
nbNoeudG = asMeshG.sdj.DIME.get()[0]
dimG = 2 # Dimension du problème
### Affectation des modèles
modG = AFFE_MODELE(
MAILLAGE=asMeshG,
AFFE=(
_F(
TOUT='OUI', # Modèle de la structure
PHENOMENE='MECANIQUE',
MODELISATION='C_PLAN',
), ))
### Définition des matériaux
matG = DEFI_MATERIAU(ELAS=_F(
E=E,
NU=Nu,
), )
### Affectation des matériaux
MatG = AFFE_MATERIAU(
MAILLAGE=asMeshG,
AFFE=(_F(
TOUT='OUI',
MATER=matG,
), ),
)
### Affectation des conditions limites
# Encastrement
# GROUP_MA => group of edges
FixG = AFFE_CHAR_CINE(MODELE=modG,
MECA_IMPO=(_F(GROUP_MA='Wd', DX=0., DY=0.), ))
# Effort imposé
FdG = AFFE_CHAR_MECA(
MODELE=modG,
FORCE_CONTOUR=_F(GROUP_MA='Fd', FX=fx, FY=fy),
#FORCE_ARETE = _F(GROUP_MA='Fd',FX=0,FY=10),
#PRES_REP = _F(GROUP_MA='Fd',PRES=10),
)
# Calcul des matrices de rigidité élémentaires
matElemG = CALC_MATR_ELEM(OPTION='RIGI_MECA', MODELE=modG, CHAM_MATER=MatG)
# Calcul de la numérotation
numDDLG = NUME_DDL(MATR_RIGI=matElemG, )
# Assemblage de la matrice de rigidité
matAssG = ASSE_MATRICE(MATR_ELEM=matElemG,
NUME_DDL=numDDLG,
CHAR_CINE=FixG)
# Calcul du second membre lié aux CL de Dirichlet
vcineG = CALC_CHAR_CINE(
NUME_DDL=numDDLG,
CHAR_CINE=FixG,
)
# Calcul du second membre lié aux CL de Neumann
vecElemG = CALC_VECT_ELEM(OPTION='CHAR_MECA', CHARGE=FdG, CHAM_MATER=MatG)
vneumG = ASSE_VECTEUR(VECT_ELEM=vecElemG, NUME_DDL=numDDLG)
# Factorisation de la matrice de rigidité et prise en compte des CL de
# Dirichlet éliminées
matAssG = FACTORISER(
reuse=matAssG,
MATR_ASSE=matAssG,
METHODE='MUMPS',
)
matAssPG = matAssG.EXTR_MATR(sparse='True')
matAssPG = sp.coo_matrix((matAssPG[0], (matAssPG[1], matAssPG[2])),
shape=(2 * nbNoeudG, 2 * nbNoeudG)).tocsc()
return matAssG, vcineG, vneumG, MatG, modG, numDDLG, matAssPG
def Local(E=50000., Nu=0., fx=0., fy=0.):
### Lecture du maillage
asMeshL = LIRE_MAILLAGE(
FORMAT='MED',
UNITE=21, # Unité logique du fichier de maillage
NOM_MED='local', # Nom du maillage au sein du fichier
INFO=1,
)
# Nombre de noeuds physiques du maillage
nbNoeudL = asMeshL.sdj.DIME.get()[0]
dim = 2 # Dimension du problème
### Affectation des modèles
modL = AFFE_MODELE(
MAILLAGE=asMeshL,
AFFE=(
_F(
TOUT='OUI', # Modèle de la structure
PHENOMENE='MECANIQUE',
MODELISATION='C_PLAN',
), ))
### Définition des matériaux
matL = DEFI_MATERIAU(ELAS=_F(
E=E,
NU=Nu,
), )
### Affectation des matériaux
MatL = AFFE_MATERIAU(
MAILLAGE=asMeshL,
AFFE=(_F(
TOUT='OUI',
MATER=matL,
), ),
)
# Effort imposé
FdL = AFFE_CHAR_MECA(
MODELE=modL,
FORCE_CONTOUR=_F(GROUP_MA='Wd', FX=fx, FY=fy),
)
# Char_cine nul
blank = AFFE_CHAR_CINE(MODELE=modL,
MECA_IMPO=_F(
GROUP_MA='Wd',
DX=0.,
DY=0.,
))
# Calcul des matrices de rigidité élémentaires
matElemL = CALC_MATR_ELEM(OPTION='RIGI_MECA', MODELE=modL, CHAM_MATER=MatL)
# Calcul de la numérotation
numDDLL = NUME_DDL(MATR_RIGI=matElemL)
matAssL = ASSE_MATRICE(
MATR_ELEM=matElemL,
NUME_DDL=numDDLL,
CHAR_CINE=blank,
)
# Calcul du second membre force
vecElemL = CALC_VECT_ELEM(OPTION='CHAR_MECA', CHARGE=FdL, CHAM_MATER=MatL)
vneumL = ASSE_VECTEUR(VECT_ELEM=vecElemL, NUME_DDL=numDDLL)
# Calcul du second membre cine nul
vblank = CALC_CHAR_CINE(
NUME_DDL=numDDLL,
CHAR_CINE=blank,
)
# Assemblage de la matrice de rigidité
matAssL = FACTORISER(
reuse=matAssL,
MATR_ASSE=matAssL,
METHODE='MUMPS',
)
return matAssL, vneumL, MatL, modL, numDDLL
def lire_resu_thyc(coeur, MODELE, nom_fic):
"""XXX
À définir dans un autre module : fonction qui prend un Coeur en argument
ou un objet ThycResult avec .read(), .hydr_load()... pour récupérer les
différents résultats
"""
from code_aster.Cata.Commands import (DEFI_FONCTION, AFFE_CHAR_MECA,
AFFE_CHAR_MECA_F)
from code_aster.Cata.Syntax import _F
# Fonction multiplicative de la force hydrodynamique axiale.
# On multiplie par 0.722 les forces hydrodynamiques a froid pour obtenir
# celles a chaud.
FOHYFR_1 = 1.0 # Valeur a froid
FOHYCH_1 = 0.722 # Valeur a chaud
res = ThycResult()
f = open(nom_fic, 'r')
f2 = open(nom_fic, 'r')
cherche_rubrique_nom(f, 'EFFORTS TRANSVERSES selon X en N')
cherche_rubrique_nom(f2, 'EFFORTS TRANSVERSES selon Y en N')
line = f.readline().split()
line2 = f2.readline().split()
line2 = f2.readline().split()
fline=f.readline().split()
version=None
if (fline[0] == "ep(m)"):
version = "Old"
elif (fline[0] == "Z(m)"):
version = "New"
else :
raise KeyError("invalid thyc result file")
# Recuperation de l'epaisseur des mailles dans Thyc
#epaisseur = f.readline().split()
#if (epaisseur[0] != "ep(m)"):
#raise KeyError("invalid epaisseur")
if version == "Old" :
cote = f.readline().split()
else :
cote=fline
#if (cote[0] != "Z(m)"):
#raise KeyError("invalid cote axial")
epaisseur = compute_ep_from_Z(cote)
j = 0
pos_thyc = []
for i in range(2, len(cote)):
# Positionnement des grilles
if ((coeur.altitude[j] > (string.atof(cote[i]) - string.atof(epaisseur[i]) / 2.)) & (coeur.altitude[j] < (string.atof(cote[i]) + string.atof(epaisseur[i]) / 2.))):
pos_thyc.append(i)
j = j + 1
if (j == len(coeur.altitude)):
break
for i in range(2, len(cote)):
# Positionnement des crayons pour application des efforts transverses
if ((coeur.XINFC > (string.atof(cote[i]) - string.atof(epaisseur[i]) / 2.)) & (coeur.XINFC < (string.atof(cote[i]) + string.atof(epaisseur[i]) / 2.))):
pos_gril_inf = i
if ((coeur.XSUPC > (string.atof(cote[i]) - string.atof(epaisseur[i]) / 2.)) & (coeur.XSUPC < (string.atof(cote[i]) + string.atof(epaisseur[i]) / 2.))):
pos_gril_sup = i
# Recuperation des efforts transverses sur les grilles
mcf = []
mcft = []
chThyc={}
for i in range(0, coeur.NBAC):
line = f.readline().split()
line2 = f2.readline().split()
print 'line = ',line
print 'line2 = ',line2
posi_aster1 = coeur.position_fromthyc(int(line[0]),int(line[1]))
posi_aster2 = coeur.position_fromthyc(int(line2[0]),int(line2[1]))
if (posi_aster1 != posi_aster2):
raise KeyError("position d assemblage avec ordre different")
for j in range(0, len(pos_thyc)):
chThyc['X']=string.atof(line[pos_thyc[j]]) / 4.0
chThyc['Y']=string.atof(line2[pos_thyc[j]]) / 4.0
chAsterY=coeur.coefFromThyc('Y')*chThyc[coeur.axeFromThyc('Y')]
chAsterZ=coeur.coefFromThyc('Z')*chThyc[coeur.axeFromThyc('Z')]
#print 'chAsterY , type()',chAsterY,type(chAsterY)
mtmp = (_F(GROUP_NO='G_' + posi_aster1 + '_' + str(j + 1), FY=chAsterY , FZ=chAsterZ),)
mcf.extend(mtmp)
chThyc['X']=definir_chargement_transverse(cote, epaisseur, pos_thyc, line, coeur.coefToThyc('X'))
chThyc['Y']=definir_chargement_transverse(cote, epaisseur, pos_thyc, line2, coeur.coefToThyc('Y'))
_resu_fy = chThyc[coeur.axeFromThyc('Y')]
_resu_fz = chThyc[coeur.axeFromThyc('Z')]
mtmp = (
_F(GROUP_MA='CR_' + posi_aster1, FY=_resu_fy, FZ=_resu_fz),)
mcft.extend(mtmp)
_co = AFFE_CHAR_MECA(MODELE=MODELE, FORCE_NODALE=mcf)
res.chtr_nodal = _co
_co = AFFE_CHAR_MECA_F(MODELE=MODELE, FORCE_POUTRE=mcft)
res.chtr_poutre = _co
# Recuperation des efforts axiaux
cherche_rubrique_nom(
f, 'FORCE HYDRODYNAMIQUE AXIALE')
line = f.readline().split()
line = f.readline().split()
line = f.readline().split()
mcp = []
mcpf = []
for i in range(0, coeur.NBAC):
line = f.readline().split()
posi_aster=coeur.position_fromthyc(int(line[0]),int(line[1]))
idAC = coeur.position_todamac(posi_aster)
print coeur.collAC.keys()
ac = coeur.collAC[idAC]
KTOT = ac.K_GRM * \
(ac.NBGR - 2) + ac.K_GRE * 2 + ac.K_EBSU + ac.K_TUB + ac.K_EBIN
# Force axiale pour une grille extremite (inf)
mtmp = (_F(GROUP_NO='G_' + posi_aster + '_' + str(1),
FX=string.atof(line[2]) / FOHYCH_1 * ac.K_GRE / KTOT / 4.0),)
mcp.extend(mtmp)
# Force axiale pour chacune des grilles de mélange
for j in range(1, ac.NBGR - 1):
mtmp = (_F(GROUP_NO='G_' + posi_aster + '_' + str(j + 1),
FX=string.atof(line[2]) / FOHYCH_1 * ac.K_GRM / KTOT / 4.0),)
mcp.extend(mtmp)
# Force axiale pour une grille extremite (sup)
mtmp = (_F(GROUP_NO='G_' + posi_aster + '_' + str(ac.NBGR),
FX=string.atof(line[2]) / FOHYCH_1 * ac.K_GRE / KTOT / 4.0),)
mcp.extend(mtmp)
# Force axiale pour l'embout inferieur
mtmp = (
_F(GROUP_NO='PI_' + posi_aster, FX=string.atof(line[2]) / FOHYCH_1 * ac.K_EBIN / KTOT),)
mcp.extend(mtmp)
# Force axiale pour l'embout superieur
mtmp = (
_F(GROUP_NO='PS_' + posi_aster, FX=string.atof(line[2]) / FOHYCH_1 * ac.K_EBSU / KTOT),)
mcp.extend(mtmp)
# Force axiale pour les crayons (appel a DEFI_FONCTION)
vale = string.atof(line[2]) / FOHYCH_1 * \
ac.K_TUB / KTOT * ac.NBCR / \
(ac.NBCR + ac.NBTG) / ac.LONCR
_FXC = DEFI_FONCTION(
NOM_PARA='X', PROL_DROITE='CONSTANT', PROL_GAUCHE='CONSTANT',
VALE=(ac.XINFC, vale, ac.XSUPC, vale))
mtmp = (_F(GROUP_MA='CR_' + posi_aster, FX=_FXC),)
mcpf.extend(mtmp)
# Force axiale pour les tubes-guides (appel a DEFI_FONCTION)
vale = string.atof(line[2]) / FOHYCH_1 * ac.K_TUB / KTOT * ac.NBTG / (
ac.NBCR + ac.NBTG) / ac.LONTU
_FXT = DEFI_FONCTION(
NOM_PARA='X', PROL_DROITE='CONSTANT', PROL_GAUCHE='CONSTANT',
VALE=(ac.XINFT, vale, ac.XSUPT, vale))
mtmp = (_F(GROUP_MA='TG_' + posi_aster, FX=_FXT),)
mcpf.extend(mtmp)
_co = AFFE_CHAR_MECA(MODELE=MODELE, FORCE_NODALE=mcp)
res.chax_nodal = _co
_co = AFFE_CHAR_MECA_F(MODELE=MODELE, FORCE_POUTRE=mcpf)
res.chax_poutre = _co
return res