- l_copo = [grma.strip() for grma in self['GROUP_MA']]
- nbcop = len(l_copo)
- l_charg = [charg['CHARGE'] for charg in self['EXCIT']]
-
- __ener = POST_ELEM(MODELE=self['MODELE'],
- RESULTAT=self['RESULTAT'],
- CHARGE=l_charg,
- TOUT_ORDRE='OUI',
- ENER_ELAS=_F(GROUP_MA=l_copo),
- TITRE='Energie élastique',)
-
- t_enel = __ener.EXTR_TABLE()
-
- # 2.1. ----- Indice de chaque copeau et deltaL
- d_icop = dict(zip(l_copo, range(1, nbcop + 1)))
-
- l_lieu = [grma.strip() for grma in t_enel.LIEU.values()]
- l_icop = [d_icop[grma] for grma in l_lieu]
- t_enel['ICOP'] = l_icop
- t_enel.fromfunction('DELTAL', fDL, 'ICOP', { 'pascop' : self['PAS_ENTAILLE'] })
-
- # 2.2. ----- Calcul de Gp fonction de Ener.Totale et de deltaL
- t_enel.fromfunction('GP', fGp_Etot, ('TOTALE', 'ICOP'),
- { 'pascop' : self['PAS_ENTAILLE'],
- 'syme' : self['SYME_CHAR'] != 'SANS',
- 'R' : self['RAYON_AXIS'] })
-
- # 2.3. ----- Tableau de Gp = f(icop) pour chaque instant
- if info >= 2:
- tGp_t_icop = t_enel['INST', 'DELTAL', 'GP']
- tGp_t_icop.titr = "Gp à chaque instant en fonction de la distance au " \
- "fond d'entaille"
- tGp_t_icop.ImprTabCroise()
-
- # 2.4. ----- Table Gpmax
- ttmp = t_enel['NUME_ORDRE', 'INST', 'ICOP', 'DELTAL', 'GP']
- l_numord = list(Set(ttmp.NUME_ORDRE.values()))
- l_numord.sort()
- for j in l_numord:
- tj = ttmp.NUME_ORDRE == j
- if self['CRIT_MAXI_GP'] == 'ABSOLU':
- t = tj.GP.MAXI()
+
+ l_copo_tot = [grma.strip() for grma in self['GROUP_MA']]
+ nbcop_tot = len(l_copo_tot)
+ nbcop = nbcop_tot/nb_tranches
+
+ if self['LIST_EP_COPEAUX'] is not None:
+ l_ep_copeaux_tot = self['LIST_EP_COPEAUX']
+
+ l_t_enel = []
+
+ if self['TRAC_COMP']=='OUI':
+ # prise en compte de la traction-compression dans le calcul de l'energie
+ resu2=CALC_ELEM(OPTION=('EQUI_ELNO_SIGM'),
+ RESULTAT=self['RESULTAT'],
+ )
+
+ # indices des mailles du dernier group_ma
+ # (pour avoir le nombre de mailles par tranche)
+ l_mailles_last_gm = maya.GROUPEMA.get()[l_copo_tot[-1].ljust(8)]
+
+ # initialisation des concepts reutilises dans la boucle
+ # on suppose que chaque tranche a le meme nombre de mailles
+
+ kk = 0
+
+ E_el = [None]*len(l_mailles_last_gm)*nb_tranches
+
+ T_el = [None]*len(l_mailles_last_gm)*nb_tranches
+
+ # on recupere les sd en dehors de la boucle
+ maya_GROUPEMA = maya.GROUPEMA.get()
+ maya_NOMMAI = maya.NOMMAI.get()
+ maya_CONNEX = maya.CONNEX.get()
+ maya_NOMNOE = maya.NOMNOE.get()
+
+ # liste des tables tb_Gpmax repartie aux noeuds
+ l_tb_Gpmax_noeuds = []
+
+ for i in range(0,nb_tranches):
+ l_copo = l_copo_tot[i*nbcop:(i+1)*nbcop]
+ l_charg = [charg['CHARGE'] for charg in self['EXCIT']]
+
+ if info >= 2 and not is_2D:
+ print "<I> Calcul de la tranche %i"%(i+1)
+
+ if self['TRAC_COMP']=='OUI':
+
+ # l_copo est une liste commulative de mailles
+ # il faut lancer POST_ELEM sur chaque maille de chaque copeau
+ # puis regarder la trace de SIEF_ELGA sur ce copeau
+
+ # on fera attention a ne pas lancer POST_ELEM sur une maille qui
+ # a deja ete calculee en stockant son resultat pour la maille en question
+ d_groupma={}
+ d_nomma={}
+
+ # indices des mailles des copeaux
+ for group_ma in l_copo:
+ d_groupma[group_ma] = maya_GROUPEMA[group_ma.ljust(8)]
+
+ # le dernier copeau contient tous les elements
+ # on calcule l energie de chaque element de ce copeau
+ last_copo = l_copo[-1]
+
+ d_ener = {}
+
+ d_nomma = {}
+
+ for k, id_elem in enumerate(d_groupma[last_copo]):
+
+
+ # les id des elements dans Aster commencent a 1
+ # la liste python commence a 0
+ elem = maya_NOMMAI[id_elem-1]
+ d_nomma[id_elem]=elem
+
+ E_el[kk] = POST_ELEM(MODELE=self['MODELE'],
+ RESULTAT=self['RESULTAT'],
+ CHARGE=l_charg,
+ TOUT_ORDRE='OUI',
+ ENER_ELAS=_F(MAILLE=elem),
+ TITRE='Energie élastique',)
+
+ T_el[kk] = E_el[kk].EXTR_TABLE()
+
+ l_enel = T_el[kk].TOTALE.values()
+
+ # signe de la trace <=> signe de la composante VMIS_SG du tenseur EQUI_ELNO_SIGM,
+ # mais E_enel est par element => on fait une moyenne sur les noeuds de l'element
+
+ list_no = []
+ for ind_no in maya_CONNEX[id_elem] :
+ nomnoe = maya_NOMNOE[ind_no-1]
+ if nomnoe not in list_no :
+ list_no.append(nomnoe)
+
+ # print "liste des noeuds de la maille ", id_elem, ": ", list_no
+
+ l_inst = T_el[kk].INST.values()
+ nb_inst = len(l_inst)
+
+ T_noeuds = Table()
+ T_noeuds['INST']=l_inst
+
+ # pour chaque noeud de l'element on recupere sa trace
+ for noeud in list_no:
+
+ VM=RECU_FONCTION(RESULTAT=resu2,
+ TOUT_INST='OUI',
+ NOM_CHAM='EQUI_ELNO_SIGM',
+ NOM_CMP='VMIS_SG',
+ MAILLE=elem,
+ NOEUD=noeud);
+
+ T_noeuds[noeud]=VM.Ordo()
+
+ DETRUIRE(CONCEPT=(_F(NOM=VM)))
+
+ T_noeuds.fromfunction('VM_MAIL', moyenne, list_no)
+
+ l_VM_MAIL = T_noeuds.VM_MAIL.values()
+
+ for j, vm in enumerate(l_VM_MAIL):
+ if vm < 0:
+ l_enel[j]=-l_enel[j]
+
+ del T_el[kk]['TOTALE']
+ T_el[kk][elem]=l_enel
+
+ if k==0:
+
+ # Table de l'energie elastique sur le GROUP_MA
+ T_el_gm = Table()
+ T_el_gm['NUME_ORDRE'] = T_el[kk].NUME_ORDRE.values()
+ T_el_gm['INST'] = T_el[kk].INST.values()
+ T_el_gm['LIEU'] = [last_copo]*nb_inst
+ T_el_gm['ENTITE'] = ['GROUP_MA']*nb_inst
+
+ T_el_gm[elem]=l_enel
+
+ kk+=1
+
+ # sommation sur les mailles du group_ma:
+ l_nomma = d_nomma.values()
+ T_el_gm.fromfunction('TOTALE', mysum, l_nomma)
+
+ # Table totale
+ t_enel=Table(titr="Energie élastique")
+ t_enel['NUME_ORDRE']=T_el_gm.NUME_ORDRE.values()
+ t_enel['INST']=T_el_gm.INST.values()
+ t_enel['LIEU']=T_el_gm.LIEU.values()
+ t_enel['ENTITE']=T_el_gm.ENTITE.values()
+ t_enel['TOTALE']=T_el_gm.TOTALE.values()
+
+ # t_enel ne contient jusqu'ici que l'energie elastique du dernier copeau
+
+ # calcul de l'energie elastique pour les autres copeaux
+ T_el_sub = T_el_gm.copy()
+
+ for k in range(len(l_copo)-2,-1,-1):
+ group_ma = l_copo[k]
+ T_el_sub = T_el_sub.copy()
+ del T_el_sub['LIEU']
+ del T_el_sub['TOTALE']
+ T_el_sub['LIEU']=[group_ma]*nb_inst
+ l_id_elem = d_groupma[group_ma]
+ l_nom_elem = []
+
+ for id_elem, nom_elem in d_nomma.items():
+ if not id_elem in l_id_elem:
+ # colonne a supprimer
+ del T_el_sub[nom_elem]
+ del d_nomma[id_elem]
+ else:
+ l_nom_elem.append(nom_elem)
+
+ T_el_sub.fromfunction('TOTALE', sum_and_check, l_nom_elem)
+
+ # Table de l'energie elastique sur le GROUP_MA
+ T_el_gm_k = Table()
+ T_el_gm_k['NUME_ORDRE'] =T_el_sub.NUME_ORDRE.values()
+ T_el_gm_k['INST'] = T_el_sub.INST.values()
+ T_el_gm_k['LIEU'] = [group_ma]*nb_inst
+ T_el_gm_k['ENTITE'] = ['GROUP_MA']*nb_inst
+ T_el_gm_k['TOTALE'] = T_el_sub.TOTALE.values()
+
+ # contribution du group_ma a la table totale:
+ t_enel = merge(t_enel, T_el_gm_k)
+
+ t_enel.sort('NUME_ORDRE')
+
+ else:
+ # si self['TRAC_COMP']!='OUI'
+ # calcul classique de l'energie elastique
+
+ __ener = POST_ELEM(MODELE=self['MODELE'],
+ RESULTAT=self['RESULTAT'],
+ CHARGE=l_charg,
+ TOUT_ORDRE='OUI',
+ ENER_ELAS=_F(GROUP_MA=l_copo),
+ TITRE='Energie élastique',)
+
+ t_enel = __ener.EXTR_TABLE()
+
+ # 2.1. ----- Indice de chaque copeau et deltaL
+ d_icop = dict(zip(l_copo, range(1, nbcop + 1)))
+
+ l_lieu = [grma.strip() for grma in t_enel.LIEU.values()]
+
+ l_icop = [d_icop[grma] for grma in l_lieu]
+
+ t_enel['ICOP'] = l_icop
+
+ l_numord = list(Set(t_enel.NUME_ORDRE.values()))
+ l_numord.sort()
+
+ if self['PAS_ENTAILLE'] is not None:
+ t_enel.fromfunction('DELTAL', fDL, 'ICOP', { 'pascop' : self['PAS_ENTAILLE'] })
+ else:
+ l_ep_copeaux_tranche = l_ep_copeaux_tot[i*nbcop:(i+1)*nbcop]
+ t_enel['DELTAL'] = l_ep_copeaux_tranche*len(l_numord)
+
+ # 2.2. ----- Calcul de Gp fonction de Ener.Totale et de deltaL
+ if is_2D:
+ t_enel.fromfunction('GP', fGp_Etot, ('TOTALE', 'DELTAL'),
+ {'syme' : self['SYME_CHAR'] != 'SANS',
+ 'R' : self['RAYON_AXIS'],})