from InterfaceQT4 import eficas_go
-dico=eficas_go.lance_eficas_param(code=prefs.code,fichier="/local00/home/A96028/GitEficas/eficas/Adao/exemple01.comm",version="V760",macro="ASSIMILATION_STUDY")
+dico=eficas_go.lanceEficas_param(code=prefs.code,fichier="/local00/home/A96028/GitEficas/eficas/Adao/exemple01.comm",version="V760",macro="ASSIMILATION_STUDY")
#print dico
import pprint
from InterfaceQT4 import eficas_go
print eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
def getIconName(self):
"""Return name of icon to be displayed normally."""
- def GetSelectedIconName(self):
+ def getSelectedIconName(self):
"""Return name of icon to be displayed when selected."""
def getSubList(self):
"""Return list of items forming sublist."""
- def OnDoubleClick(self):
+ def onDoubleClick(self):
"""Called on a double-click on the item."""
class Delegate(object):
self.object = delegate
self.__cache = {}
- def setdelegate(self, delegate):
+ def setDelegate(self, delegate):
self.resetcache()
self.object = delegate
- def getdelegate(self):
+ def getDelegate(self):
return self.object
def __getattr__(self, name):
if format in generator.plugins :
# Le generateur existe on l'utilise
g=generator.plugins[format]()
- g.init_jdc(self.node.getJdc())
+ g.initJdc(self.node.getJdc())
texte=g.gener(self.node)
else:
print ("Le generateur n'a pas ete trouve")
return text[1:i],''
class ENTITE(object):
- def cherche_enfants(self):
+ def chercheEnfants(self):
try :
self.text = self.text.strip()
liste = re.split(u'=',self.text,1)
self.creeMc(nom_mc,arg_mc,reste[0:4])
else :
self.text = reste
- self.cherche_enfants()
+ self.chercheEnfants()
else :
# pas de = rencontre
return
except Exception as e:
- self.cr.fatal(tr("Erreur rencontree dans recherche_enfants : %s", e.__str()))
+ self.cr.fatal(tr("Erreur rencontree dans rechercheEnfants : %s", e.__str()))
def creeMc(self,nom_mc,arg_mc,test):
if test in l_noms_composes :
self.cr = CR()
self.cr.debut = "Debut commande %s" %self.nom
self.cr.fin = "Fin commande %s" %self.nom
- self.cherche_enfants()
+ self.chercheEnfants()
self.construitListeDico()
parent.cr.add(self.cr)
self.cr = CR()
self.cr.debut = "Debut mot-cle facteur ou bloc %s" %self.nom
self.cr.fin = "Fin mot-cle facteur ou bloc %s" %self.nom
- self.cherche_enfants()
+ self.chercheEnfants()
self.construitListeDico()
parent.cr.add(self.cr)
self.cr = CR()
self.cr.debut = "Debut compte-rendu catalogue %s" %self.fichier
self.cr.fin = "Fin compte-rendu catalogue %s" %self.fichier
- self.ouvrir_fichier()
+ self.ouvrirFichier()
self.liste_commandes=[]
self.liste_textes_commandes=[]
- def ouvrir_fichier(self):
+ def ouvrirFichier(self):
try :
f=open(self.fichier,'r')
self.texte_complet=f.read()
cata.analyseTexte(cata.texte_complet)
return cata
-def analyseCatalogue_commande(parent,nom_cata):
+def analyseCatalogueCommande(parent,nom_cata):
cata = CATALOGUE_CATA(parent,nom_cata)
cata.analyseCommande(cata.texte_complet)
cata.construitListeDico()
self.liste_commandes=[]
self.lignes=[]
self.fichier=fichier
- self.ouvrir_fichier()
+ self.ouvrirFichier()
self.constrListTxtCmd()
- def ouvrir_fichier(self):
+ def ouvrirFichier(self):
try :
f=open(self.fichier,'r')
self.lignes=f.readlines()
return d_study
-def check_fich(option, opt_str, fich, parser):
+def checkFich(option, opt_str, fich, parser):
"""
Fonction : parse le fichier fich (format .ini)
d_study["comm"]=comm
parser.values.studies.append(d_study)
-def print_pours(d_pours,dec=''):
+def printPours(d_pours,dec=''):
# Les fichiers includes d'abord
for k,v in list(d_pours.items()):
if k in (u"pours","comm"):continue
if "pours" in d_pours:
# Description de la poursuite
print((tr("%(v_1)s fichier poursuite: %(v_2)s", {'v_1': dec, 'v_2': d_pours["pours"]["comm"]})))
- print_pours(d_pours["pours"],dec=dec+"++")
+ printPours(d_pours["pours"],dec=dec+"++")
-def print_d_env():
+def printDEnv():
if d_env.studies is None:return
for study in d_env.studies:
print((tr("nom etude : %s", study["comm"])))
- print_pours(study,dec="++")
+ printPours(study,dec="++")
def createparser():
# creation du parser des options de la ligne de commande
nargs=2, help=tr("numero d'unite suivi du nom du fichier include"))
parser.add_option(u"-f","--fich", type="string",dest="fich",
- action="callback", callback=check_fich,
+ action="callback", callback=checkFich,
help=tr("fichier decrivant une etude"))
parser.add_option(u"-c","--cata", action="store", type="string",dest="cata",
global d_env
d_env=options
- #print_d_env()
+ #printDEnv()
return options
def getUnit(d_study,appli):
def __init__(self,texte='',parent=None,reg='oui'):
self.valeur = texte
if not parent :
- self.jdc = self.parent = CONTEXT.get_current_step()
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
else:
self.jdc = self.parent = parent
if hasattr(self.parent,'etape'):
self.niveau = self.parent.niveau
self.actif=1
self.state="unchanged"
- #self.appel = N_utils.callee_where(niveau=2)
+ #self.appel = N_utils.calleeWhere(niveau=2)
if reg=='oui' : self.register()
def isValid(self):
- le nom de la sdprod eventuellement produite (sinon None)
"""
# on recupere le contexte avant la commande commentarisee
- context_ini = self.jdc.getContexte_avant(self)
+ context_ini = self.jdc.getContexteAvant(self)
try:
# on essaie de creer un objet JDC...
CONTEXT.unsetCurrentStep()
# parent est un objet de type OBJECT (ETAPE ou MC ou JDC...)
self.valeur=valeur
if not parent :
- self.jdc = self.parent = CONTEXT.get_current_step()
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
else:
self.jdc = self.parent = parent
# La classe COMMENTAIRE n'a pas de definition. On utilise self
self.parent = parent
self.l_children = []
if formule :
- self.set_formule(formule)
+ self.setFormule(formule)
if self.parent :
self.parent.enregistre(self)
- def set_formule(self,formule):
+ def setFormule(self,formule):
"""
Stocke formule (tuple) dans l'attribut t_formule
Methode externe
# si necessaire apres en appelant la methode verifContexte
# ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
- # Ajoute a la creation (appel de reg_sd).
+ # Ajoute a la creation (appel de regSD).
self.sds_dict[sdnom]=sd
sd.nom=sdnom
def getVerifContexte(self):
#print "getVerifContexte"
- j_context=self.getContexte_avant(None)
+ j_context=self.getContexteAvant(None)
self.verifContexte(j_context)
return j_context
# self.context_ini={}
# self.procedure=None
- def getContexte_avant(self,etape):
+ def getContexteAvant(self,etape):
"""
Retourne le dictionnaire des concepts connus avant etape
On tient compte des concepts produits par le jdc pere
comme DETRUIRE ou les macros
Si etape == None, on retourne le contexte en fin de JDC
"""
- #print "jdc_include.getContexte_avant",etape,etape and etape.nom
+ #print "jdc_include.getContexteAvant",etape,etape and etape.nom
if self.etape_include:
- new_context=self.etape_include.parent.getContexte_avant(self.etape_include).copy()
+ new_context=self.etape_include.parent.getContexteAvant(self.etape_include).copy()
self.context_ini=new_context
- d= JDC.getContexte_avant(self,etape)
+ d= JDC.getContexteAvant(self,etape)
return d
def resetContext(self):
#print "jdc_include.resetContext",self,self.nom
if self.etape_include:
self.etape_include.parent.resetContext()
- new_context=self.etape_include.parent.getContexte_avant(self.etape_include).copy()
+ new_context=self.etape_include.parent.getContexteAvant(self.etape_include).copy()
self.context_ini=new_context
JDC.resetContext(self)
def getVal(self):
"""
Une autre methode qui retourne une "autre" valeur du mot cle facteur.
- Elle est utilisee par la methode get_mocle
+ Elle est utilisee par la methode getMocle
"""
l=[]
for v in self.mc_liste:
self.idracine="NUPLET"
self.affecter_parente()
- def verif_cata(self):
+ def verifCata(self):
"""
Cette methode sert a valider les attributs de l'objet de definition
de la classe NUPL
self.cr.fatal(tr("L'attribut 'statut' doit valoir 'o','f','c' ou 'd'"))
if type(self.docu) != bytes :
self.cr.fatal(tr("L'attribut 'docu' doit etre une chaine de caracteres"))
- self.verif_cata_regles()
+ self.verifCataRegles()
def __call__(self,val,nom,parent):
"""
Methode qui cree le rapport de verification du catalogue du nuplet
"""
self.cr = self.CR()
- self.verif_cata()
+ self.verifCata()
for v in self.entites :
cr = v.report()
cr.debut =tr("Debut ")+v.__class__.__name__+ ' : '
# completude
self.definition=self
# parent ne peut etre qu'un objet de type JDC
- self.jdc = self.parent = CONTEXT.get_current_step()
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
self.niveau=self.parent.niveau
self.actif=1
self.state='undetermined'
"""
return self.actif
- def set_attribut(self,nom_attr,new_valeur):
+ def setAttribut(self,nom_attr,new_valeur):
"""
Remplace la valeur de self.nom_attr par new_valeur)
"""
self.valeur = self.interpreteValeur(valeur)
self.val = valeur
self.nom = nom
- self.jdc = self.parent = CONTEXT.get_current_step()
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
self.definition=self
self.niveau = self.parent.niveau
self.actif=1
self.state='undetermined'
# Ceci est-il indispensable ???
- #self.appel = N_utils.callee_where(niveau=2)
+ #self.appel = N_utils.calleeWhere(niveau=2)
self.register()
def __repr__(self):
fonctions = l_form)
if cr == 'oui' :
if not verificateur.cr.estvide():
- self.cr.fatal(verificateur.cr.get_mess_fatal())
+ self.cr.fatal(verificateur.cr.getMessFatal())
return verificateur.isValid(),''.join(verificateur.cr.crfatal)
else:
# pas d'expression EVAL --> self non valide
return 0,"Un concept de nom %s existe deja !" %nom
return 1,''
- def verif_parametre_eval(self,param=None,cr='non'):
+ def verifParametreEval(self,param=None,cr='non'):
"""
Verifie la validite du parametre EVAL passe en argument.
Ce nouveau parametre est passe sous la forme d'un tuple : (nom,valeur)
- il a un nom
- il a une valeur qui est interpretable par l'interpreteur de FORMULEs
"""
- resu,erreur= self.verif_parametre_eval(cr=cr)
+ resu,erreur= self.verifParametreEval(cr=cr)
return resu
def report(self):
def __init__(self,module):
UserDict.__init__(self)
self.plugin_dir=module.__path__[0]
- self.plugin_set_name=module.__name__
+ self.plugin_setName=module.__name__
_module_list = glob.glob( os.path.join( self.plugin_dir,
- '%s*py' % self.plugin_set_name,
+ '%s*py' % self.plugin_setName,
)
)
_module_list.sort()
for _module_name in _module_list:
_module_name = os.path.basename(_module_name)[:-3]
- _import_name = '%s.%s' % ( self.plugin_set_name,
+ _import_name = '%s.%s' % ( self.plugin_setName,
_module_name )
try:
if isinstance(string, (six.text_type, int, float, complex)):
return string
elif isinstance(string, str):
- return _str_to_unicode(string)
+ return _str_toUnicode(string)
else:
raise EficasException("TypeError: Expected number, string or\
Unicode object!")
-def _str_to_unicode(string):
+def _str_toUnicode(string):
"""
- _str_to_unicode(string) -> unicode
+ _str_toUnicode(string) -> unicode
Tries to create a Unicode object out of the input string; assumes
the string is UTF-8 encoded; if not, then assume the string is
Latin-9 encoded.
class ASSD:
def __repr__(self):
return tr("concept %(inst_name)s de type %(class_name)s", \
- {'inst_name': self.get_name(), \
+ {'inst_name': self.getName(), \
'class_name': self.__class__.__name__})
def __str__(self):
- return self.get_name() or "<None>"
+ return self.getName() or "<None>"
#def __del__(self):
# print "__del__",self
class CO(ASSD):
def __convert__(cls,valeur):
if hasattr(valeur,'_etape') :
- # valeur est un concept CO qui a ete transforme par type_sdprod
+ # valeur est un concept CO qui a ete transforme par typeSDProd
if valeur.etape == valeur._etape:
# le concept est bien produit par l'etape
return valeur
return self.nom
def getSdname(self):
- #print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
+ #print "SDNAME ",self.reuse,self.sd,self.sd.getName()
if CONTEXT.debug :
- print(("SDNAME ", self.reuse, self.sd, self.sd.get_name()))
+ print(("SDNAME ", self.reuse, self.sd, self.sd.getName()))
sdname=''
if self.reuse != None:
- sdname= self.reuse.get_name()
+ sdname= self.reuse.getName()
else:
- if self.sd:sdname=self.sd.get_name()
+ if self.sd:sdname=self.sd.getName()
if sdname.find('sansnom') != -1 or sdname.find('SD_') != -1:
# dans le cas ou la SD est 'sansnom' ou 'SD_' on retourne la chaine vide
return ''
Retourne la liste des noms de concepts utilisesa l'interieur de la commande
qui sont du type que peut retourner cette commande
"""
- liste_sd = self.get_sd_utilisees()
+ liste_sd = self.getSd_utilisees()
l_noms = []
if type(self.definition.sd_prod) == types.FunctionType:
d=self.creeDictValeurs(self.mc_liste)
interpreteur = interpreteur_formule.Interpreteur_Formule
- def McBuild(self):
+ def MCBuild(self):
self.mc_liste=self.build_mc()
# on cree la liste des types autorises (liste des noms de mots-cles
# simples dans le catalogue de FORMULE)
la string vide sinon
"""
if self.sd :
- return self.sd.get_name()
+ return self.sd.getName()
else:
return ''
# du coup on est oblige de modifier le dictionnaire valeur de self ...
self.valeur = {}
self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps
- self.McBuild()
+ self.MCBuild()
sd = self.getSdProd()
if sd:
sd.nom = formule[0]
"""
Retourne la liste des concepts avant etape d'un type acceptable
"""
- d=self.getContexte_avant(etape)
+ d=self.getContexteAvant(etape)
l=[]
if etapeTraitee==etapeStop:
break
if etapeTraitee.nom == 'VARIABLE' :
- variable=etapeTraitee.get_mocle('ModelVariable')
+ variable=etapeTraitee.getMocle('ModelVariable')
if variable != None :
l.append(variable.nom)
return l
#def set_Copules_recalcule_etat(self):
# for etapeTraitee in self.etapes :
# if etapeTraitee.nom == 'CORRELATION' :
- #Matrix=etapeTraitee.get_child('Matrix')
+ #Matrix=etapeTraitee.getChild('Matrix')
#if Matrix !=None :
- # Correlation=etapeTraitee.get_child('CorrelationMatrix')
+ # Correlation=etapeTraitee.getChild('CorrelationMatrix')
# if Correlation !=None : Correlation.state='arecalculer'
# Matrix.state='arecalculer'
#def recalculeEtatCorrelation(self):
# for etapeTraitee in self.etapes :
# if etapeTraitee.nom == 'CORRELATION' :
- #Matrix=etapeTraitee.get_child('Matrix')
+ #Matrix=etapeTraitee.getChild('Matrix')
#if Matrix !=None :
# Matrix.state='arecalculer'
- # Correlation=Matrix.get_child('CorrelationMatrix')
+ # Correlation=Matrix.getChild('CorrelationMatrix')
# if Correlation !=None : Correlation.state='arecalculer'
# Correlation.isValid()
# Matrix.isValid()
def recalculeEtatCorrelation(self):
for etapeTraitee in self.etapes :
if etapeTraitee.nom == 'CORRELATION' :
- Correlation=etapeTraitee.get_child('CorrelationMatrix')
+ Correlation=etapeTraitee.getChild('CorrelationMatrix')
if Correlation !=None :
Correlation.state='arecalculer'
Correlation.isValid()
if objet != None: objet.state='arecalculer'
if hasattr(objet,'listeMcPresents'):
for childNom in objet.listeMcPresents():
- child=objet.get_child(childNom)
+ child=objet.getChild(childNom)
if hasattr(objet,'_updateConditionBloc'):objet._updateConditionBloc()
self.forceRecalculBloc(child)
Attention different de la routine precedente : 1 seul type passe en parametre
Teste sur issubclass et par sur le type permis
"""
- d=self.getContexte_avant(etape)
+ d=self.getContexteAvant(etape)
l=[]
try :
typeverif=self.cata[0].__dict__[type]
return l
def chercheListAvant(self,etape,valeur):
- d=self.getContexte_avant(etape)
+ d=self.getContexteAvant(etape)
for k,v in d.items():
if issubclass(v.__class__,LASSD):
if k == valeur :
# On veut ajouter une nouvelle commande
try:
self.setCurrentStep()
- cmd=self.get_cmd(name)
+ cmd=self.getCmd(name)
# L'appel a make_objet n'a pas pour effet d'enregistrer l'etape
# aupres du step courant car editmode vaut 1
# Par contre elle a le bon parent grace a setCurrentStep
return []
def getSdAvantEtape(self,nom_sd,etape):
- return self.getContexte_avant(etape).get(nom_sd,None)
+ return self.getContexteAvant(etape).get(nom_sd,None)
def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'):
"""
comme DETRUIRE ou les macros
Si etape == None, on retourne le contexte en fin de JDC
"""
- if not etape: return self.getContexte_avant(etape)
+ if not etape: return self.getContexteAvant(etape)
- d=self.getContexte_avant(etape)
+ d=self.getContexteAvant(etape)
if etape.isActif():etape.updateContext(d)
self.index_etape_courante=self.index_etape_courante+1
return d
#derniere etape du jdc : rien a faire
return
- context=self.getContexte_avant(etape)
+ context=self.getContexteAvant(etape)
for e in self.etapes[index_etape:]:
e.controlSdprods(context)
def analyse(self):
self.compile()
if not self.cr.estvide():return
- self.exec_compile()
+ self.execCompile()
self.activeEtapes()
def registerParametre(self,param):
l_fonctions = []
# on recupere le contexte avant etape
# on ne peut mettre dans les deux listes que des elements de ce contexte
- d=self.getContexte_avant(etape)
+ d=self.getContexteAvant(etape)
# construction de l_constantes
for param in self.params:
nom = param.nom
#contexte initial du jdc
context=self.condition_context.copy()
#contexte courant des concepts. Il contient les parametres
- context.update(self.getContexte_avant(etape))
+ context.update(self.getContexteAvant(etape))
try :
objet = eval(valeur,context)
return objet
"""
Cette methode ajoute etape dans la liste
des etapes self.etapes et retourne l identificateur d'etape
- fourni par l appel a g_register
+ fourni par l appel a gRegister
A quoi sert editmode ?
- Si editmode vaut 1, on est en mode edition de JDC. On cherche
self.index_etapes[etape] = len(self.etapes) - 1
else:
pass
- return self.g_register(etape)
+ return self.gRegister(etape)
#ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
def NommerSdprod(self,sd,sdnom,restrict='non'):
# XXX En mode editeur dans EFICAS, le nommage doit etre gere differemment
# Le dictionnaire g_context ne represente pas le contexte
# effectif avant une etape.
- # Il faut utiliser getContexte_avant avec indication de l'etape
+ # Il faut utiliser getContexteAvant avec indication de l'etape
# traitee.
# Cette etape est indiquee par l'attribut _etape_context qui a ete
# positionne prealablement par un appel a setEtapeContext
if CONTEXT.debug : print(("JDC.NommerSdprod ",sd,sdnom))
if self._etape_context:
- o=self.getContexte_avant(self._etape_context).get(sdnom,None)
+ o=self.getContexteAvant(self._etape_context).get(sdnom,None)
else:
o=self.sds_dict.get(sdnom,None)
raise AsException(tr(" Nom de concept deja defini : "+ sdnom))
# ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
- # Ajoute a la creation (appel de reg_sd).
+ # Ajoute a la creation (appel de regSD).
self.sds_dict[sdnom]=sd
sd.nom=sdnom
class LASSD:
def __repr__(self):
- return self.get_name()
+ return self.getName()
"""
#print ("getContexteJdc",self,self.nom)
# On recupere l'etape courante
- step=CONTEXT.get_current_step()
+ step=CONTEXT.getCurrentStep()
try:
#if 1 :
# on essaie de creer un objet JDC auxiliaire avec un contexte initial
- # Attention getContexte_avant retourne un dictionnaire qui contient
+ # Attention getContexteAvant retourne un dictionnaire qui contient
# le contexte courant. Ce dictionnaire est reactualise regulierement.
# Si on veut garder l'etat du contexte fige, il faut en faire une copie.
- context_ini = self.parent.getContexte_avant(self).copy()
+ context_ini = self.parent.getContexteAvant(self).copy()
#print "getContexteJdc",context_ini.keys()
# Indispensable avant de creer un nouveau JDC
# On ajoute egalement le concept produit dans le sds_dict du parent
# sans verification car on est sur (verification integree) que
# le nommage est possible
- j_context=self.jdc_aux.getContexte_avant(None)
+ j_context=self.jdc_aux.getContexteAvant(None)
self.g_context.clear()
context_ini=self.jdc_aux.context_ini
for k,v in j_context.items():
self.jdc_aux.context_ini=d.copy()
self.jdc_aux.current_context={}
self.jdc_aux.index_etape_courante=0
- #ATTENTION: il ne faut pas utiliser self.jdc_aux.getContexte_avant
+ #ATTENTION: il ne faut pas utiliser self.jdc_aux.getContexteAvant
#car cet appel conduit a des remontees multiples incoherentes dans le
# ou les parents.
- #get_context_avant appelle updateContext qui NE DOIT PAS appeler getContexte_avant
+ #get_context_avant appelle updateContext qui NE DOIT PAS appeler getContexteAvant
#On n'a besoin que d'un update local connaissant
# le contexte amont : d qui sert a reinitialiser self.context_ini
for e in self.etapes:
texte=texteSources+texteCond+texteNoCond+texteVcut
#print (texte)
self.buildIncludeInclude(texte)
- if CONTEXT.get_current_step()==None : CONTEXT.setCurrentStep(self)
+ if CONTEXT.getCurrentStep()==None : CONTEXT.setCurrentStep(self)
reevalue=0
def makeIncludeCarmel(self,fichier=None):
self.fichier_err=tr("Le fichier n est pas defini")
self.parent.recordUnit(999,self)
try :
- MCFils=self.get_child('FileName')
+ MCFils=self.getChild('FileName')
MCFils.setValeur(None)
except :
pass
self.old_context_fichier_init=self.contexte_fichier_init
self.parent.recordUnit(unite,self)
try :
- MCFils=self.get_child('FileName')
+ MCFils=self.getChild('FileName')
#MCFils.setValeur(fichier)
#on appelle pas setValeur qui modifie le contexte ce qui fout le bazar
#pas de modification de bloc
self.fichier_err=tr("Le fichier n est pas defini")
self.parent.recordUnit(999,self)
try :
- MCFils=self.get_child('FileName')
+ MCFils=self.getChild('FileName')
MCFils.setValeur(None)
except :
pass
self.old_context_fichier_init=self.contexte_fichier_init
self.parent.recordUnit(unite,self)
try :
- MCFils=self.get_child('FileName')
+ MCFils=self.getChild('FileName')
MCFils.setValeur(fichier)
except :
pass
if e.nom == "VARIABLE" :
e.state="modified"
try :
- mc=e.get_child('ModelVariable')
+ mc=e.getChild('ModelVariable')
mc.state="modified"
except :
pass
if e.nom == "CORRELATION" :
e.state="modified"
try :
- mc=e.get_child('Matrix')
+ mc=e.getChild('Matrix')
mc.state="modified"
- mcFeuille=mc.get_child('CorrelationMatrix')
+ mcFeuille=mc.getChild('CorrelationMatrix')
mcFeuille.state="modified"
except :
pass
self.fichier_err = ''.join(l)
self.contexte_fichier_init={}
try :
- MCFils=self.get_child('FileName')
+ MCFils=self.getChild('FileName')
MCFils.setValeur(None)
except :
pass
# on enleve les mots-cles dont l'occurrence est deja atteinte
liste_copy = copy(liste)
for k in liste_copy:
- objet = self.get_child(k,restreint = 'oui')
+ objet = self.getChild(k,restreint = 'oui')
if objet != None :
# l'objet est deja present : il faut distinguer plusieurs cas
if isinstance(objet,MCSIMP):
# on ajoute les mots cles facteurs presents dont l'occurence n'est pas atteinte
for k in listeMcPresents:
if k in liste:continue
- objet = self.get_child(k,restreint = 'oui')
+ objet = self.getChild(k,restreint = 'oui')
if isinstance(objet,MCFACT):
# un mot-cle facteur ne peut pas etre repete plus de self.max fois
if objet.definition.max > 1:
return 0
# On cherche s'il existe deja un mot cle de meme nom
- old_obj = self.get_child(objet.nom,restreint = 'oui')
+ old_obj = self.getChild(objet.nom,restreint = 'oui')
if not old_obj :
# on normalize l'objet
objet=objet.normalize()
"""
Realise l'update des blocs conditionnels fils de self
"""
- dict = self.cree_dict_condition(self.mc_liste,condition=1)
+ dict = self.creeDictCondition(self.mc_liste,condition=1)
for k,v in self.definition.entites.items():
if v.label != 'BLOC' :continue
globs= self.jdc and self.jdc.condition_context or {}
- bloc=self.get_child(k,restreint = 'oui')
- presence=v.verif_presence(dict,globs)
+ bloc=self.getChild(k,restreint = 'oui')
+ presence=v.verifPresence(dict,globs)
if presence and not bloc:
# le bloc doit etre present
# mais le bloc n'est pas present et il doit etre cree
"""
liste_ajouts = []
liste_retraits = []
- dict = self.cree_dict_condition(self.mc_liste,condition=1)
+ dict = self.creeDictCondition(self.mc_liste,condition=1)
for k,v in self.definition.entites.items():
if v.label=='BLOC' :
globs= self.jdc and self.jdc.condition_context or {}
- if v.verif_presence(dict,globs):
+ if v.verifPresence(dict,globs):
# le bloc doit etre present
- if not self.get_child(k,restreint = 'oui'):
+ if not self.getChild(k,restreint = 'oui'):
# le bloc n'est pas present et il doit etre cree
liste_ajouts.append(k)
else :
# le bloc doit etre absent
- if self.get_child(k,restreint = 'oui'):
+ if self.getChild(k,restreint = 'oui'):
# le bloc est present : il faut l'enlever
liste_retraits.append(k)
return liste_ajouts,liste_retraits
def isOblig(self):
if self.definition.statut != 'o' : return 0
- objet = self.parent.get_child(self.nom)
+ objet = self.parent.getChild(self.nom)
if len(objet) > 1 : return 0
else : return 1
isole ou d'un MCFACT appartenant a une MCList :
utilisee pour l'affichage dans l'arbre
"""
- objet = self.parent.get_child(self.nom)
+ objet = self.parent.getChild(self.nom)
# objet peut-etre self ou une MCList qui contient self ...
if objet is None or objet is self:
return tr("Erreur - mclist inexistante : %s", self.nom)
return self.jdc.appli.appliEficas.dict_reels[clefobj][val]
if type(val) != tuple :
try:
- return val.get_name()
+ return val.getName()
except:
return val
else :
s='( '
for item in val :
try :
- s=s+item.get_name()+','
+ s=s+item.getName()+','
except:
s=s+repr(item)+','
s=s+' )'
if typ == 'TXM' :return 1
return 0
+ def waitTuple(self):
+ for ss_type in self.definition.type:
+ if repr(ss_type).find('Tuple') != -1 :
+ return 1
+ return 0
+
+
def getListeValeurs(self):
"""
"""
ou un EVAL: Retourne la valeur evaluee (ou None) et le test de reussite (1 ou 0)
"""
sd = self.jdc.getSdAvantEtape(new_valeur,self.etape)
- #sd = self.jdc.getContexte_avant(self.etape).get(new_valeur,None)
+ #sd = self.jdc.getContexteAvant(self.etape).get(new_valeur,None)
#print sd
if sd is not None:
return sd,1
# contextes en mode editeur
# Normalement la methode du Noyau doit etre surchargee
# On declare l'etape du mot cle comme etape courante pour NommerSdprod
- cs= CONTEXT.get_current_step()
+ cs= CONTEXT.getCurrentStep()
CONTEXT.unsetCurrentStep()
CONTEXT.setCurrentStep(step)
step.setEtapeContext(self.etape)
# Attention : possible probleme avec include
# A priori il n'y a pas de raison de retirer les concepts non existants
# avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro
- l_sd_avant_etape = list(self.jdc.getContexte_avant(self.etape).values())
+ l_sd_avant_etape = list(self.jdc.getContexteAvant(self.etape).values())
if type(self.valeur) in (tuple,list) :
l=[]
for sd in self.valeur:
""" Retire self des declarations globales
"""
if self.definition.position == 'global' :
- etape = self.get_etape()
+ etape = self.getEtape()
if etape :
del etape.mc_globaux[self.nom]
elif self.definition.position == 'global_jdc' :
Un mot cle simple peut etre global.
"""
if self.definition.position == 'global' :
- etape = self.get_etape()
+ etape = self.getEtape()
if etape :
etape.mc_globaux[self.nom]=self
elif self.definition.position == 'global_jdc' :
self.intoProto.adapt(item)
#on ne verifie pas la cardinalite
if self.definition.validators:
- valid=self.definition.validators.verif_item(item)
+ valid=self.definition.validators.verifItem(item)
except ValError as e:
#traceback.print_exc()
valid=0
self.intoProto.adapt(item)
#on ne verifie pas la cardinalite mais on verifie les validateurs
if self.definition.validators:
- valid=self.definition.validators.verif_item(item)
+ valid=self.definition.validators.verifItem(item)
comment=""
valid=1
except ValError as e:
def valideMatrice(self,cr):
#Attention, la matrice contient comme dernier tuple l ordre des variables
if self.valideEnteteMatrice()==False :
- self.set_valid(0)
+ self.setValid(0)
if cr == "oui" : self.cr.fatal(tr("La matrice n'a pas le bon entete"))
return 0
if self.monType.methodeCalculTaille != None :
if len(self.valeur[i])!= self.monType.nbCols:
ok=0
if ok:
- self.set_valid(1)
+ self.setValid(1)
return 1
except :
#else :
if cr == 'oui' :
self.cr.fatal(tr("La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d", \
{'n_lign': self.monType.nbLigs, 'n_col': self.monType.nbCols}))
- self.set_valid(0)
+ self.setValid(0)
return 0
def updateDelegate(self):
if len(self._object) > 1:
- self.setdelegate(self._object)
+ self.setDelegate(self._object)
else:
- self.setdelegate(self._object.data[0])
+ self.setDelegate(self._object.data[0])
def panel(self,jdcdisplay,pane,node):
""" Retourne une instance de l'objet panneau associe a l'item (self)
g.gener(self.item.object, format='beautifie')
stdGener = g.getGenerateur()
loi = list(g.dictMCLois.keys())[0]
- nomLoi = loi.get_name()
+ nomLoi = loi.getName()
(fd, fichier) = tempfile.mkstemp(prefix = "openturns_graph_", suffix = ".png")
os.close(fd)
chemin = os.path.dirname(fichier)
Renomme le parametre
"""
self.object.setNom(new_nom)
- #self.object.set_attribut('nom',new_nom)
+ #self.object.setAttribut('nom',new_nom)
def getFr(self):
"""
# Modules Eficas
from Editeur import Objecttreeitem
from . import browser
-from Noyau.N_CR import justify_text
+from Noyau.N_CR import justifyText
from Accas import SalomeEntry
class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
def getListeParamPossible(self):
liste_param=[]
- l1,l2=self.jdc.getParametresFonctionsAvantEtape(self.get_etape())
+ l1,l2=self.jdc.getParametresFonctionsAvantEtape(self.getEtape())
for param in self.object.jdc.params:
if param.nom not in l1 : continue
encorevalide=self.valideItem(param.valeur)
else:
return 0
+ def waitTuple(self) :
+ return self.object.waitTuple()
+
def waitDate(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un réel, 0 sinon """
# ou si son nom de classe est CO.
# Il faut faire les 2 tests car une macro non valide peut etre
# dans un etat pas tres catholique avec des CO pas encore types
- # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
+ # et donc pas dans sdprods (resultat d'une exception dans typeSDProd)
if not valeur:valeur=self.object.valeur
if valeur in self.object.etape.sdprods:return 1
if type(valeur) is not types.InstanceType:return 0
self.setValeursParDefaut()
if self.code != '' :
- self.lecture_fichier_ini_standard()
- self.lecture_fichier_ini_integrateur()
- self.lecture_fichier_ini_utilisateur()
+ self.lectureFichierIniStandard()
+ self.lectureFichierIniIntegrateur()
+ self.lectureFichierIniUtilisateur()
if self.boutonDsMenuBar:
self.closeAutreCommande = True
#--------------------------------------
- def lecture_fichier_ini_standard(self):
+ def lectureFichierIniStandard(self):
#--------------------------------------
name='prefs_'+self.appli.code
#--------------------------------------
- def lecture_fichier_ini_integrateur(self):
+ def lectureFichierIniIntegrateur(self):
#--------------------------------------
# Verifie l'existence du fichier "standard"
# appelle la lecture de ce fichier
#--------------------------------------
- def lecture_fichier_ini_utilisateur(self):
+ def lectureFichierIniUtilisateur(self):
#--------------------------------------
# Surcharge les parametres standards par les parametres utilisateur s'ils existent
self.fic_ini_utilisateur = os.path.join(self.rep_user,self.name)
setattr(self,k,d[k])
#--------------------------------------
- def save_params(self):
+ def saveParams(self):
#--------------------------------------
# sauvegarde
# les nouveaux parametres dans le fichier de configuration utilisateur
txt_exception = None
if not jdc:
self.jdc.analyse()
- txt_exception = self.jdc.cr.get_mess_exception()
+ txt_exception = self.jdc.cr.getMessException()
if txt_exception:
self.jdc = None
QApplication.restoreOverrideCursor()
noeudACopier=self.QWParent.noeud_a_editer[0]
if (self.QWParent.edit != "couper"):
- #print (noeudOuColler.item.parent.get_child(noeudOuColler.item.nom))
+ #print (noeudOuColler.item.parent.getChild(noeudOuColler.item.nom))
try:
if noeudOuColler == self.tree.racine :
child=noeudOuColler.doPastePremier(noeudACopier)
self.tree.racine.item.getObject().nom=os.path.basename(newName)
self.tree.racine.updateNodeLabel()
- print ('Attention chgt du if pour test')
- print (self.generator)
- #if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
- if hasattr(self.generator, "writeDefault"):
+ if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
+ #if hasattr(self.generator, "writeDefault"):
self.generator.writeDefault(fn)
elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
msgBox = QMessageBox(None)
# dans le JDC
ouChercher=etape
for mot in listeAvant :
- ouChercher=ouChercher.get_child(mot,restreint="oui")
- monMC=ouChercher.get_child(MCFils,restreint="oui")
+ ouChercher=ouChercher.getChild(mot,restreint="oui")
+ monMC=ouChercher.getChild(MCFils,restreint="oui")
if monMC != None : ouChercher.suppEntite(monMC)
ouChercher.state='changed'
ouChercher.isValid()
# dans le JDC
ouChercher=etape
for mot in listeAvant :
- ouChercher=ouChercher.get_child(mot,restreint="oui")
- monMC=etape.get_child(ouChercher,restreint="oui")
+ ouChercher=ouChercher.getChild(mot,restreint="oui")
+ monMC=etape.getChild(ouChercher,restreint="oui")
if monMC== None : monMC= ouChercher.addEntite(MCFils)
monMC.valeur=valeurs
monMC.val=valeurs
ouChercher=etape
print (ouChercher)
for mot in listeAvant :
- ouChercher=ouChercher.get_child(mot,restreint="oui")
+ ouChercher=ouChercher.getChild(mot,restreint="oui")
print (mot)
print (ouChercher)
- monMC=etape.get_child(ouChercher,restreint="oui")
+ monMC=etape.getChild(ouChercher,restreint="oui")
if monMC== None : monMC= ouChercher.addEntite(MCFils)
monMC.isValid()
if debug : print ('etape trouvee', ouChercher)
if ouChercher==None : return None
for mot in listeAvant :
- ouChercher=ouChercher.get_child(mot,restreint="oui")
+ ouChercher=ouChercher.getChild(mot,restreint="oui")
if debug : print (mot, ouChercher)
if ouChercher==None : return None
- monMC=ouChercher.get_child(MCFils,restreint="oui")
+ monMC=ouChercher.getChild(MCFils,restreint="oui")
if debug : print ('monMC', monMC)
if monMC== None : return None
return monMC.valeur
if e.nom == nomEtape : ouChercher=e; break
if ouChercher==None : return None
for mot in listeAvant :
- ouChercher=ouChercher.get_child(mot,restreint="oui")
+ ouChercher=ouChercher.getChild(mot,restreint="oui")
#print (mot, ouChercher)
if ouChercher==None : return None
- monMC=ouChercher.get_child(MCFils,restreint="oui")
+ monMC=ouChercher.getChild(MCFils,restreint="oui")
monMC.setValeur(valeur)
monMC.isValid()
if ouChercher==None : return
for mot in listeAvant :
- ouChercher=ouChercher.get_child(mot,restreint="oui")
+ ouChercher=ouChercher.getChild(mot,restreint="oui")
if ouChercher==None : return
- monMC=ouChercher.get_child(MCFils,restreint="oui")
+ monMC=ouChercher.getChild(MCFils,restreint="oui")
if monMC== None : monMC= ouChercher.addEntite(MCFils)
monMC.definition.into=valeurs
for mot in listeAvant :
try :
- ouChercher=ouChercher.get_child(mot,restreint="oui")
+ ouChercher=ouChercher.getChild(mot,restreint="oui")
# Le mot clef n est pas la
except : return 0
try :
- monMC=ouChercher.get_child(MCFils,restreint="oui")
+ monMC=ouChercher.getChild(MCFils,restreint="oui")
# Le mot clef n est pas la
except : return 0
if monMC == None : return 0
ouChercher = etape
for mot in listeMC[:-1] :
- ouChercher=ouChercher.get_child(mot,restreint="oui")
+ ouChercher=ouChercher.getChild(mot,restreint="oui")
if ouChercher==None : return
MCFils=listeMC[-1]
- monMC=ouChercher.get_child(MCFils,restreint="oui")
+ monMC=ouChercher.getChild(MCFils,restreint="oui")
if monMC== None : monMC= etape.addEntite(MCFils)
monMC.definition.into=into
if editeurDir not in sys.path :sys.path.append(editeurDir)
-def lance_eficas(code=None,fichier=None,ssCode=None,multi=False,langue='en'):
+def lanceEficas(code=None,fichier=None,ssCode=None,multi=False,langue='en'):
"""
Lance l'appli EFICAS
"""
sys.exit(res)
-def lance_eficas_ssIhm(code=None,fichier=None,ssCode=None,version=None,debug=False,langue='en'):
+def lanceEficas_ssIhm(code=None,fichier=None,ssCode=None,version=None,debug=False,langue='en'):
"""
Lance l'appli EFICAS pour trouver les noms des groupes
"""
monEditeur=JDCEditor(Eficas,fichier)
return monEditeur
-def lance_eficas_ssIhm_chercheGroupes(code=None,fichier=None,ssCode=None,version=None):
- monEditeur=lance_eficas_ssIhm(code,fichier,ssCode,version)
+def lanceEficas_ssIhm_chercheGroupes(code=None,fichier=None,ssCode=None,version=None):
+ monEditeur=lanceEficas_ssIhm(code,fichier,ssCode,version)
print((monEditeur.chercheGroupes()))
-def lance_eficas_ssIhm_cherche_cr(code=None,fichier=None,ssCode=None,version=None):
- monEditeur=lance_eficas_ssIhm(code,fichier,ssCode,version)
+def lanceEficas_ssIhm_cherche_cr(code=None,fichier=None,ssCode=None,version=None):
+ monEditeur=lanceEficas_ssIhm(code,fichier,ssCode,version)
print((monEditeur.jdc.cr))
-def lance_eficas_ssIhm_reecrit(code=None,fichier=None,ssCode=None,version=None,ou=None,cr=False,debug=False,leger=False,langue='ang'):
- #print 'lance_eficas_ssIhm_reecrit', fichier
- monEditeur=lance_eficas_ssIhm(code,fichier,ssCode,version,langue=langue)
+def lanceEficas_ssIhm_reecrit(code=None,fichier=None,ssCode=None,version=None,ou=None,cr=False,debug=False,leger=False,langue='ang'):
+ #print 'lanceEficas_ssIhm_reecrit', fichier
+ monEditeur=lanceEficas_ssIhm(code,fichier,ssCode,version,langue=langue)
if ou == None :
fileName=fichier.split(".")[0]+"_reecrit.comm"
fn=fichier.split(".")[0]+"_cr.txt"
f.write(str(monEditeur.jdc.report()))
f.close()
-def lance_eficas_param(code='Adao',fichier=None,version='V0',macro='ASSIMILATION_STUDY'):
+def lanceEficas_param(code='Adao',fichier=None,version='V0',macro='ASSIMILATION_STUDY'):
"""
Lance l'appli EFICAS pour trouver les noms des groupes
"""
parameters=getJdcParameters(texte,macro)
return parameters
-def getEficasSsIhm(code='Adao',version='V0'):
+def getEficasSsIhm(code='Adao',versionCode='V0'):
from .qtEficasSsIhm import AppliSsIhm
app = QApplication(sys.argv)
Eficas=Appli(code=code,ssCode=None,salome=0)
if __name__ == "__main__":
import sys
sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..')))
- lance_eficas(code=None,fichier=None,ssCode=None,multi=True)
+ lanceEficas(code=None,fichier=None,ssCode=None,multi=True)
else :
if mc.min == mc.max:
commentaire=tr("Entrez ")+str(mc.min)+" "+tr(d_aides[type])+'\n'
+ elif mc.max == float('inf') :
+ commentaire=tr("Entrez une liste de ") + tr(d_aides[type])+'\n'
else :
commentaire=tr("Entrez entre ")+"\n"+str(mc.min)+(" et ")+str(mc.max) +" " +tr(d_aides[type])+'\n'
aideval=self.node.item.aide()
self.maCommande.listeAffichageWidget.append(self.lineEditVal1)
self.AAfficher=self.lineEditVal1
self.inInit=False
+ # PNPN a completer __ si tuple le type des tuples sinon le tuple
+ self.monCommentaireLabel.setText(self.finCommentaireListe())
def setValeurs(self):
if self.node.item.isValid() == 0 :
liste=[]
for item in self.listeValeursCourantes:
- if self.node.item.definition.validators.verif_item(item)==1:
+ if self.node.item.definition.validators.verifItem(item)==1:
liste.append(item)
self.listeAAfficher=self.node.item.getListePossible(liste)
else:
if self.node.item.isValid() == 0 :
liste=[]
for item in self.listeValeursCourantes:
- if self.node.item.definition.validators.verif_item(item)==1: liste.append(item)
+ if self.node.item.definition.validators.verifItem(item)==1: liste.append(item)
self.listeAAfficher=self.node.item.getListePossible(liste)
else:
self.listeAAfficher=self.node.item.getListePossible([])
valeur=eval(val,{})
except :
try :
- d=self.parentQt.objSimp.jdc.getContexte_avant(self.parentQt.objSimp. etape)
+ d=self.parentQt.objSimp.jdc.getContexteAvant(self.parentQt.objSimp. etape)
valeur=eval(val,d)
except :
valeur=val
valeur=eval(val,{})
except :
try :
- d=self.parentQt.objSimp.jdc.getContexte_avant(self.parentQt.objSimp. etape)
+ d=self.parentQt.objSimp.jdc.getContexteAvant(self.parentQt.objSimp. etape)
valeur=eval(val,d)
except :
valeur=val
if hasattr(self.objSimp.jdc,'LineDico'):
for k in self.objSimp.jdc.LineDico :
try :
- valeur=self.objSimp.jdc.get_concept(k)
+ valeur=self.objSimp.jdc.getConcept(k)
val.append((valeur,0))
except :
pass
if hasattr(self.objSimp.jdc,'MachineDico'):
for k in self.objSimp.jdc.MachineDico :
try :
- valeur=self.objSimp.jdc.get_concept(k)
+ valeur=self.objSimp.jdc.getConcept(k)
val.append((valeur,0))
except :
pass
if hasattr(self.objSimp.jdc,'TransfoDico'):
for k in self.objSimp.jdc.TransfoDico :
try :
- valeur=self.objSimp.jdc.get_concept(k)
+ valeur=self.objSimp.jdc.getConcept(k)
val.append((valeur,0))
except :
pass
if hasattr(self.objSimp.jdc,'LoadDico'):
for k in self.objSimp.jdc.LoadDico :
try :
- valeur=self.objSimp.jdc.get_concept(k)
+ valeur=self.objSimp.jdc.getConcept(k)
val.append((valeur,0))
except :
pass
if hasattr(self.objSimp.jdc,'MotorDico'):
for k in self.objSimp.jdc.MotorDico :
try :
- valeur=self.objSimp.jdc.get_concept(k)
+ valeur=self.objSimp.jdc.getConcept(k)
val.append((valeur,0))
except :
pass
self.setValeurTexte(str(valeurentree))
else:
cr = self.node.item.getCr()
- commentaire = tr("Valeur du mot-cle non autorisee ")+cr.get_mess_fatal()
+ commentaire = tr("Valeur du mot-cle non autorisee ")+cr.getMessFatal()
self.node.item.setValeur(ancienneVal)
return validite, commentaire
commentaire = tr("Valeur du mot-cle enregistree")
else:
cr = self.node.item.getCr()
- commentaire = tr("Valeur du mot-cle non autorisee ")+cr.get_mess_fatal()
+ commentaire = tr("Valeur du mot-cle non autorisee ")+cr.getMessFatal()
self.node.item.setValeur(ancienneVal)
return validite, commentaire
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2017 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+
+import os, sys
+import six
+
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+from Extensions import param2
+from InterfaceQT4.viewManagerSsIhm import MyTabviewSsIhm
+
+
+from InterfaceQT4.getVersion import getEficasVersion
+
+from editorSsIhm import JDCEditorSsIhm
+
+
+class AppliSsIhm:
+ """
+ Class implementing the main user interface.
+ """
+ def __init__(self,code=None,salome=1,parent=None,ssCode=None,multi=False,langue='fr',ssIhm=True,versionCode=None):
+ """
+ Constructor
+ """
+ version=getEficasVersion()
+ self.VERSION_EFICAS="Eficas QT5 Salome " + version
+ self.version_code=versionCode
+
+ self.salome=salome
+ self.ssIhm=True
+ self.code=code
+
+ self.dict_reels={}
+ self.fichierIn=None
+ self.fichierOut=None
+
+ self.recent = []
+ self.ficRecents={}
+ self.mesScripts={}
+ self.listeAEnlever=[]
+ self.ListePathCode=['Adao','ADAO','Carmel3D','Telemac','CF','MAP','ZCracks', 'SEP','SPECA','PSEN_Eficas','PSEN_N1']
+ self.listeCode=['Adao','ADAO','Carmel3D','Telemac','CF','MAP','ZCracks', 'SEP','SPECA','PSEN_Eficas','PSEN_N1']
+ self.repIcon=os.path.join( os.path.dirname(os.path.abspath(__file__)),'..','Editeur','icons')
+
+ if self.salome:
+ import Accas
+ try :
+ import eficasSalome
+ Accas.SalomeEntry = eficasSalome.SalomeEntry
+ except :
+ print ('eficas hors salome')
+
+ self.multi=multi
+ self.demande=multi # specifique PSEN
+
+ if langue=='fr': self.langue=langue
+ else : self.langue="ang"
+
+ if self.multi == False :
+ self.definitCode(code,ssCode)
+ if code==None: return
+
+ self.suiteTelemac=False
+ self.viewmanager = MyTabviewSsIhm(self)
+
+
+ def definitCode(self,code,ssCode) :
+ self.code=code
+ self.ssCode=ssCode
+ if self.code == None:return # pour le cancel de la fenetre choix code
+
+ name='prefs_'+self.code
+ prefsCode=__import__(name)
+
+ self.repIni=prefsCode.repIni
+ if ssCode != None :
+ self.format_fichier= ssCode #par defaut
+ prefsCode.NAME_SCHEME=ssCode
+ else :
+ self.format_fichier="python" #par defaut
+
+ nameConf='configuration_'+self.code
+ configuration=__import__(nameConf)
+ self.CONFIGURATION = configuration.make_config(self,prefsCode.repIni)
+ self.CONFIGStyle = None
+ if hasattr(configuration,'make_config_style'):
+ self.CONFIGStyle = configuration.make_config_style(self,prefsCode.repIni)
+
+
+
+ def fileNew(self):
+ self.viewmanager.newEditor()
+
+ def fileOpen(self,fichier):
+ self.viewmanager.handleOpen(fichier)
+
+ def fileSave(self):
+ return self.viewmanager.saveCurrentEditor()
+
+ def fileSaveAs(self,fichier):
+ return self.viewmanager.saveAsCurrentEditor(fichier)
+
+ def fileClose(self):
+ self.viewmanager.handleClose()
+
+ def jdcRapport(self):
+ return self.viewmanager.jdcRapport()
+
+ def jdcText(self):
+ return self.viewmanager.jdcText()
+
+ def jdcDico(self):
+ return self.viewmanager.jdcDico()
+
+ def jdcDicoPython(self):
+ return self.viewmanager.jdcDicoPython()
+
+ def getSource(self,file):
+ # appele par Editeur/session.py
+ # a garder pour les poursuites
+ # le format n est pas le meme que celui de la fonction jdcText
+ import convert
+ p=convert.plugins['python']()
+ p.readfile(file)
+ texte=p.convert('execnoparseur')
+ return texte
+
+if __name__=='__main__':
+
+ # Modules Eficas
+ monEficas= AppliSsIhm(code='Adao',salome=0,versionCode='V83')
self.viewmanager.handleOpen(fichier=study["comm"],units=d)
- def get_source(self,file):
+ def getSource(self,file):
# appele par Editeur/session.py
import convert
p=convert.plugins['python']()
if hasattr(self,"lineEditVal"):self.lineEditVal.setText(valeur)
nouvelleValeur=valeur
if self.node.item.definition.validators != None :
- if self.node.item.definition.validators.verif_item(nouvelleValeur) !=1 :
+ if self.node.item.definition.validators.verifItem(nouvelleValeur) !=1 :
commentaire=self.node.item.definition.validators.infoErreurItem()
self.editor.afficheInfos(commentaire,Qt.red)
self.inSaisieValeur=False
self.node.updateNodeValid()
else :
cr = self.node.item.getCr()
- commentaire = tr("Valeur du mot-clef non autorisee :")+cr.get_mess_fatal()
+ commentaire = tr("Valeur du mot-clef non autorisee :")+cr.getMessFatal()
import configuration\r
\r
# Modules Eficas\r
-from Editeur import utils\r
\r
-class CONFIG(configuration.CONFIG_BASE):\r
+class CONFIG(configuration.configBase):\r
\r
#-----------------------------------\r
def __init__(self,appli,repIni):\r
self.labels_eficas=['exec_acrobat','savedir','path_doc','catalogues','closeAutreCommande','closeFrameRechercheCommande','taille']\r
\r
#self.cataFile="catalogues_MAP.ini"\r
- configuration.CONFIG_BASE.__init__(self,appli,repIni)\r
+ configuration.configBase.__init__(self,appli,repIni)\r
\r
def make_ssCode(self,ssCode):\r
if ssCode == None : return\r
# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
+# maConfiguration MANAGEMENT OF EDF VERSION
# RESPONSABLE D6BHHHH J-P.LEFEBVRE
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
CorrelationMatrix = SIMP ( statut = "o", typ = Matrice(nbLigs=None,
nbCols=None,
- methodeCalculTaille='NbDeVariables',
+ methodeCalculTaille='nbDeVariables',
valSup=1,
valMin=-1,
structure="symetrique"),
# -*- coding: utf-8 -*-\r
-# CONFIGURATION MANAGEMENT OF EDF VERSION\r
+# maConfiguration MANAGEMENT OF EDF VERSION\r
# ======================================================================\r
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG\r
# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY\r
import os\r
\r
\r
-class CONFIG(configuration.CONFIG_BASE):\r
+class CONFIG(configuration.configBase):\r
\r
#-----------------------------------\r
def __init__(self,appli,repIni):\r
self.labels_user=['catalogues','lang']\r
self.labels_eficas=['lang','rep_cata','catalogues']\r
\r
- configuration.CONFIG_BASE.__init__(self,appli,'.Eficas_monCode')\r
+ configuration.configBase.__init__(self,appli,'.Eficas_monCode')\r
\r
\r
def make_config(appli,rep):\r
from PyQt4.QtCore import *
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
+# maConfiguration MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
+# maConfiguration MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
## """\r
## """\r
## if NOEUD is not None:\r
-## self.type_sdprod(NOEUD, Noeud)\r
+## self.typeSDProd(NOEUD, Noeud)\r
## pass\r
## else:\r
## raise AsException("Impossible de typer les concepts resultats")\r
## """\r
## """\r
## if NOEUD is not None:\r
-## self.type_sdprod(NOEUD, Noeud)\r
+## self.typeSDProd(NOEUD, Noeud)\r
## pass\r
## else:\r
## raise AsException("Impossible de typer les concepts resultats")\r
--- /dev/null
+## -*- coding: utf-8 -*-
+#
+## --------------------------------------------------
+## debut entete
+## --------------------------------------------------
+#
+# 20120510 : suppression de la valeur par defaut de MATERIAU->PARAMETRES_MAT->NU
+# changement du nom MATERIAU->PARAMETRES_MAT->MASS_VOL en MATERIAU->PARAMETRES_MAT->RHO
+#
+# 20120619 : changement ordre d'affichage des macros -> ordre de création
+# 20120725 : modification definition (matrices A,K,M) palier et support
+# 20130411 : ajout elements dans palier generalise (mail tdg + comm tdg)
+#
+# todo : supprimer les noeuds -> definir les elements par leur longueur
+#
+#
+#
+#
+#
+
+
+
+
+
+
+
+
+from Accas import *
+#
+
+import types
+class Tuple:
+ def __init__(self,ntuple):
+ self.ntuple=ntuple
+
+ def __convert__(self,valeur):
+ if type(valeur) == types.StringType:
+ return None
+ if len(valeur) != self.ntuple:
+ return None
+ return valeur
+
+ def info(self):
+ return "Tuple de %s elements" % self.ntuple
+
+ __repr__=info
+ __str__=info
+
+
+#CONTEXT.debug = 1
+VERSION_CATALOGUE="2017.0.0";
+JdC = JDC_CATA(code = 'MT',
+ execmodul = None,
+ regles = (AU_MOINS_UN ( 'LIGNE_ARBRE',),
+ AU_PLUS_UN ( 'LIGNE_ARBRE',)),
+ ) # Fin JDC_CATA
+
+class Direction(ASSD): pass
+class Materiau(ASSD): pass
+#class Masse(ASSD): pass
+class Zone(ASSD): pass
+class Palier(ASSD): pass
+#class Masse(ASSD): pass
+#class ConditionsAuxLimites(ASSD): pass
+class LigneArbre(ASSD): pass
+class Support(ASSD): pass
+class Butee(ASSD): pass
+class PalTor(ASSD):pass
+#class Noeud(ASSD): pass
+
+## def macro_noeuds(self, NOEUD, **args):
+## """
+## """
+## if NOEUD is not None:
+## self.typeSDProd(NOEUD, Noeud)
+## pass
+## else:
+## raise AsException("Impossible de typer les concepts resultats")
+
+## return Noeuds
+
+############################# MATERIAUX ########################################
+# @todo
+# introduction manuelle => dans ce cas l'utilisateur definit le
+# materiau comme ci-dessous
+# recuperation depuis une bibliothÚque de materiau => sera specife
+# plus tard
+MATERIAUX = MACRO(nom = 'MATERIAUX',
+ op = None,
+ sd_prod = Materiau,
+ reentrant = 'n',
+ UIinfo = {"groupes": ("Machine tournante",)},
+ fr = "Renseignement des caracteristiques des materiaux",
+ TYPE_INTRO = SIMP(statut='o',
+ fr = "Mode de description des caracteristiques des materiaux",
+ typ='TXM',
+ into=('MANUELLE','FICHIER'),
+ min=1,
+ max=1,
+ defaut='MANUELLE',
+ ), # end TYPE_INTRO
+ PARAMETRES_MAT = BLOC(condition = "((TYPE_INTRO == 'MANUELLE') )",
+ #MASS_VOL = SIMP(statut='o', typ='R', min=1, max=1, fr='masse volumique'),
+ fr = "Saisie manuelle des caracteristiques du materiau",
+ RHO = SIMP(statut='o',
+ typ='R',
+ min=1,
+ max=1,
+ fr='Masse volumique (kg/m**3)',
+ ), # end RHO
+ E = SIMP(statut='o',
+ typ='R',
+ min=1,
+ max=1,
+ fr="Module d'Young (Pa)",
+ ), # end E
+ NU = SIMP(statut='o',
+ typ='R',
+ min=1,
+ max=1,
+ val_min=-1.0,
+ val_max=0.5,
+ fr='Coefficient de cisaillement (-1.0 <= NU <= 0.5)',
+ ), # end NU
+ ALPHA = SIMP(statut='f',
+ typ='R',
+ min=1,
+ max=1,
+ fr = "Coefficient permettant de construire une matrice d'amortissement visqueux proportionnel a la rigidite",
+ ), # end ALPHA
+ BETA = SIMP(statut='f',
+ typ='R',
+ min=1,
+ max=1,
+ fr = "Coefficient permettant de construire une matrice d'amortissement visqueux proportionnel a la masse",
+ ), # end BETA
+ GAMMA = SIMP(statut='f',
+ typ='R',
+ min=1,
+ max=1,
+ fr = "Coefficient d'amortissement hysteretique permettant de definir le module d'Young complexe",
+ ), # end GAMMA
+ ), # end PARAMETRES_MAT
+ FICHIER_MAT = BLOC(condition = "((TYPE_INTRO == 'FICHIER') )",
+ MATERIAU_CATALOGUE = SIMP(statut='o',
+ fr="Fichier decrivant les caracteristiques materiaux (format decrit dans le Manuel Utilisateur)",
+ min=1,
+ max=1,
+ typ=('Fichier','Fichier materiau (*.*)'),
+ ), # end MATERIAU_CATALOGUE
+ ), # end FICHIER_MAT
+ #SIMP(typ=('Fichier','JDC Files (*.comm)'),docu='',min=1,max=1,statut='o',defaut=None)
+ ) # end MATERIAU
+
+
+
+############################# ZONES ########################################
+ZONE = MACRO(nom = 'ZONE',
+ op = None,
+ sd_prod = Zone,
+ reentrant = 'n',
+ UIinfo = {"groupes":("Machine tournante",)},
+ fr = "Description d'une zone (comportant noeuds et elements, et en option masses ponctuelles et fissures)",
+ regles = (AU_MOINS_UN("ELEMENTS")),
+ MASSE = FACT(statut='f',
+ min=0,
+ max='**',
+ fr = "Description des masses ponctuelles",
+ #POSITION = SIMP(statut='o',
+ NOEUD = SIMP(statut='o',
+ typ='TXM',
+ defaut=None,
+ fr = "Definition de la position axiale de la masse (label du noeud de la ligne d'arbres en vis-a-vis)",
+ ), # end POSITION
+ TYPE_MASSE = SIMP(statut='o',
+ typ='TXM',
+ fr = "Renseignement du type de masse consideree",
+ into=('DISQUE','AILETTE','QUELCONQUE'),
+ ), # end TYPE_MASSE
+ DISQUE = BLOC(condition = "((TYPE_MASSE == 'DISQUE') )",
+ TYPE_SAISIE = SIMP(statut='o',
+ typ='TXM',
+ fr = "Type de saisie des parametres du DISQUE",
+ into = ('MECANIQUE','GEOMETRIQUE'),
+ defaut = 'MECANIQUE'
+ ), # end TYPE_SAISIE
+ PARAMETRES_MECANIQUE = BLOC(condition = "TYPE_SAISIE == 'MECANIQUE'",
+ PARAMETRES = FACT(statut = 'o',
+ fr = "Parametres mecaniques pour un DISQUE",
+ MASSE = SIMP(statut='o',
+ typ='R',
+ val_min=0,
+ fr = "Masse du DISQUE (kg)",
+ ), # end MASSE_DISQUE
+ INERTIEX = SIMP(statut='o',
+ typ='R',
+ fr = "Inertie du DISQUE en X (kg.m**2)",
+ ), # end INERTIEX
+ INERTIEY = SIMP(statut='o',
+ typ='R',
+ fr = "Inertie du DISQUE en Y (kg.m**2)",
+ ), # end INERTIEY
+ INERTIEZ = SIMP(statut='o',
+ typ='R',
+ fr = "Inertie du DISQUE en Z (axe de rotation de la ligne d'arbres)(kg.m**2)",
+ ), # end INERTIEZ
+ ) # end PARAMETRES_DISQUE_M
+ ), # end PARAMETRES_MECANIQUE
+ PARAMETRES_GEOMETRIQUE = BLOC(condition = "TYPE_SAISIE == 'GEOMETRIQUE'",
+ PARAMETRES = FACT(statut = 'o',
+ fr = "Parametres geometriques pour un DISQUE",
+ DIAMETRE_EXT = SIMP(statut='o',
+ typ='R',
+ val_min=0,
+ fr = "Diametre exterieur du DISQUE (m)",
+ ), # end MASSE_DISQUE
+ DIAMETRE_INT = SIMP(statut='o',
+ typ='R',
+ fr = "Diametre interieur du DISQUE (m). Verifier le diametre exterieur du rotor avant saisie",
+ ), # end INERTIEX
+ EPAISSEUR = SIMP(statut='o',
+ typ='R',
+ val_min=0,
+ fr = "Epaisseur (dans la direction axiale) du DISQUE (m)",
+ ), # end INERTIEY
+ MATERIAU = SIMP(statut='o',
+ typ=Materiau,
+ fr = "Materiau constituant le DISQUE (doit avoir ete defini via une entree MATERIAUX)",
+ ), # end INERTIEZ
+ ) # nd PARAMETRES_DISQUE_G
+ ), # end PARAMETRES_MECANIQUE
+ ), # end DISQUE
+ AILETTE = BLOC(condition = "((TYPE_MASSE == 'AILETTE') )",
+ TYPE_SAISIE = SIMP(statut='o',
+ typ='TXM',
+ fr = "Type de saisie des parametres de la rangee d'AILETTES",
+ into = ('MECANIQUE','GEOMETRIQUE'),
+ defaut = 'MECANIQUE'
+ ), # end TYPE_SAISIE
+ PARAMETRES_MECANIQUE = BLOC(condition = "TYPE_SAISIE == 'MECANIQUE'",
+ PARAMETRES = FACT(statut = 'o',
+ fr = "Parametres mecaniques de la rangee d'AILETTES",
+ MASSE = SIMP(statut='o',
+ typ='R',
+ val_min=0,
+ fr = "Masse de la rangee d'AILETTES (kg)",
+ ), # end MASSE_AILETTE
+ INERTIEX = SIMP(statut='o',
+ typ='R',
+ fr = "Inertie de la rangee d'AILETTES en X (kg.m**2)",
+ ), # end INERTIEX
+ INERTIEY = SIMP(statut='o',
+ typ='R',
+ fr = "Inertie de la rangee d'AILETTES en Y (kg.m**2)",
+ ), # end INERTIEY
+ INERTIEZ = SIMP(statut='o',
+ typ='R',
+ fr = "Inertie de la rangee d'AILETTES en Z (axe de rotation de la ligne d'arbres) (kg.m**2)",
+ ), # end INERTIEZ
+ ) # nd PARAMETRES_AILETTE_M
+ ), # end PARAMETRES_MECANIQUE
+ PARAMETRES_GEOMETRIQUE = BLOC(condition = "TYPE_SAISIE == 'GEOMETRIQUE'",
+ PARAMETRES = FACT(statut = 'o',
+ fr = "Parametres geometriques d'une AILETTE",
+ MASSE_AILETTE = SIMP(statut='o',
+ typ='R',
+ val_min=0,
+ fr = "Masse d'une AILETTE (kg)",
+ ), # end MASSE_AILETTE
+ RAYON = SIMP(statut='o',
+ typ='R',
+ val_min=0,
+ fr = "Distance entre le pied de l'AILETTE et le centre de rotation (m). Verifier le diametre exterieur du rotor avant saisie",
+ ), # end RAYON
+ HAUTEUR = SIMP(statut='o',
+ typ='R',
+ val_min=0,
+ fr = "Distance entre les deux extremites de l'AILETTE (m)",
+ ), # end HAUTEUR
+ BASE = SIMP(statut='o',
+ typ='R',
+ val_min=0,
+ fr = "Largeur du pied de l'AILETTE (m)",
+ ), # end BASE
+ NOMBRE = SIMP(statut='o',
+ typ='I',
+ val_min=1,
+ fr = "Nombre d'AILETTES dans la rangee",
+ ),
+ ) # end PARAMETRES_DISQUE
+ ), # end PARAMETRES_MECANIQUE
+ ), # end AILETTE
+ QUELCONQUE = BLOC(condition = "((TYPE_MASSE == 'QUELCONQUE') )",
+ #TYPE_SAISIE = SIMP(statut='c',typ='TXM',defaut="MECANIQUE"), # cf 20120622 test : mot-clé caché
+ PARAMETRES = FACT(statut = 'o',
+ fr = "Parametres pour masse de type QUELCONQUE",
+ MASSE = SIMP(statut='o',
+ typ='R',
+ val_min=0,
+ fr = "Masse (m)",
+ ), # end MASSE
+ INERTIEX = SIMP(statut='o',
+ typ='R',
+ fr = "Inertie en X (kg.m**2)",
+ ), # end INERTIEX
+ INERTIEY = SIMP(statut='o',
+ typ='R',
+ fr = "Inertie en Y (kg.m**2)",
+ ), # end INERTIEY
+ INERTIEZ = SIMP(statut='o',
+ typ='R',
+ fr = "Inertie en Z (axe de rotation de la ligne d'arbres) (kg.m**2)",
+ ), # end INERTIEZ
+ ), # end PARAMETRES_QUELCONQUE
+ ), # end QUELCONQUE
+ ), # end MASSE
+ NOEUDS = FACT(fr = "Definition des noeuds de la zone (2 noeuds minimum)",
+ statut='o',
+ min=2,
+ max='**',
+ NOM = SIMP(statut='o',
+ typ='TXM',
+ fr="Label du noeud",
+ ), # end NOM
+ POSITION_AXIALE = SIMP(statut='o',
+ typ='R',
+ defaut=0.0,
+ val_min=0.0,
+ fr = "Position axiale du noeud (relative par rapport au debut de la zone (1er noeud a 0m)) (m)",
+ ), # end X
+ ), # end NOEUDS
+ ELEMENTS = FACT(fr = "Definition des elements poutre de la zone",
+ statut='o',
+ min=1,
+ max='**',
+ NOM = SIMP(statut='o',
+ typ='TXM',
+ fr="Label de l'element"
+ ), # end NOM
+ NOEUD_DEBUT = SIMP(statut='o',
+ typ='TXM',
+ fr= "Noeud de debut de l'element poutre (label d'un noeud)"
+ ), # end DEBUT
+ NOEUD_FIN = SIMP(statut='o',
+ typ='TXM',
+ fr= "Noeud de fin de l'element poutre (label d'un noeud)"
+ ), # end FIN
+ RAFFINEMENT = SIMP(fr = "Choix de raffiner l'element poutre",
+ statut='o',
+ typ='TXM',
+ into=('OUI','NON'),
+ defaut='NON'
+ ), # end RAFFINEMENT
+ PARAM_RAFFINEMENT = BLOC(fr = "Nombre de points supplementaires a ajouter pour le raffinement (nombre elements : 1 -> nb points + 1)",
+ condition = "((RAFFINEMENT == 'OUI') )",
+ NB_POINTS_SUPPL = SIMP(statut='o',
+ typ='I'
+ ), # end NB_POINTS_SUPPL
+ ), # end PARAM_RAFFINEMENT
+ MATERIAU = SIMP(statut='o',
+ typ=Materiau,
+ fr= "Materiau constituant l'element poutre (doit avoir ete defini via une entree MATERIAUX)"
+ ), # end MATERIAU
+ SECTION_MASSE = FACT(statut='o',
+ fr = "Section a partir de laquelle est determinee la masse de l'element poutre",
+ TYPE_SECTION = SIMP(statut='o',
+ fr = "Choix d'une section de dimensions constantes ou variables",
+ typ='TXM',
+ into=('CONSTANTE','VARIABLE'),
+ defaut='CONSTANTE',
+ ), # end TYPE_SECTION
+ DIAM_EXTERN_DEBUT = SIMP(statut='o',
+ typ='R',
+ fr = "Diametre exterieur en debut d'element poutre (m)",
+ ), # end DIAM_EXTERN_DEBUT
+ DIAM_INTERN_DEBUT = SIMP(statut='o',
+ typ='R',
+ fr = "Diametre interieur en debut d'element poutre (m) (different de 0 si element creux)",
+ ), # end DIAM_INTERN_DEBUT
+ PARAMETRE_SECT_VAR = BLOC(condition = "((TYPE_SECTION == 'VARIABLE') )",
+ fr = "Renseignement des dimensions de fin d'element (variation lineaire entre le debut et la fin)",
+ DIAM_EXTERN_SORTIE = SIMP(statut='o',
+ typ='R',
+ fr = "Diametre exterieur en fin d'element (m)",
+ ), # end DIAM_EXTERN_SORTIE
+ DIAM_INTERN_SORTIE = SIMP(statut='o',
+ typ='R',
+ fr = "Diametre interieur en fin d'element (m)",
+ ), # DIAM_INTERN_SORTIE
+ ),
+ ), # end SECTION_MASSE
+ SECTION_RIGIDITE = FACT(statut='f',
+ fr = "Section a partir de laquelle est determinee la rigidite de l'element poutre",
+ TYPE_SECTION = SIMP(statut='o',
+ fr = "Choix d'une section de dimensions constantes ou variables",
+ typ='TXM',
+ into=('CONSTANTE','VARIABLE'),
+ defaut='CONSTANTE',
+ ), # end TYPE_SECTION
+ DIAM_EXTERN_DEBUT = SIMP(statut='o',
+ typ='R',
+ fr = "Diametre exterieur en debut d'element poutre (m)",
+ ), # end DIAM_EXTERN_DEBUT
+ DIAM_INTERN_DEBUT = SIMP(statut='o',
+ typ='R',
+ fr = "Diametre interieur en debut d'element poutre (m) (different de 0 si element creux)",
+ ), # end DIAM_INTERN_DEBUT
+ PARAMETRE_SECT_VAR = BLOC(condition = "((TYPE_SECTION == 'VARIABLE') )",
+ fr = "Renseignement des dimensions de fin d'element (variation lineaire entre le debut et la fin)",
+ DIAM_EXTERN_SORTIE = SIMP(statut='o',
+ typ='R',
+ fr = "Diametre exterieur en fin d'element (m)",
+ ), # end DIAM_EXTERN_SORTIE
+ DIAM_INTERN_SORTIE = SIMP(statut='o',
+ typ='R',
+ fr = "Diametre interieur en fin d'element (m)",
+ ), # end DIAM_INTERN_SORTIE
+ ), # end PARAMETRE_SECT_VAR
+ ), # end SECTION_RIGIDITE
+ ), # end ELEMENTS
+ FISSURE = FACT(statut='f',
+ fr="Description d'une fissure sur un noeud de l'arbre (licite uniquement si les elements poutres a gauche et a droite du noeud ont des sections masse et rigidite constantes)",
+ MATERIAU = SIMP(statut='o',
+ typ=Materiau,
+ fr="Materiau a la position de la fissure (doit avoir ete defini via une entree MATERIAUX)"
+ ), # end MATERIAU
+ NOEUD_FISSURE = SIMP(statut='o',
+ typ='TXM',
+ fr="Label du noeud ou est positionnee la fissure",
+ ), # end POSITION_FISSURE
+ ORIENTATION_FISSURE = SIMP(statut='o',
+ typ='R',
+ fr="Angle initial du fond de fissure par rapport à sa définition dans la loi de comportement de fissure (0. par defaut)(degres)",
+ ), # end ORIENTATION_FISSURE
+ FICHIER_RAIDEUR = SIMP(statut='o',
+ typ=('Fichier','Fichier loi de raideur (*.*)'),
+ fr="Fichier contenant la loi de comportement en raideur de la fissure",
+ ), # end FICHIER_RAIDEUR
+ DIAMETRE = SIMP(statut='o',
+ typ='R',
+ fr="Diametre du rotor a l'emplacement de la fissure (m)",
+ ), # end DIAMETRE
+ ), # end FISSURE
+
+ ) # end ZONE
+
+############################# PALIERS ########################################
+PALIER = MACRO(nom = 'PALIER',
+ op = None,
+ sd_prod = Palier,
+ reentrant = 'n',
+ UIinfo = {"groupes":("Machine tournante",)},
+ fr = "Description d'un palier radial",
+ POSITION = SIMP(statut='o',
+ typ='R',
+ defaut=0.0,
+ fr = "Position axiale (absolue) du palier radial (m)",
+ ), # end POSITION
+ NOM_NOEUD = SIMP(statut='f',
+ typ='TXM',
+ fr=u"Nom du noeud dans le cas où plusieurs noeuds se trouvent à la même position axiale"),
+ TYPE_PALIER = SIMP(statut='o',
+ fr = "Type de palier radial",
+ typ='TXM',
+ into=('PALIER LINEAIRE','PALIER NON-LINEAIRE','LAME FLUIDE'),
+ ), # end TYPE_PALIER
+ PALIER_LINEAIRE = BLOC(condition = "((TYPE_PALIER == 'PALIER LINEAIRE') )",
+ fr = "Description d'un palier radial lineaire",
+ TYPE_SAISIE = SIMP(statut='o',
+ fr = "Mode de description des caracteristiques du palier radial lineaire",
+ typ='TXM',
+ into=('MANUELLE', 'CATALOGUE'),
+ ), # end TYPE_SAISIE
+ MANUELLE = BLOC(condition = "((TYPE_SAISIE == 'MANUELLE') )",
+ fr = "Saisie manuelle des caracteristiques du palier radial lineaire",
+ CARAC_PALIER = FACT(statut = 'o',max='**',fr = "Caracteristiques du palier par vitesse de rotation de la ligne d'arbres",
+ VITESSE_ROTATION = SIMP(statut='o',
+ typ='R',
+ fr= "Vitesse de rotation (tr/min)",
+ ), # end VITESSE_ROTATION
+ SYME = SIMP(statut = 'o',
+ typ = 'TXM',
+ max = 1,
+ fr = "Symetrie des matrices du palier radial lineaire (KXY=KYX et AXY=AYX)",
+ into = ('OUI','NON'),
+ defaut = 'OUI',
+ ), # end SYME
+ RIGIDITE_NS = BLOC(condition="(SYME=='NON')",
+ RIGIDITE=FACT(statut='o',fr="Renseignement des caracteristiques non-symetriques de rigidite du palier radial lineaire",
+ KXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXX dans la matrice de rigidite (N/m)",
+ ),# end KXX
+ KXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXY dans la matrice de rigidite (N/m)",
+ ),# end KXY
+ KYX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KYX dans la matrice de rigidite (N/m)",
+ ),# end KYX
+ KYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KYY dans la matrice de rigidite (N/m)",
+ ),# end KYY
+ ), # end RIGIDITE
+ ), # end RIGIDITE_S
+ RIGIDITE_S = BLOC(condition="(SYME=='OUI')",
+ RIGIDITE=FACT(statut='o',fr="Renseignement des caracteristiques symetriques de rigidite du palier radial lineaire",
+ KXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXX dans la matrice de rigidite (N/m)",
+ ),# end KXX
+ KXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXY dans la matrice de rigidite (N/m)",
+ ),# end KXY
+ KYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KYY dans la matrice de rigidite (N/m)",
+ ),# end KYY
+ ), # end RIGIDITE
+ ), # end RIGIDITE_NS
+ AMORTISSEMENT_NS = BLOC(condition="(SYME=='NON')",
+ AMORTISSEMENT=FACT(statut='o',fr="Renseignement des caracteristiques non-symetriques d'amortissement du palier radial lineaire",
+ AXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXX dans la matrice d'amortissement (N.s/m)",
+ ),# end AXX
+ AXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXY dans la matrice d'amortissement (N.s/m)",
+ ),# end AXY
+ AYX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AYX dans la matrice d'amortissement (N.s/m)",
+ ),# end AYX
+ AYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AYY dans la matrice d'amortissement (N.s/m)",
+ ),# end AYY
+ ), # end AMORTISSEMENT
+ ), # end AMORTISSEMENT_NS
+ AMORTISSEMENT_S = BLOC(condition="(SYME=='OUI')",
+ AMORTISSEMENT=FACT(statut='o',fr="Renseignement des caracteristiques symetriques d'amortissement du palier radial lineaire",
+ AXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXX dans la matrice d'amortissement (N.s/m)",
+ ),# end AXX
+ AXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXY dans la matrice d'amortissement (N.s/m)",
+ ),# end AXY
+ AYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AYY dans la matrice d'amortissement (N.s/m)",
+ ),# end AYY
+ ), # end AMORTISSEMENT
+ ), # end AMORTISSEMENT_S
+ ), # end CARAC_PALIER
+ ), # end MANUELLE
+ CATALOGUE = BLOC(condition = "((TYPE_SAISIE == 'CATALOGUE') )",
+ fr = "Renseignement des fichiers contenant les caracteristiques du palier radial lineaire",
+ CATALOGUE_AMORTISSEMENT = SIMP(statut='o',
+ min=1,
+ max=1,
+ typ='Fichier',
+ fr="Fichier decrivant les caracteristiques d'amortissement (N.s/m) du palier radial lineaire (format decrit dans le Manuel Utilisateur)",
+ ), # end CATALOGUE_AMORTISSEMENT
+ CATALOGUE_RIGIDITE = SIMP(statut='o',
+ min=1,
+ max=1,
+ typ='Fichier',
+ fr="Fichier decrivant les caracteristiques de rigidite (N/m) du palier radial lineaire (format decrit dans le Manuel Utilisateur)",
+ ), # end CATALOGUE_RIGIDITE
+ ), # end CATALOGUE
+ ), # end PALIER_LINEAIRE
+ LAME_FLUIDE = BLOC(condition = "((TYPE_PALIER == 'LAME FLUIDE') )",
+ fr = "Description d'une lame fluide",
+ TYPE_SAISIE = SIMP(statut='o',
+ fr = "Mode de description des caracteristiques de la lame fluide",
+ typ='TXM',
+ defaut = 'MANUELLE',
+ #into=('MANUELLE', 'CATALOGUE'), #Fonctionnalite catalogue non encore implementee
+ into=('MANUELLE',),
+ ), # end TYPE_SAISIE
+ MANUELLE = BLOC(condition = "((TYPE_SAISIE == 'MANUELLE') )",
+ fr = "Saisie manuelle des caracteristiques de la lame fluide",
+ CARAC_PALIER = FACT(statut = 'o',max='**',fr = "Caracteristiques de la lame fluide par vitesse de rotation de la ligne d'arbres",
+ SYME = SIMP(statut = 'o',
+ typ = 'TXM',
+ max = 1,
+ fr = "Symetrie des matrices de la lame fluide (KXY=KYX et AXY=AYX)",
+ into = ('OUI','NON'),
+ defaut = 'OUI',
+ ), # end SYME
+ RIGIDITE_NS = BLOC(condition="(SYME=='NON')",
+ RIGIDITE=FACT(statut='o',fr="Renseignement des caracteristiques non-symetriques de rigidite de la lame fluide",
+ KXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXX dans la matrice de rigidite (N/m)",
+ ),# end KXX
+ KXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXY dans la matrice de rigidite (N/m)",
+ ),# end KXY
+ KYX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KYX dans la matrice de rigidite (N/m)",
+ ),# end KYX
+ KYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KYY dans la matrice de rigidite (N/m)",
+ ),# end KYY
+ ),# end RIGIDITE
+ ), # end RIGIDITE_NS
+ RIGIDITE_S = BLOC(condition="(SYME=='OUI')",
+ RIGIDITE=FACT(statut='o',fr="Renseignement des caracteristiques symetriques de rigidite de la lame fluide",
+ KXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXX dans la matrice de rigidite (N/m)",
+ ),# end KXX
+ KXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXY dans la matrice de rigidite (N/m)",
+ ),# end KXY
+ KYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KYY dans la matrice de rigidite (N/m)",
+ ),# end KYY
+ ), # end RIGIDITE
+ ), # end RIGIDITE_S
+ AMORTISSEMENT_NS = BLOC(condition="(SYME=='NON')",
+ AMORTISSEMENT=FACT(statut='o',fr="Renseignement des caracteristiques non-symetriques d'amortissement de la lame fluide",
+ AXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXX dans la matrice d'amortissement (N.s/m)",
+ ),# end AXX
+ AXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXY dans la matrice d'amortissement (N.s/m)",
+ ),# end AXY
+ AYX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AYX dans la matrice d'amortissement (N.s/m)",
+ ),# end AYX
+ AYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AYY dans la matrice d'amortissement (N.s/m)",
+ ),# end AYY
+ ), # end AMORTISSEMENT
+ ), # end AMORTISSEMENT
+ #), # end AMORTISSEMENT_NS
+ AMORTISSEMENT_S = BLOC(condition="(SYME=='OUI')",
+ AMORTISSEMENT=FACT(statut='o',fr="Renseignement des caracteristiques symetriques d'amortissement de la lame fluide",
+ AXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXX dans la matrice d'amortissement (N.s/m)",
+ ),# end AXX
+ AXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXY dans la matrice d'amortissement (N.s/m)",
+ ),# end AXY
+ AYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AYY dans la matrice d'amortissement (N.s/m)",
+ ),# end AYY
+ ), # end AMORTISSEMENT
+ ), # end AMORTISSEMENT_S
+ MASSE_NS = BLOC(condition="(SYME=='NON')",
+ MASSE=FACT(statut='o',fr="Renseignement des caracteristiques non symetriques de masse de la lame fluide",
+ MXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MXX dans la matrice de masse (kg)",
+ ),# end MXX
+ MXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MXY dans la matrice de masse (kg)",
+ ),# end MXY
+ MYX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MYX dans la matrice de masse (kg)",
+ ),# end MYX
+ MYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MYY dans la matrice de masse (kg)",
+ ),# end MYY
+ ), # end MASSE
+ ), # end MASSE_NS
+ MASSE_S = BLOC(condition="(SYME=='OUI')",
+ MASSE=FACT(statut='o',fr="Renseignement des caracteristiques symetriques de masse de la lame fluide",
+ MXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MXX dans la matrice de masse (kg)",
+ ),# end MXX
+ MXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MXY dans la matrice de masse (kg)",
+ ),# end MXY
+ MYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MYY dans la matrice de masse (kg)",
+ ),# end MYY
+ ), # end MASSE
+ ), # end MASSE_S
+ VITESSE_ROTATION = SIMP(statut='o',
+ typ='R',
+ fr= "Vitesse de rotation (tr/min)",
+ ), # end VITESSE_ROTATION
+ ), # end CARAC_PALIER
+ ), # end MANUELLE
+ #Fonctionnalite non encore implementee
+ CATALOGUE = BLOC(condition = "((TYPE_SAISIE == 'CATALOGUE') )",
+ PALIERS_CATALOGUE = SIMP(statut='o',
+ min=1,
+ max=1,
+ typ='Fichier',
+ fr="Format du fichier : CSV.",
+ ), # end PALIERS_CATALOGUE
+ ), # end CATALOGUE
+
+ ), # end LAME_FLUIDE
+ PALIER_NON_LINEAIRE = BLOC(condition = "((TYPE_PALIER == 'PALIER NON-LINEAIRE') )",
+ fr = "Description d'un palier non-lineaire (licite uniquement en cas d'analyse de type 'TRANSITOIRE ACCIDENTEL'",
+ TYPE = SIMP(statut='o',
+ typ='TXM',
+ into=('PAPANL','PAFINL','PAHYNL','PACONL'),
+ defaut=None,
+ fr="Type de palier non-lineaire parmi ceux proposes dans Edyos",
+ ), # end TYPE
+ REPERTOIRE_EDYOS = SIMP(statut='o',
+ typ=('Repertoire'),
+ defaut=None,
+ fr="Repertoire 'CDC' du palier non-lineaire utilise (les fichiers Geometrie et Donnees doivent exister dans les repertoires parents respectivement de niveau 2 et 1 de CDC)",
+ ), # end REPERTOIRE_EDYOS
+ ), # end PALIER_NON_LINEAIRE
+ ) # end PALIER
+
+PALIER_TORSION=MACRO(nom="PALIER_TORSION",
+ op=None,
+ sd_prod=PalTor,
+ reentrant='n',
+ UIinfo={"groupes":("Machine tournante",)},
+ fr="Description d'un palier de torsion",
+ POSITION = SIMP(statut='o',typ='R',defaut=0.0,fr = "Position axiale (absolue) du palier de torsion (m)",), # end POSITION
+ TYPE_SAISIE = SIMP(statut='o',typ='TXM',into=('MANUELLE',),fr = "Mode de description des caracteristiques du palier de torsion",), # end TYPE_SAISIE
+ MANUELLE = BLOC(condition = "((TYPE_SAISIE == 'MANUELLE') )",
+ fr = "Saisie manuelle des caracteristiques du palier de torsion",
+ CARAC_PALIER = FACT(statut = 'o',max=1,fr = "Caracteristiques du palier par vitesse de rotation de l'arbre",
+ VITESSE_ROTATION = SIMP(statut='o',typ='R',min=1,max='**',fr= "Liste des vitesses de rotation (tr/min)",), # end VITESSE_ROTATION
+ KRZ = SIMP(statut = 'o',typ = 'R',min=1,max = '**',fr = "Liste des caracteristiques de rigidite (N/m) du palier de torsion en fonction de la vitesse de rotation",),# end KRZ
+ ARZ = SIMP(statut = 'o',typ = 'R',min=1,max = '**',fr = "Liste des caracteristiques d'amortissement (N.s/m) du palier de torsion en fonction de la vitesse de rotation",),# end ARZ
+ MRZ = SIMP(statut = 'f',typ = 'R',min=1,max = '**',fr = "Liste des caracteristiques de masse ajoutee (kg) du palier de torsion en fonction de la vitesse de rotation",),# end MRZ
+ ),#end CARAC_PALIER
+ ), # end MANUELLE
+ #Fonctionnalite pas encore implementee
+ CATALOGUE = BLOC(condition = "((TYPE_SAISIE == 'CATALOGUE') )",
+ fr = "Renseignement des fichiers contenant les caracteristiques du palier de torsion",
+ CATA_PALIER = SIMP(statut='o',min=1,max=1,typ='Fichier',fr="Format du fichier : CSV.",), # end CATA_PALIER
+ ), # end CATALOGUE
+ )#end PALIER TORSION
+
+BUTEE=MACRO(nom="BUTEE",
+ op=None,
+ sd_prod=Butee,
+ reentrant='n',
+ UIinfo={"groupes":("Machine tournante",)},
+ fr="Description d'une butee",
+ POSITION = SIMP(statut='o',typ='R',defaut=0.0,fr = "Position axiale (absolue) de la butee (m)",), # end POSITION
+ TYPE_BUTEE = SIMP(statut='o',typ='TXM',into=('BUTEE LINEAIRE',),fr = "Type de butee",), # end TYPE_BUTEE, BUTEE NON LINEAIRE reintegrable
+ BUTEE_LINEAIRE=BLOC(condition="TYPE_BUTEE=='BUTEE LINEAIRE'",
+ fr = "Description d'une butee lineaire",
+ TYPE_SAISIE = SIMP(statut='o',typ='TXM',into=('MANUELLE',),fr = "Mode de description des caracteristiques de la butee lineaire",), # end TYPE_SAISIE; 'CATALOGUE' reintegrable
+ MANUELLE=BLOC(condition="TYPE_SAISIE=='MANUELLE'",
+ fr = "Saisie manuelle des caracteristiques de la butee lineaire",
+ CARAC_BUTEE=FACT(statut='o',max=1,fr="Caracteristiques de la butee en fonction de la vitesse de rotation",
+ VITESSE_ROTATION=SIMP(statut='o',typ='R',min=1,max='**',fr="Liste des vitesses de rotation (tr/min)",),
+ SYMETRIQUE=SIMP(statut='o',typ='TXM',min=1,max=1,into=("OUI","NON"),defaut="OUI",fr="Symetrie des matrices de la butee (KRXRY=KRYRX , ARXRY=ARYRX et MRXRY=MRYRX)",),
+
+ RIGIDITE_NS = BLOC(condition="(SYMETRIQUE=='NON')",
+ RIGIDITE=FACT(statut='o',max=1,fr="Caracteristiques non-symetriques de rigidite de la butee lineaire en fonction de la vitesse de rotation",
+ KZZ=SIMP(statut='o',typ='R',min=1,max='**',fr="Rigidite axiale (N/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ KRXRX=SIMP(statut='f',typ='R',min=1,max='**',fr="Rigidite directe de rotation autour de l'axe X (N/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ KRXRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Rigidite croisee de rotation autour de l'axe X (N/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ KRYRX=SIMP(statut='f',typ='R',min=1,max='**',fr="Rigidite croisee de rotation autour de l'axe Y (N/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ KRYRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Rigidite directe de rotation autour de l'axe Y (N/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ), #END RIGIDITE
+ ),#END RIGIDITE_NS
+ RIGIDITE_S = BLOC(condition="(SYMETRIQUE=='OUI')",
+ RIGIDITE=FACT(statut='o',max=1,fr="Caracteristiques symetriques de rigidite de la butee lineaire en fonction de la vitesse de rotation",
+ KZZ=SIMP(statut='o',typ='R',min=1,max='**',fr="Rigidite axiale (N/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ KRXRX=SIMP(statut='f',typ='R',min=1,max='**',fr="Rigidite directe de rotation autour de l'axe X (N/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ KRXRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Rigidite croisee de rotation autour de l'axe X (N/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ KRYRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Rigidite directe de rotation autour de l'axe Y (N/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ), #END RIGIDITE
+ ),#END RIGIDITE_S
+
+ AMORTISSEMENT_NS = BLOC(condition="(SYMETRIQUE=='NON')",
+ AMORTISSEMENT=FACT(statut='o',max=1,fr="Caracteristiques non-symetriques d'amortissement de la butee lineaire en fonction de la vitesse de rotation",
+ AZZ=SIMP(statut='o',typ='R',min=1,max='**',fr="Amortissement axial (N.s/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ARXRX=SIMP(statut='f',typ='R',min=1,max='**',fr="Amortissement direct de rotation autour de l'axe X (N.s/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ARXRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Amortissement croise de rotation autour de l'axe X (N.s/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ARYRX=SIMP(statut='f',typ='R',min=1,max='**',fr="Amortissement croise de rotation autour de l'axe Y (N.s/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ARYRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Amortissement croise de rotation autour de l'axe Y (N.s/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ),#END AMORTISSEMENT
+ ),#END AMORTISSEMENT_NS
+ AMORTISSEMENT_S = BLOC(condition="(SYMETRIQUE=='OUI')",
+ AMORTISSEMENT=FACT(statut='o',max=1,fr="Caracteristiques symetriques d'amortissement de la butee lineaire en fonction de la vitesse de rotation",
+ AZZ=SIMP(statut='o',typ='R',min=1,max='**',fr="Amortissement axial (N.s/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ARXRX=SIMP(statut='f',typ='R',min=1,max='**',fr="Amortissement direct de rotation autour de l'axe X (N.s/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ARXRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Amortissement croise de rotation autour de l'axe X (N.s/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ARYRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Amortissement croise de rotation autour de l'axe Y (N.s/m) de la butee lineaire en fonction de la vitesse de rotation"),
+ ),#END AMORTISSEMENT
+ ),#END AMORTISSEMENT_S
+
+ INERTIE_NS = BLOC(condition="(SYMETRIQUE=='NON')",
+ INERTIE=FACT(statut='f',max=1,fr="Caracteristiques non-symetriques de masse ajoutee de la butee lineaire en fonction de la vitesse de rotation",
+ MZZ=SIMP(statut='f',typ='R',min=1,max='**',fr="Masse ajoutee axiale (kg) de la butee lineaire en fonction de la vitesse de rotation"),
+ MRXRX=SIMP(statut='f',typ='R',min=1,max='**',fr="Masse ajoutee directe de rotation autour de l'axe X (kg) de la butee lineaire en fonction de la vitesse de rotation"),
+ MRXRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Masse ajoutee croisee de rotation autour de l'axe X (kg) de la butee lineaire en fonction de la vitesse de rotation"),
+ MRYRX=SIMP(statut='f',typ='R',min=1,max='**',fr="Masse ajoutee croisee de rotation autour de l'axe Y (kg) de la butee lineaire en fonction de la vitesse de rotation"),
+ MRYRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Masse ajoutee croisee de rotation autour de l'axe Y (kg) de la butee lineaire en fonction de la vitesse de rotation"),
+ ),#END INERTIE
+ ),#END INERTIE_NS
+ INERTIE_S = BLOC(condition="(SYMETRIQUE=='OUI')",
+ INERTIE=FACT(statut='f',max=1,fr="Caracteristiques symetriques de masse ajoutee de la butee lineaire en fonction de la vitesse de rotation",
+ MZZ=SIMP(statut='f',typ='R',min=1,max='**',fr="Masse ajoutee axiale (kg) de la butee lineaire en fonction de la vitesse de rotation"),
+ MRXRX=SIMP(statut='f',typ='R',min=1,max='**',fr="Masse ajoutee directe de rotation autour de l'axe X (kg) de la butee lineaire en fonction de la vitesse de rotation"),
+ MRXRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Masse ajoutee croisee de rotation autour de l'axe X (kg) de la butee lineaire en fonction de la vitesse de rotation"),
+ MRYRY=SIMP(statut='f',typ='R',min=1,max='**',fr="Masse ajoutee croisee de rotation autour de l'axe Y (kg) de la butee lineaire en fonction de la vitesse de rotation"),
+ ),#END INERTIE
+ ),#END INERTIE_S
+
+ ),#END CARA_BUTEE
+ ),#end MANUELLE
+ CATALOGUE=BLOC(condition="TYPE_SAISIE=='CATALOGUE'",
+ fr = "Renseignement des fichiers contenant les caracteristiques de la butee lineaire",
+ ),#END CATALOGUE
+ ),#END BUTEE LINEAIRE
+
+ BUTEE_NON_LINEAIRE=BLOC(condition="TYPE_BUTEE=='BUTEE NON LINEAIRE'",
+ fr = "Description d'une butee non-lineaire",
+ ),#END BUTEE NON LINEAIRE
+
+ );#END BUTEE
+
+############################# SUPPORT ########################################
+SUPPORT = MACRO(nom = "SUPPORT",
+ op = None,
+ sd_prod = Support,
+ reentrant = 'n',
+ UIinfo = {"groupes":("Machine tournante",)},
+ fr = "Description d'un support ",
+ TYPE_SUPPORT = SIMP(statut='o',
+ fr = "Type de support",
+ typ='TXM',
+ defaut="RIGIDE",
+ into=("RIGIDE", "SIMPLIFIE", "GENERALISE", ),
+ ), # end TYPE_SUPPORT
+ SIMPLIFIE = BLOC(condition = "((TYPE_SUPPORT == 'SIMPLIFIE') )",
+ fr = "Description d'un support simplifie",
+ RIGIDITE = FACT(statut='o', fr = "Renseignement des caracteristiques de rigidite du support simplifie",
+ KXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXX dans la matrice de rigidite (N/m)",
+ ),# end KXX
+ KXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KXY dans la matrice de rigidite (N/m)",
+ ),# end KXY
+ KYX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KYX dans la matrice de rigidite (N/m)",
+ ),# end KYX
+ KYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de KYY dans la matrice de rigidite (N/m)",
+ ),# end KYY
+ ), # end RIGIDITE
+ AMORTISSEMENT = FACT(statut='o', fr= "Renseignement des caracteristiques d'amortissement du support simplifie",
+ AXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXX dans la matrice d'amortissement (N.s/m)",
+ ),# end AXX
+ AXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AXY dans la matrice d'amortissement (N.s/m)",
+ ),# end AXY
+ AYX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AYX dans la matrice d'amortissement (N.s/m)",
+ ),# end AYX
+ AYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de AYY dans la matrice d'amortissement (N.s/m)",
+ ),# end AYY
+ ), # end AMORTISSEMENT
+ MASSE = FACT(statut='o', fr= "Renseignement des caracteristiques de masse du support simplifie",
+ MXX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MXX dans la matrice de masse (kg)",
+ ),# end MXX
+ MXY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MXY dans la matrice de masse (kg)",
+ ),# end MXY
+ MYX = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MYX dans la matrice de masse (kg)",
+ ),# end MYX
+ MYY = SIMP(statut = 'o',
+ typ = 'R',
+ max = 1,
+ fr = "Valeur de MYY dans la matrice de masse (kg)",
+ ),# end MYY
+ ), # end MASSE
+ ), # end SIMPLIFIE
+ GENERALISE = BLOC(condition = "((TYPE_SUPPORT == 'GENERALISE') )",
+ fr = "Description d'un support generalise",
+ ANGL_NAUT = SIMP(statut='f',
+ fr="Rotation du modele du support generalise a effectuer pour coincider avec le repere de la ligne d'arbres (rotation autour de X, puis Y, puis Z (degres))",
+ typ='R',
+ min=3,max=3,
+ ), # end ANGL_NAUT
+ TRANS = SIMP(statut='f',
+ fr="Translation du modele du support generalise a effectuer pour que ses noeuds de connexion soient confondus avec ceux de la ligne d'arbres (translation suivant X, Y et Z (m))",
+ typ='R',
+ min=3,max=3,
+ ), # end TRANS
+ MAIL_TDG = SIMP(statut='o',
+ fr="Fichier du maillage du support generalise",
+ typ=("Fichier","Fichier maillage TdG (*.*)"),
+ min=1,max=1,
+ ), # end MAIL_TDG
+ COMM_TDG = SIMP(statut='o',
+ fr="Fichier de la mise en donnees du support generalise",
+ typ=("Fichier","Fichier commande TdG (*.*)"),
+ min=1,max=1,
+ ), # end COMM_TDG
+ NOM_MACRO_ELEMENT_DYNAMIQUE = SIMP(statut='o',
+ fr="Nom du macro element dynamique cree pour le support generalise",
+ typ='TXM',
+ min=1,max=1,
+ ), # end NOM_MACRO_ELEMENT_DYNAMIQUE
+ NOM_INTERFACE = SIMP(statut='o',
+ fr="Nom de l'interface cree pour le support generalise",
+ typ='TXM',
+ min=1,max=1,
+ ), # end NOM_INTERFACE
+ NOM_GROUP_MA_MASSIF = SIMP(statut='o',
+ fr="Nom du groupe de maille representant le support generalise",
+ typ='TXM',
+ min=1,max=1,
+ ), # end NOM_GROUP_MA_MASSIF
+ REDUIT = SIMP(statut='f',
+ fr="Introduction du mot-cle REDUIT pour le cas ou le nombre d'interfaces n'est pas identique entre le support generalise et la ligne d'arbres",
+ typ='TXM',
+ into=("OUI",),
+ defaut="OUI",
+ ), # end REDUIT
+ ), # end GENERALISE
+ ) # end SUPPORT
+
+############################# LIGNE_ARBRE ########################################
+LIGNE_ARBRE = MACRO(nom = 'LIGNE_ARBRE',
+ op = None,
+ sd_prod = LigneArbre,
+ reentrant = 'n',
+ UIinfo = {"groupes":("Machine tournante",)},
+ fr = "Description de la ligne d'arbres",
+ ZONES = SIMP(statut='o',
+ fr = "Zone(s) composant la ligne d'arbres (choisir, en faisant attention a l'ordre, parmi les entrees ZONE creees)",
+ typ=Zone,
+ min=1,
+ max='**',
+ ), # end ZONES
+ PALIERS = SIMP(statut='o',
+ fr = "Paliers supportant la ligne d'arbres (choisir, en faisant attention a l'ordre, parmi les entrees PALIER creees)",
+ typ=Palier,
+ min=2,
+ max='**',
+ ), # end PALIERS
+ BUTEES = SIMP(statut='f',
+ fr = "Butee(s) guidant axialement la ligne d'arbres (choisir, en faisant attention a l'ordre, parmi les entrees BUTEES creees)",
+ typ=Butee,
+ max='**'
+ ),#end BUTEE
+ PALIERS_TORSION=SIMP(statut='f',
+ fr = "Palier(s) de torsion de la ligne d'arbres (choisir, en faisant attention a l'ordre, parmi les entrees PALIERS_TORSION creees)",
+ typ=PalTor,
+ max='**'
+ ),#end PALIERS_TORSION
+ SUPPORTS = SIMP(statut='o',
+ fr = "Supports sous les paliers (choisir, en faisant attention a l'ordre, parmi les entrees SUPPORTS creees)",
+ typ=Support,
+ min=1,
+ max='**',
+ ), # end SUPPORTS
+ ) # end LIGNE_ARBRE
+
+
# -*- coding: utf-8 -*-\r
-# CONFIGURATION MANAGEMENT OF EDF VERSION\r
+# maConfiguration MANAGEMENT OF EDF VERSION\r
# ======================================================================\r
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG\r
# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY\r
import os\r
\r
\r
-class CONFIG(configuration.CONFIG_BASE):\r
+class CONFIG(configuration.configBase):\r
\r
#-----------------------------------\r
def __init__(self,appli,repIni):\r
\r
self.labels_user=['catalogues','lang']\r
self.labels_eficas=['lang','rep_cata','catalogues']\r
-\r
- configuration.CONFIG_BASE.__init__(self,appli,repIni)\r
+ configuration.configBase.__init__(self,appli,repIni)\r
\r
\r
def make_config(appli,rep):\r
# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
+# maConfiguration MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
#
catalogues=(
- ('MT','V2016',os.path.join(repIni,'MT_Cata_V2016.py'),'python','python'),
+ ('MT','V2017',os.path.join(repIni,'MT_Cata_V2017.py'),'python','python'),
)
-nombreDeBoutonParLigne=4
+#nombreDeBoutonParLigne=4
simpleClic=True
closeFrameRechercheCommande=True
+boutonDsMenuBar=True
+ficIcones='images.dicoDesIcones'
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
+# maConfiguration MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
import cProfile, pstats, StringIO
pr = cProfile.Profile()
pr.enable()
-eficas_go.lance_eficas_ssIhm_reecrit(code='MT',fichier = 'gros_modele_MT.comm',ou = 'toto',cr=True)
+eficas_go.lanceEficas_ssIhm_reecrit(code='MT',fichier = 'gros_modele_MT.comm',ou = 'toto',cr=True)
pr.disable()
s = StringIO.StringIO()
sortby = 'cumulative'
ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
ps.print_stats()
-print s.getvalue()
+print s.getValue()
if etape:
self.parent = etape.parent
else:
- self.parent = CONTEXT.get_current_step()
+ self.parent = CONTEXT.getCurrentStep()
if self.parent:
self.jdc = self.parent.getJdcRoot()
else:
if not self.parent:
self.id = None
elif reg == 'oui':
- self.id = self.parent.reg_sd(self)
+ self.id = self.parent.regSD(self)
else:
self.id = self.parent.o_register(self)
# permet de savoir si le concept a été calculé (1) ou non (0)
# 0 : assd normal, 1 : type CO, 2 : type CO typé
self._as_co = 0
- def _get_sdj(self):
+ def _getSdj(self):
"""Retourne le catalogue de SD associé au concept."""
if self.ptr_sdj is None:
cata_sdj = getattr(self, 'cata_sdj', None)
% self.__class__.__name__
assert self.nom, "The attribute 'nom' has not been filled!"
if self.ptr_class_sdj is None:
- self.ptr_class_sdj = import_object(cata_sdj)
+ self.ptr_class_sdj = importObject(cata_sdj)
self.ptr_sdj = self.ptr_class_sdj(nomj=self.nom)
return self.ptr_sdj
self.ptr_sdj = None
self.ptr_class_sdj = None
- sdj = property(_get_sdj, None, _del_sdj)
+ sdj = property(_getSdj, None, _del_sdj)
def __getitem__(self, key):
text_error = "ASSD.__getitem__ est déprécié car la référence a l'objet ETAPE parent sera supprimée."
warn(text_error, DeprecationWarning, stacklevel=2)
return self.etape[key]
- def set_name(self, nom):
+ def setName(self, nom):
"""Positionne le nom de self (et appelle sd_init)
"""
self.nom = nom
- def is_typco(self):
+ def isTypCO(self):
"""Permet de savoir si l'ASSD est issu d'un type CO.
Retourne:
0 : ce n'est pas un type CO
"""
return self._as_co
- def change_type(self, new_type):
+ def changeType(self, new_type):
"""Type connu a posteriori (type CO)."""
self.__class__ = new_type
assert self._as_co != 0, 'it should only be called on CO object.'
self._as_co = 2
- def get_name(self):
+ def getName(self):
"""
Retourne le nom de self, éventuellement en le demandant au JDC
"""
if not self.nom:
try:
- self.nom = self.parent.get_name(self) or self.id
+ self.nom = self.parent.getName(self) or self.id
except:
self.nom = ""
if self.nom.find('sansnom') != -1 or self.nom == '':
'force' est utilisée pour faire des suppressions complémentaires
(voir les formules dans N_FONCTION).
"""
- self.supprime_sd()
+ self.supprimeSd()
self.etape = None
self.sd = None
self.jdc = None
self.parent = None
- def supprime_sd(self):
+ def supprimeSd(self):
"""Supprime la partie du catalogue de SD."""
- # 'del self.sdj' appellerait la méthode '_get_sdj()'...
+ # 'del self.sdj' appellerait la méthode '_getSdj()'...
self._del_sdj()
"""
if CONTEXT.debug:
print(('| accessible ?', self.nom))
- is_accessible = CONTEXT.get_current_step().sd_accessible()
+ is_accessible = CONTEXT.getCurrentStep().sdAccessible()
if CONTEXT.debug:
print((' `- is_accessible =', repr(is_accessible)))
return is_accessible
ctxt[key] = value
return ctxt
- def par_lot(self):
+ def parLot(self):
"""Conserver uniquement pour la compatibilite avec le catalogue v9 dans eficas."""
# XXX eficas
if not hasattr(self, 'jdc') or self.jdc == None:
val = None
else:
- val = self.jdc.par_lot
+ val = self.jdc.parLot
return val == 'OUI'
def rebuild_sd(self):
from . import N_ENTITE
from . import N_MCBLOC
from .N_Exception import AsException
-from .N_types import force_list
+from .N_types import forceList
class BLOC(N_ENTITE.ENTITE):
"""
return self.class_instance(nom=nom, definition=self, val=val, parent=parent)
- def verif_cata(self):
+ def verifCata(self):
"""
Cette méthode vérifie si les attributs de définition sont valides.
Les éventuels messages d'erreur sont écrits dans l'objet compte-rendu (self.cr).
"""
- self.check_fr()
- self.check_docu()
- self.check_regles()
- self.check_statut(into=('f', 'o'))
- self.check_condition()
- self.verif_cata_regles()
-
- def verif_presence(self, dict, globs):
+ self.checkFr()
+ self.checkDocu()
+ self.checkRegles()
+ self.checkStatut(into=('f', 'o'))
+ self.checkCondition()
+ self.verifCataRegles()
+
+ def verifPresence(self, dict, globs):
"""
Cette méthode vérifie si le dictionnaire passé en argument (dict)
est susceptible de contenir un bloc de mots-clés conforme à la
les valeurs des mots-clés
"""
# On recopie le dictionnaire pour protéger l'original
- dico = bloc_utils()
+ dico = blocUtils()
dico.update(dict)
if self.condition != None:
try:
return 0
-def bloc_utils():
+def blocUtils():
"""Définit un ensemble de fonctions utilisables pour écrire les
conditions de BLOC."""
def au_moins_un(mcsimp, valeurs):
"""Valide si la (ou une) valeur de 'mcsimp' est au moins une fois dans
la ou les 'valeurs'. Similaire à la règle AU_MOINS_UN, 'mcsimp' peut
contenir plusieurs valeurs."""
- test = set(force_list(mcsimp))
- valeurs = set(force_list(valeurs))
+ test = set(forceList(mcsimp))
+ valeurs = set(forceList(valeurs))
return not test.isdisjoint(valeurs)
def aucun(mcsimp, valeurs):
try:
self.parent.NommerSdprod(self, nom)
except AsException as e:
- appel = N_utils.callee_where(niveau=2)
+ appel = N_utils.calleeWhere(niveau=2)
raise AsException(
"Concept CO, fichier: ", appel[1], " ligne : ", appel[0], '\n', e)
else:
self.nom = nom
def __convert__(cls, valeur):
- if valeur.is_typco():
+ if valeur.isTypCO():
return valeur
raise ValError("Pas un concept CO")
__convert__ = classmethod(__convert__)
from builtins import object
except : pass
-from .N_types import is_int, is_float, is_sequence
+from .N_types import isInt, isFloat, isSequence
-def has_int_value(real):
+def hasIntValue(real):
"""Est-ce que 'real' a une valeur entière ?
"""
return abs(int(real) - real) < 1.e-12
def convert(self, obj):
"""Filtre liste
"""
- in_as_seq = is_sequence(obj)
+ in_as_seq = isSequence(obj)
if not in_as_seq:
obj = (obj,)
TypeConversion.__init__(self, 'I')
def function(self, o):
- if is_float(o) and has_int_value(o):
+ if isFloat(o) and hasIntValue(o):
o = int(o)
return o
TypeConversion.__init__(self, 'R')
def function(self, o):
- if is_float(o):
+ if isFloat(o):
o = float(o)
return o
self.crfatal = []
self.subcr = []
- def beautifie_messages(self):
+ def beautifieMessages(self):
"""
Beautifie les messages stockés dans crok,crfatal,crexception et crwarn
"""
self.crok_belle = l
l = []
for mess in self.crwarn:
- l.append(encadre_message(mess, '*'))
+ l.append(encadreMessage(mess, '*'))
self.crwarn_belle = l
l = []
for mess in self.crfatal:
- l.append(encadre_message(mess, '!'))
+ l.append(encadreMessage(mess, '!'))
self.crfatal_belle = l
l = []
for mess in self.crexception:
- l.append(encadre_message(mess, '!'))
+ l.append(encadreMessage(mess, '!'))
self.crexception_belle = l
def indent(self, s):
Retourne une chaine de caractères décorée et représentative de self
"""
s = ''
- self.beautifie_messages()
+ self.beautifieMessages()
s = s + ''.join(self.crok_belle)
s = s + ''.join(self.crwarn_belle)
s = s + ''.join(self.crfatal_belle)
(decalage - 1) * self.dec + self.fin + '\n'
return s
- def get_mess_fatal(self):
+ def getMessFatal(self):
"""
Retourne une chaine de caractères contenant les messages de
la liste crfatal (du dernier au premier)
self.crfatal.reverse()
return s
- def get_mess_exception(self):
+ def getMessException(self):
"""
Retourne une chaine de caractères contenant les messages
de la liste crexception (du dernier au premier)
return ligne[:coupure + 1] + '\n' + split(ligne[coupure + 1:], cesure)
-def justify_text(texte='', cesure=50):
+def justifyText(texte='', cesure=50):
if not isinstance (texte,str) : texte = ''.join(texte)
texte = texte.strip()
liste_lignes = texte.split('\n')
return texte_justifie
-def encadre_message(texte, motif):
+def encadreMessage(texte, motif):
"""
Retourne la chaine de caractères texte entourée d'un cadre formés
d'éléments 'motif'
"""
- texte = justify_text(texte, cesure=80)
+ texte = justifyText(texte, cesure=80)
if texte.strip() == "" : return ''
lignes = texte.split( '\n')
longueur = 0
v.pere = self
v.nom = k
- def verif_cata(self):
+ def verifCata(self):
"""
Cette methode sert à valider les attributs de l'objet de définition
"""
- raise NotImplementedError("La méthode verif_cata de la classe %s doit être implémentée"
+ raise NotImplementedError("La méthode verifCata de la classe %s doit être implémentée"
% self.__class__.__name__)
def __call__(self):
rapport de validation de la définition portée par cet objet
"""
self.cr = self.CR()
- self.verif_cata()
+ self.verifCata()
for k, v in list(self.entites.items()):
try:
cr = v.report()
print(("père =", self))
return self.cr
- def verif_cata_regles(self):
+ def verifCataRegles(self):
"""
Cette méthode vérifie pour tous les objets dérivés de ENTITE que
les objets REGLES associés ne portent que sur des sous-entités
% (parent, tuple(mcs.intersection(mcbloc)))
return mcs
- def check_op(self, valmin=-9999, valmax=9999):
+ def checkOp(self, valmin=-9999, valmax=9999):
"""Vérifie l'attribut op."""
if self.op is not None and \
(type(self.op) is not int or self.op < valmin or self.op > valmax):
self.cr.fatal(_(u"L'attribut 'op' doit être un entier "
u"compris entre %d et %d : %r"), valmin, valmax, self.op)
- def check_proc(self):
+ def checkProc(self):
"""Vérifie l'attribut proc."""
if self.proc is not None and not isinstance(self.proc, N_OPS.OPS):
self.cr.fatal(
_(u"L'attribut op doit être une instance d'OPS : %r"), self.proc)
- def check_regles(self):
+ def checkRegles(self):
"""Vérifie l'attribut regles."""
if type(self.regles) is not tuple:
self.cr.fatal(_(u"L'attribut 'regles' doit être un tuple : %r"),
self.regles)
- def check_fr(self):
+ def checkFr(self):
"""Vérifie l'attribut fr."""
if type(self.fr) not in stringTypes:
self.cr.fatal(
_(u"L'attribut 'fr' doit être une chaine de caractères : %r"),
self.fr)
- def check_docu(self):
+ def checkDocu(self):
"""Vérifie l'attribut docu."""
if type(self.docu) not in stringTypes:
self.cr.fatal(
_(u"L'attribut 'docu' doit être une chaine de caractères : %r"),
self.docu)
- def check_nom(self):
+ def checkNom(self):
"""Vérifie l'attribut proc."""
if type(self.nom) is not str:
self.cr.fatal(
_(u"L'attribut 'nom' doit être une chaine de caractères : %r"),
self.nom)
- def check_reentrant(self):
+ def checkReentrant(self):
"""Vérifie l'attribut reentrant."""
if self.reentrant not in ('o', 'n', 'f'):
self.cr.fatal(
_(u"L'attribut 'reentrant' doit valoir 'o','n' ou 'f' : %r"),
self.reentrant)
- def check_statut(self, into=('o', 'f', 'c', 'd')):
+ def checkStatut(self, into=('o', 'f', 'c', 'd')):
"""Vérifie l'attribut statut."""
if self.statut not in into:
self.cr.fatal(_(u"L'attribut 'statut' doit être parmi %s : %r"),
into, self.statut)
- def check_condition(self):
+ def checkCondition(self):
"""Vérifie l'attribut condition."""
if self.condition != None:
if type(self.condition) is not str:
else:
self.cr.fatal(_(u"La condition ne doit pas valoir None !"))
- def check_min_max(self):
+ def checkMinMax(self):
"""Vérifie les attributs min/max."""
if type(self.min) != int:
if self.min != '**'and self.min != float('-inf'):
_(u"Nombres d'occurrence min et max invalides : %r %r"),
self.min, self.max)
- def check_validators(self):
+ def checkValidators(self):
"""Vérifie les validateurs supplémentaires"""
- if self.validators and not self.validators.verif_cata():
+ if self.validators and not self.validators.verifCata():
self.cr.fatal(_(u"Un des validateurs est incorrect. Raison : %s"),
self.validators.cata_info)
- def check_homo(self):
+ def checkHomo(self):
"""Vérifie l'attribut homo."""
if self.homo != 0 and self.homo != 1:
self.cr.fatal(
_(u"L'attribut 'homo' doit valoir 0 ou 1 : %r"), self.homo)
- def check_into(self):
+ def checkInto(self):
"""Vérifie l'attribut into."""
if self.into != None:
if (type(self.into) not in (list, tuple)) and (type(self.into) != types.FunctionType) :
self.cr.fatal(
_(u"L'attribut 'into' doit être un tuple : %r"), self.into)
- def check_position(self):
+ def checkPosition(self):
"""Vérifie l'attribut position."""
if self.position not in ('local', 'global', 'global_jdc'):
self.cr.fatal(_(u"L'attribut 'position' doit valoir 'local', 'global' "
self.reuse = reuse
self.valeur = args
self.nettoiargs()
- self.parent = CONTEXT.get_current_step()
+ self.parent = CONTEXT.getCurrentStep()
self.etape = self
self.nom = oper.nom
self.idracine = oper.label
- self.appel = N_utils.callee_where(niveau)
+ self.appel = N_utils.calleeWhere(niveau)
self.mc_globaux = {}
self.sd = None
self.actif = 1
if self.valeur[k] == None:
del self.valeur[k]
- def McBuild(self):
+ def MCBuild(self):
"""
Demande la construction des sous-objets et les stocke dans l'attribut
mc_liste.
self.sdnom = nom
try:
if self.parent:
- sd = self.parent.create_sdprod(self, nom)
+ sd = self.parent.createSdprod(self, nom)
if type(self.definition.op_init) == types.FunctionType:
self.definition.op_init(*(
self, self.parent.g_context))
if sd != None and self.reuse == None:
# On ne nomme le concept que dans le cas de non reutilisation
# d un concept
- sd.set_name(nom)
+ sd.setName(nom)
except AsException as e:
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1], e)
sd_prod = self.definition.sd_prod
return sd_prod
- def get_etape(self):
+ def getEtape(self):
"""
Retourne l'etape a laquelle appartient self
Un objet de la categorie etape doit retourner self pour indiquer que
Methode utilisee pour que l etape self se declare etape
courante. Utilise par les macros
"""
- cs = CONTEXT.get_current_step()
+ cs = CONTEXT.getCurrentStep()
if self.parent != cs:
raise AsException("L'etape courante", cs.nom, cs,
"devrait etre le parent de", self.nom, self)
Methode utilisee par l'etape self qui remet son etape parent comme
etape courante
"""
- cs = CONTEXT.get_current_step()
+ cs = CONTEXT.getCurrentStep()
if self != cs:
raise AsException("L'etape courante", cs.nom, cs,
"devrait etre", self.nom, self)
etape.mc_liste.append(new_obj)
return etape
- def copy_reuse(self, old_etape):
+ def copyReuse(self, old_etape):
""" Methode qui copie le reuse d'une autre etape.
"""
if hasattr(old_etape, "reuse"):
self.reuse = old_etape.reuse
- def copy_sdnom(self, old_etape):
+ def copySdnom(self, old_etape):
""" Methode qui copie le sdnom d'une autre etape.
"""
if hasattr(old_etape, "sdnom"):
if self.sd and self.reuse == None:
self.sd.jdc = self.jdc
- def get_cmd(self, nomcmd):
+ def getCmd(self, nomcmd):
"""
Methode pour recuperer la definition d'une commande
donnee par son nom dans les catalogues declares
au niveau du jdc
Appele par un ops d'une macro en Python
"""
- return self.jdc.get_cmd(nomcmd)
+ return self.jdc.getCmd(nomcmd)
- def copy_intern(self, etape):
+ def copyIntern(self, etape):
"""
Methode permettant lors du processus de recopie de copier
les elements internes d'une etape dans une autre
"""
return
- def full_copy(self, parent=None):
+ def fullCopy(self, parent=None):
"""
Methode permettant d'effectuer une copie complète
d'une etape (y compris concept produit, elements internes)
aura cet objet comme parent.
"""
new_etape = self.copy()
- new_etape.copy_reuse(self)
- new_etape.copy_sdnom(self)
+ new_etape.copyReuse(self)
+ new_etape.copySdnom(self)
if parent:
new_etape.reparent(parent)
if self.sd:
if self.reuse == None:
new_etape.parent.NommerSdprod(new_sd, self.sd.nom)
else:
- new_sd.set_name(self.sd.nom)
- new_etape.copy_intern(self)
+ new_sd.setName(self.sd.nom)
+ new_etape.copyIntern(self)
return new_etape
- def reset_jdc(self, new_jdc):
+ def resetJdc(self, new_jdc):
"""
Reinitialise le nommage du concept de l'etape lors d'un changement de jdc
"""
if self.sd and self.reuse == None:
self.parent.NommerSdprod(self.sd, self.sd.nom)
- def is_include(self):
+ def isInclude(self):
"""Permet savoir si on a affaire a la commande INCLUDE
car le comportement de ces macros est particulier.
"""
return self.nom.startswith('INCLUDE')
- def sd_accessible(self):
+ def sdAccessible(self):
"""Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'etape.
"""
if CONTEXT.debug:
- print(('`- ETAPE sd_accessible :', self.nom))
- return self.parent.sd_accessible()
+ print(('`- ETAPE sdAccessible :', self.nom))
+ return self.parent.sdAccessible()
- def get_concept(self, nomsd):
+ def getConcept(self, nomsd):
"""
Methode pour recuperer un concept a partir de son nom
"""
# pourrait etre appelee par une commande fortran faisant appel a des fonctions python
# on passe la main au parent
- return self.parent.get_concept(nomsd)
+ return self.parent.getConcept(nomsd)
# Modules EFICAS
from __future__ import absolute_import
-from .strfunc import get_encoding, to_unicode
+from .strfunc import getEncoding, toUnicode
import six
def __unicode__(self):
args = []
for x in self.args:
- ustr = to_unicode(x)
+ ustr = toUnicode(x)
if type(ustr) is not six.text_type:
ustr = six.text_type( repr(x) )
args.append(ustr)
return " ".join(args)
def __str__(self):
- return six.text_type(self).encode(get_encoding())
+ return six.text_type(self).encode(getEncoding())
class InterruptParsingError(Exception):
"""Exception used to interrupt the parsing of the command file
- without raising an error (see N_JDC.exec_compile for usage)"""
+ without raising an error (see N_JDC.execCompile for usage)"""
from . import N_MCFACT
from . import N_MCLIST
from .N__F import _F
-from .N_types import is_sequence
+from .N_types import isSequence
from . import N_OBJECT
# On ne devrait jamais passer par la
print ("On ne devrait jamais passer par la")
return None
- elif is_sequence(val) and len(val) == 0 and self.statut == 'o':
+ elif isSequence(val) and len(val) == 0 and self.statut == 'o':
# On est dans le cas où le mcfact est présent mais est une liste/tuple
# vide. Il est obligatoire donc on l'initialise. Les règles, mots-clés
# obligatoires diront si un mcfact vide est accepté.
return l
- def verif_cata(self):
- self.check_min_max()
- self.check_fr()
- self.check_regles()
- self.check_statut()
- self.check_docu()
- self.check_validators()
- self.verif_cata_regles()
+ def verifCata(self):
+ self.checkMinMax()
+ self.checkFr()
+ self.checkRegles()
+ self.checkStatut()
+ self.checkDocu()
+ self.checkValidators()
+ self.verifCataRegles()
if self.accessible():
TypeProl = {
'E': 'EXCLU', 'L': 'LINEAIRE', 'C': 'CONSTANT', 'I': 'INTERPRE'}
- sd = sd_formule(self.get_name())
+ sd = sd_formule(self.getName())
prol = sd.PROL.get()
nova = sd.NOVA.get()
if prol is None or nova is None:
if etape:
self.parent = etape.parent
else:
- self.parent = CONTEXT.get_current_step()
+ self.parent = CONTEXT.getCurrentStep()
if self.parent:
self.jdc = self.parent.getJdcRoot()
else:
if not self.parent:
self.id = None
elif reg == 'oui':
- self.id = self.parent.reg_sd(self)
+ self.id = self.parent.regSD(self)
self.nom = nom
- def get_name(self):
+ def getName(self):
return self.nom
def __convert__(cls, valeur):
from . import N_CR
from .N_Exception import AsException, InterruptParsingError
from .N_ASSD import ASSD
-from .strfunc import get_encoding
+from .strfunc import getEncoding
from six.moves import range
self.args.update(args)
self.nstep = 0
self.nsd = 0
- self.par_lot = 'OUI'
- self.par_lot_user = None
+ self.parLot = 'OUI'
+ self.parLot_user = None
if definition:
self.regles = definition.regles
self.code = definition.code
# Python 2.7 compile function does not accept unicode filename, so we encode it
# with the current locale encoding in order to have a correct
# traceback
- encoded_filename = self.nom.encode(get_encoding())
+ encoded_filename = self.nom.encode(getEncoding())
self.proc_compile = compile(
self.procedure, encoded_filename, 'exec')
except SyntaxError as e:
self.cr.exception("Compilation impossible : " + ''.join(l))
return
- def exec_compile(self):
+ def execCompile(self):
"""
Cette methode execute le jeu de commandes compile dans le contexte
self.g_context de l'objet JDC
# Fonctionnement normal, ne doit pas etre considere comme une
# erreur
CONTEXT.unsetCurrentStep()
- self.affiche_fin_exec()
- self.traiter_fin_exec('commande')
+ self.afficheFinExec()
+ self.traiterFinExec('commande')
except AsException as e:
# une erreur a ete identifiee
CONTEXT.unsetCurrentStep()
# except self.UserError as exc_val:
- # self.traiter_user_exception(exc_val)
+ # self.traiterUserException(exc_val)
# CONTEXT.unsetCurrentStep()
- # self.affiche_fin_exec()
- # self.traiter_fin_exec('commande')
+ # self.afficheFinExec()
+ # self.traiterFinExec('commande')
except:
# erreur inattendue
del exc_typ, exc_val, exc_fr
CONTEXT.unsetCurrentStep()
- def affiche_fin_exec(self):
+ def afficheFinExec(self):
"""
Cette methode realise l'affichage final des statistiques de temps
apres l'execution de toutes
"""
return
- def traiter_fin_exec(self, mode, etape=None):
+ def traiterFinExec(self, mode, etape=None):
"""
Cette methode realise un traitement final apres l'execution de toutes
les commandes en mode commande par commande ou par lot
"""
print ( "FIN D'EXECUTION %s %s" %s( mode, etape))
- def traiter_user_exception(self, exc_val):
+ def traiterUserException(self, exc_val):
"""Cette methode realise un traitement sur les exceptions utilisateur
Par defaut il n'y a pas de traitement. La methode doit etre
surchargee pour en introduire un.
"""
self.etapes.append(etape)
self.index_etapes[etape] = len(self.etapes) - 1
- return self.g_register(etape)
+ return self.gRegister(etape)
def o_register(self, sd):
"""
nom = sd.idracine + self.SEP + repr(self.nsd)
return nom
- def g_register(self, etape):
+ def gRegister(self, etape):
"""
Retourne un identificateur pour etape
"""
idetape = etape.idracine + self.SEP + repr(self.nstep)
return idetape
- def create_sdprod(self, etape, nomsd):
+ def createSdprod(self, etape, nomsd):
"""
Cette methode doit fabriquer le concept produit retourne
par l'etape etape et le nommer.
raise AsException(
"Nom de concept invalide. '%s' est un mot-cle reserve." % sdnom)
- # Ajoute a la creation (appel de reg_sd).
+ # Ajoute a la creation (appel de regSD).
self.sds_dict[sdnom] = sd
- sd.set_name(sdnom)
+ sd.setName(sdnom)
# En plus si restrict vaut 'non', on insere le concept dans le contexte
# du JDC
if restrict == 'non':
self.g_context[sdnom] = sd
- def reg_sd(self, sd):
+ def regSD(self, sd):
"""
Methode appelee dans l __init__ d un ASSD lors de sa creation
pour s enregistrer
linecache.cache[fname] = 0, 0, text.split('\n'), fname
return fname, text
- def set_par_lot(self, par_lot, user_value=False):
+ def set_parLot(self, parLot, user_value=False):
"""
Met le mode de traitement a PAR LOT
ou a COMMANDE par COMMANDE
En PAR_LOT='NON', il n'y a pas d'ambiguite.
d'analyse et juste avant la phase d'execution.
`user_value` : permet de stocker la valeur choisie par l'utilisateur
- pour l'interroger plus tard (par exemple dans `getContexte_avant`).
+ pour l'interroger plus tard (par exemple dans `getContexteAvant`).
"""
if user_value:
- self.par_lot_user = par_lot
+ self.parLot_user = parLot
if self.appli == None:
# Pas d application maitre
- self.par_lot = par_lot
+ self.parLot = parLot
else:
# Avec application maitre
- self.par_lot = 'OUI'
+ self.parLot = 'OUI'
def accept(self, visitor):
"""
console = None
CONTEXT.unsetCurrentStep()
- def getContexte_avant(self, etape):
+ def getContexteAvant(self, etape):
"""
Retourne le dictionnaire des concepts connus avant etape
On tient compte des commandes qui modifient le contexte
# Si on insère des commandes (par ex, dans EFICAS), il faut prealablement
# remettre ce pointeur a 0
# self.current_context.items() if isinstance(v, ASSD)])
- if self.par_lot_user == 'NON':
+ if self.parLot_user == 'NON':
d = self.current_context = self.g_context.copy()
if etape is None:
return d
self.index_etape_courante = index_etape
return d
- def get_global_contexte(self):
+ def getGlobalContexte(self):
"""Retourne "un" contexte global ;-)"""
# N'est utilise que par INCLUDE (sauf erreur).
# g_context est remis a {} en PAR_LOT='OUI'. const_context permet
- # de retrouver ce qui y a ete mis par exec_compile.
+ # de retrouver ce qui y a ete mis par execCompile.
# Les concepts n'y sont pas en PAR_LOT='OUI'. Ils sont ajoutes
- # par get_global_contexte de la MACRO.
+ # par getGlobalContexte de la MACRO.
d = self.const_context.copy()
d.update(self.g_context)
return d
- def getContexte_courant(self, etape_courante=None):
+ def getContexteCourant(self, etape_courante=None):
"""
Retourne le contexte tel qu'il est (ou 'sera' si on est en phase
de construction) au moment de l'execution de l'etape courante.
"""
if etape_courante is None:
- etape_courante = CONTEXT.get_current_step()
- return self.getContexte_avant(etape_courante)
+ etape_courante = CONTEXT.getCurrentStep()
+ return self.getContexteAvant(etape_courante)
- def get_concept(self, nomsd):
+ def getConcept(self, nomsd):
"""
Methode pour recuperer un concept a partir de son nom
"""
- co = self.getContexte_courant().get(nomsd.strip(), None)
+ co = self.getContexteCourant().get(nomsd.strip(), None)
if not isinstance(co, ASSD):
co = None
return co
- def get_concept_by_type(self, nomsd, typesd, etape):
+ def getConceptByType(self, nomsd, typesd, etape):
"""
Methode pour recuperer un concept a partir de son nom et de son type.
Il aura comme père 'etape'.
"""
assert issubclass(typesd, ASSD), typesd
co = typesd(etape=etape)
- co.set_name(nomsd)
+ co.setName(nomsd)
co.executed = 1
return co
except:
pass
- def get_cmd(self, nomcmd):
+ def getCmd(self, nomcmd):
"""
Methode pour recuperer la definition d'une commande
donnee par son nom dans les catalogues declares
self.etapes.append(etape)
self.index_etapes[etape] = len(self.etapes) - 1
etape.reparent(self)
- etape.reset_jdc(self)
+ etape.resetJdc(self)
- def sd_accessible(self):
+ def sdAccessible(self):
"""On peut acceder aux "valeurs" (jeveux) des ASSD si le JDC est en PAR_LOT="NON".
"""
if CONTEXT.debug:
- print((' `- JDC sd_accessible : PAR_LOT =', self.par_lot))
- return self.par_lot == 'NON'
+ print((' `- JDC sdAccessible : PAR_LOT =', self.parLot))
+ return self.parLot == 'NON'
def _build_reserved_kw_list(self):
"""Construit la liste des mots-cles reserves (interdits pour le
self.d_niveaux[niveau.nom] = niveau
# On change d'objet catalogue. Il faut d'abord mettre le catalogue
# courant à None
- CONTEXT.unset_current_cata()
- CONTEXT.set_current_cata(self)
+ CONTEXT.unsetCurrentCata()
+ CONTEXT.setCurrentCata(self)
def __call__(self, procedure=None, cata=None, cata_ord_dico=None,
nom='SansNom', parent=None, **args):
"""
self.commandes.append(commande)
- def verif_cata(self):
+ def verifCata(self):
"""
Méthode de vérification des attributs de définition
"""
- self.check_regles()
- self.verif_cata_regles()
+ self.checkRegles()
+ self.verifCataRegles()
- def verif_cata_regles(self):
+ def verifCataRegles(self):
"""
Cette méthode vérifie pour tous les objets stockés dans la liste entités
respectent les REGLES associés à self
self.cr = self.CR(
debut=u"Compte-rendu de validation du catalogue " + self.code,
fin=u"Fin Compte-rendu de validation du catalogue " + self.code)
- self.verif_cata()
+ self.verifCata()
for commande in self.commandes:
cr = commande.report()
cr.debut = u"Début Commande :" + commande.nom
for commande in self.commandes:
commande.supprime()
- def get_niveau(self, nom_niveau):
+ def getNiveau(self, nom_niveau):
"""
Retourne l'objet de type NIVEAU de nom nom_niveau
ou None s'il n'existe pas
# operateur sauf si == None
self.op_init = op_init
self.entites = args
- current_cata = CONTEXT.get_current_cata()
+ current_cata = CONTEXT.getCurrentCata()
if niveau == None:
self.niveau = None
current_cata.enregistre(self)
else:
- self.niveau = current_cata.get_niveau(niveau)
+ self.niveau = current_cata.getNiveau(niveau)
self.niveau.enregistre(self)
self.UIinfo = UIinfo
self.affecter_parente()
"""
nomsd = self.nommage.getNomConceptResultat(self.nom)
etape = self.class_instance(oper=self, reuse=reuse, args=args)
- etape.McBuild()
+ etape.MCBuild()
return etape.buildSd(nomsd)
def make_objet(self, mc_list='oui'):
"""
etape = self.class_instance(oper=self, reuse=None, args={})
if mc_list == 'oui':
- etape.McBuild()
+ etape.MCBuild()
return etape
- def verif_cata(self):
+ def verifCata(self):
"""
Méthode de vérification des attributs de définition
"""
- self.check_op(valmax=0)
- self.check_proc()
- self.check_regles()
- self.check_fr()
- self.check_docu()
- self.check_nom()
- self.check_reentrant()
- self.verif_cata_regles()
+ self.checkOp(valmax=0)
+ self.checkProc()
+ self.checkRegles()
+ self.checkFr()
+ self.checkDocu()
+ self.checkNom()
+ self.checkReentrant()
+ self.verifCataRegles()
def supprime(self):
"""
# comme parent
self.setCurrentStep()
if self.parent:
- sd = self.parent.create_sdprod(self, nom)
+ sd = self.parent.createSdprod(self, nom)
if type(self.definition.op_init) == types.FunctionType:
self.definition.op_init(*(
self, self.parent.g_context))
if sd != None and self.reuse == None:
# On ne nomme le concept que dans le cas de non reutilisation
# d un concept
- sd.set_name(nom)
+ sd.setName(nom)
self.resetCurrentStep()
except AsException as e:
self.resetCurrentStep()
d = self.creeDictValeurs(self.mc_liste)
try:
# la sd_prod d'une macro a l'objet macro_etape lui meme en premier argument
- # Comme sd_prod peut invoquer la methode type_sdprod qui ajoute
+ # Comme sd_prod peut invoquer la methode typeSDProd qui ajoute
# les concepts produits dans self.sdprods, il faut le mettre a
# zero avant de l'appeler
self.sdprods = []
if type(self.definition.sd_prod) == types.FunctionType:
d = self.creeDictValeurs(self.mc_liste)
- # Comme sd_prod peut invoquer la methode type_sdprod qui ajoute
+ # Comme sd_prod peut invoquer la methode typeSDProd qui ajoute
# les concepts produits dans self.sdprods, il faut le mettre a zero
self.sdprods = []
sd_prod = self.definition.sd_prod(*(self,), **d)
sd_prod = self.definition.sd_prod
return sd_prod
- def getContexte_avant(self, etape):
+ def getContexteAvant(self, etape):
"""
Retourne le dictionnaire des concepts connus avant etape
pour les commandes internes a la macro
e.jdc = jdc
del self.index_etapes[e]
- def type_sdprod(self, co, t):
+ def typeSDProd(self, co, t):
"""
Cette methode a pour fonction de typer le concept co avec le type t
dans les conditions suivantes :
#
# On cherche a discriminer les differents cas de typage d'un concept
# produit par une macro qui est specifie dans un mot cle simple.
- # On peut passer plusieurs fois par type_sdprod ce qui explique
+ # On peut passer plusieurs fois par typeSDProd ce qui explique
# le nombre important de cas.
#
# Cas 1 : Le concept est libre. Il vient d'etre cree par CO(nom)
- # Cas 2 : Le concept est produit par la macro. On est deja passe par type_sdprod.
+ # Cas 2 : Le concept est produit par la macro. On est deja passe par typeSDProd.
# Cas semblable a Cas 1.
# Cas 3 : Le concept est produit par la macro englobante (parent). On transfere
# la propriete du concept de la macro parent a la macro courante (self)
# en verifiant que le type est valide
# Cas 4 : La concept est la propriete d'une etape fille. Ceci veut dire qu'on est
- # deja passe par type_sdprod et que la propriete a ete transfere a une
+ # deja passe par typeSDProd et que la propriete a ete transfere a une
# etape fille. Cas semblable a Cas 3.
# Cas 5 : Le concept est produit par une etape externe a la macro.
#
# Cas 1 : le concept est libre
# On l'attache a la macro et on change son type dans le type demande
# Recherche du mot cle simple associe au concept
- mcs = self.get_mcs_with_co(co)
+ mcs = self.getMcsWithCo(co)
if len(mcs) != 1:
raise AsException("""Erreur interne.
Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" % (co, mcs.definition.type))
co.etape = self
# affectation du bon type du concept
- co.change_type(t)
+ co.changeType(t)
self.sdprods.append(co)
elif co.etape == self:
# Cas 2 : le concept est produit par la macro (self)
- # On est deja passe par type_sdprod (Cas 1 ou 3).
+ # On est deja passe par typeSDProd (Cas 1 ou 3).
# XXX Peut-il etre creer par une autre macro ?
# On verifie juste que c'est un vrai CO non deja type
# if co.etape == co._etape:
- if co.is_typco() == 1:
+ if co.isTypCO() == 1:
# Le concept a ete cree par la macro (self)
# On peut changer son type
- co.change_type(t)
+ co.changeType(t)
else:
# Le concept a ete cree par une macro parente
# Le type du concept doit etre coherent avec le type demande
raise AsException("""
Impossible de changer le type du concept produit (%s) en (%s).
Le type actuel (%s) devrait etre une classe derivee du nouveau type (%s)""" % (co, t, co.__class__, t))
- mcs = self.get_mcs_with_co(co)
+ mcs = self.getMcsWithCo(co)
if len(mcs) != 1:
raise AsException("""Erreur interne.
Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
elif self.issubstep(co.etape):
# Cas 4 : Le concept est propriete d'une sous etape de la macro (self).
- # On est deja passe par type_sdprod (Cas 3 ou 1).
+ # On est deja passe par typeSDProd (Cas 3 ou 1).
# Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
# Le type du concept et t doivent etre derives.
# Il n'y a aucune raison pour que la condition ne soit pas
"""
self.etapes.append(etape)
self.index_etapes[etape] = len(self.etapes) - 1
- idetape = self.jdc.g_register(etape)
+ idetape = self.jdc.gRegister(etape)
return idetape
- def reg_sd(self, sd):
+ def regSD(self, sd):
"""
Methode appelee dans l __init__ d un ASSD a sa creation pour
s enregistrer (reserve aux ASSD crees au sein d'une MACRO)
"""
return self.jdc.o_register(sd)
- def create_sdprod(self, etape, nomsd):
+ def createSdprod(self, etape, nomsd):
"""
Cette methode doit fabriquer le concept produit retourne
par l'etape etape et le nommer.
"""
# Normalement, lorsqu'on appelle cette methode, on ne veut nommer que des concepts nouvellement crees.
# Le filtrage sur les concepts a creer ou a ne pas creer est fait dans la methode
- # create_sdprod. La seule chose a verifier apres conversion eventuelle du nom
+ # createSdprod. La seule chose a verifier apres conversion eventuelle du nom
# est de verifier que le nom n'est pas deja attribue. Ceci est fait en delegant
# au JDC par l'intermediaire du parent.
if sdnom in self.Outputs :
else:
# On est dans le cas d'un nom de concept global
# XXX a voir, creation de CO() dans CALC_ESSAI (sdls139a)
- if not sd.is_typco():
+ if not sd.isTypCO():
raise AsException(
"Resultat non declare par la macro %s : %s" % (self.nom, sdnom))
self.last = sdnom
sdprods.append(self.sd)
return sdprods
- def get_last_concept(self):
+ def getLastConcept(self):
"""Retourne le dernier concept produit dans la macro.
Peut-etre utile pour acceder au contenu 'fortran' dans une
clause 'except'."""
# et le contexte de l etape (local au sens Python)
code = compile(text, f, 'exec')
d = self.g_context = self.macro_const_context
- globs = self.get_global_contexte()
+ globs = self.getGlobalContexte()
d.update(globs)
exec(code, globs, d)
# pour ne pas conserver des references sur tout
self.macro_const_context = {}
- def get_global_contexte(self):
+ def getGlobalContexte(self):
"""
Cette methode retourne le contexte global fourni
par le parent(self) a une etape fille (l'appelant) pour
# Le contexte global est forme par concatenation du contexte
# du parent de self et de celui de l'etape elle meme (self)
# Pour les concepts, cela ne doit rien changer. Mais pour les constantes,
- # les valeurs de getContexte_avant sont moins recentes que dans
- # get_global_contexte. On prend donc la precaution de ne pas ecraser
+ # les valeurs de getContexteAvant sont moins recentes que dans
+ # getGlobalContexte. On prend donc la precaution de ne pas ecraser
# ce qui y est deja.
- d = self.parent.get_global_contexte()
+ d = self.parent.getGlobalContexte()
d.update(self.g_context)
- d.update([(k, v) for k, v in list(self.parent.getContexte_avant(self).items())
+ d.update([(k, v) for k, v in list(self.parent.getContexteAvant(self).items())
if d.get(k) is None])
return d
- def getContexte_courant(self, etape_fille_du_jdc=None):
+ def getContexteCourant(self, etape_fille_du_jdc=None):
"""
Retourne le contexte tel qu'il est au moment de l'execution de
l'etape courante.
"""
ctx = {}
# update car par ricochet on modifierait jdc.current_context
- ctx.update(self.parent.getContexte_courant(self))
+ ctx.update(self.parent.getContexteCourant(self))
# on peut mettre None car toujours en PAR_LOT='NON', donc la dernière
- ctx.update(self.getContexte_avant(None))
+ ctx.update(self.getContexteAvant(None))
return ctx
- def get_concept(self, nomsd):
+ def getConcept(self, nomsd):
"""
Methode pour recuperer un concept a partir de son nom
dans le contexte du jdc connu avant l'execution de la macro courante.
"""
- # chercher dans self.getContexte_avant, puis si non trouve
- # self.parent.get_concept est peut-etre plus performant
- co = self.getContexte_courant().get(nomsd.strip(), None)
+ # chercher dans self.getContexteAvant, puis si non trouve
+ # self.parent.getConcept est peut-etre plus performant
+ co = self.getContexteCourant().get(nomsd.strip(), None)
if not isinstance(co, ASSD):
co = None
return co
- def get_concept_by_type(self, nomsd, typesd, etape=None):
+ def getConceptByType(self, nomsd, typesd, etape=None):
"""
Methode pour recuperer un concept a partir de son nom et de son type.
Il aura comme père 'etape' (ou la macro courante si etape est absente).
"""
- return self.parent.get_concept_by_type(nomsd, typesd, etape=etape or self)
+ return self.parent.getConceptByType(nomsd, typesd, etape=etape or self)
def copy(self):
""" Methode qui retourne une copie de self non enregistree auprès du JDC
etape.sdprods = []
return etape
- def copy_intern(self, etape):
+ def copyIntern(self, etape):
""" Cette methode effectue la recopie des etapes internes d'une macro
passee en argument (etape)
"""
self.index_etapes = {}
for etp in etape.etapes:
new_etp = etp.copy()
- new_etp.copy_reuse(etp)
- new_etp.copy_sdnom(etp)
+ new_etp.copyReuse(etp)
+ new_etp.copySdnom(etp)
new_etp.reparent(self)
if etp.sd:
new_sd = etp.sd.__class__(etape=new_etp)
new_etp.sd = new_sd
if etp.reuse:
- new_sd.set_name(etp.sd.nom)
+ new_sd.setName(etp.sd.nom)
else:
self.NommerSdprod(new_sd, etp.sd.nom)
- new_etp.copy_intern(etp)
+ new_etp.copyIntern(etp)
self.etapes.append(new_etp)
self.index_etapes[new_etp] = len(self.etapes) - 1
- def reset_jdc(self, new_jdc):
+ def resetJdc(self, new_jdc):
"""
Reinitialise l'etape avec un nouveau jdc parent new_jdc
"""
for e in self.etapes:
e.reparent(self)
- def update_const_context(self, d):
+ def updateConstContext(self, d):
"""
Met a jour le contexte des constantes pour l'evaluation de
formules dans la macro.
"""
- # Dans le jdc, const_context est mis a jour par exec_compile
+ # Dans le jdc, const_context est mis a jour par execCompile
# Dans la macro, on n'a pas le code a compiler pour recupèrer les
# constantes locales a la macro. On demande donc explicitement de
# definir les constantes "locales".
self.macro_const_context.update(d)
- def sd_accessible(self):
+ def sdAccessible(self):
"""On peut acceder aux "valeurs" (jeveux) des ASSD dans
les macro-commandes qui sont localement en PAR_LOT="NON"
sauf pour INCLUDE.
"""
if CONTEXT.debug:
- print((' `- MACRO sd_accessible :', self.nom))
- return self.parent.sd_accessible() or not self.is_include()
+ print((' `- MACRO sdAccessible :', self.nom))
+ return self.parent.sdAccessible() or not self.isInclude()
#PNPN on recalcule dico_valeurs dans le for
# pour les globaux imbriques (exple Telemac Advection)
# avant le calcul etait avant le for
- dico_valeurs = self.cree_dict_condition(mc_liste, condition=1)
+ dico_valeurs = self.creeDictCondition(mc_liste, condition=1)
globs = self.jdc and self.jdc.condition_context or {}
- if v.verif_presence(dico_valeurs, globs):
+ if v.verifPresence(dico_valeurs, globs):
# Si le bloc existe :
# 1- on le construit
# 2- on l'ajoute à mc_liste
self.reste_val = args
# On ordonne la liste ainsi créée suivant l'ordre du catalogue
# (utile seulement pour IHM graphique)
- mc_liste = self.ordonne_liste(mc_liste)
+ mc_liste = self.ordonneListe(mc_liste)
# on retourne la liste ainsi construite
return mc_liste
- def ordonne_liste(self, mc_liste):
+ def ordonneListe(self, mc_liste):
"""
Ordonne la liste suivant l'ordre du catalogue.
Seulement pour IHM graphique
# valeur par défaut ou la valeur None
# On rajoute les mots-clés globaux sans écraser les clés existantes
- dico_mc = self.recherche_mc_globaux()
+ dico_mc = self.rechercheMcGlobaux()
dico_mc.update(dico)
dico = dico_mc
return dico
- def cree_dict_toutes_valeurs(self):
+ def creeDictToutesValeurs(self):
"""Semblable à `creeDictValeurs(liste=self.mc_liste)` en supprimant les
valeurs None."""
dico = self.creeDictValeurs(self.mc_liste, condition=0)
dico = dict([(k, v) for k, v in list(dico.items()) if v is not None])
return dico
- def cree_dict_condition(self, liste=[], condition=0):
+ def creeDictCondition(self, liste=[], condition=0):
"""
Methode pour construire un contexte qui servira dans l'évaluation
des conditions de présence de blocs. Si une commande a un concept
dico['reuse'] = self.reuse
return dico
- def recherche_mc_globaux(self):
+ def rechercheMcGlobaux(self):
"""
Retourne la liste des mots-clés globaux de l'étape à laquelle appartient self
et des mots-clés globaux du jdc
"""
- etape = self.get_etape()
+ etape = self.getEtape()
if etape:
- dict_mc_globaux_fac = self.recherche_mc_globaux_facultatifs()
+ dict_mc_globaux_fac = self.rechercheMcGlobauxFacultatifs()
for k, v in list(etape.mc_globaux.items()):
dict_mc_globaux_fac[k] = v.getValeur()
if self.jdc:
else:
return {}
- def recherche_mc_globaux_facultatifs(self):
+ def rechercheMcGlobauxFacultatifs(self):
"""
Cette méthode interroge la définition de self et retourne la liste des mots-clés fils
directs de self de type 'global'.
position='global' n'est donc possible (et n'a de sens) qu'au plus haut niveau.
"""
dico = {}
- etape = self.get_etape()
+ etape = self.getEtape()
if not etape:
return {}
for k, v in list(etape.definition.entites.items()):
"""
Cette méthode retourne la valeur d'un sous mot-clé (key)
"""
- return self.get_mocle(key)
+ return self.getMocle(key)
- def get_mocle(self, key):
+ def getMocle(self, key):
"""
Retourne la valeur du sous mot-clé key
Ce sous mot-clé peut exister, avoir une valeur par defaut ou etre
if not mc.isBLOC():
continue
try:
- return mc.get_mocle(key)
+ return mc.getMocle(key)
except:
# On n a rien trouve dans ce bloc, on passe au suivant
pass
# On leve une exception
raise IndexError("Le mot cle %s n existe pas dans %s" % (key, self))
- def get_child(self, name, restreint='non'):
+ def getChild(self, name, restreint='non'):
"""
Retourne le fils de self de nom name ou None s'il n'existe pas
Si restreint vaut oui : ne regarde que dans la mc_liste
"""
Ajoute le mot-clé mc à la liste des mots-clés globaux de l'étape
"""
- etape = self.get_etape()
+ etape = self.getEtape()
if etape:
nom = mc.nom
etape.mc_globaux[nom] = mc
for mocle in self.mc_liste:
mocle.reparent(self)
- def get_sd_utilisees(self):
+ def getSd_utilisees(self):
"""
Retourne la liste des concepts qui sont utilisés à l'intérieur de self
( comme valorisation d'un MCS)
"""
l = []
for child in self.mc_liste:
- l.extend(child.get_sd_utilisees())
+ l.extend(child.getSd_utilisees())
return l
- def get_sd_mcs_utilisees(self):
+ def getSd_mcs_utilisees(self):
"""
Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
- Si aucune sd n'est utilisée, le dictionnaire est vide.
"""
dico = {}
for child in self.mc_liste:
- daux = child.get_sd_mcs_utilisees()
+ daux = child.getSd_mcs_utilisees()
for cle in daux:
dico[cle] = dico.get(cle, [])
dico[cle].extend(daux[cle])
return dico
- def get_mcs_with_co(self, co):
+ def getMcsWithCo(self, co):
"""
Cette methode retourne l'objet MCSIMP fils de self
qui a le concept co comme valeur.
"""
l = []
for child in self.mc_liste:
- l.extend(child.get_mcs_with_co(co))
+ l.extend(child.getMcsWithCo(co))
return l
- def get_all_co(self):
+ def getAllCo(self):
"""
Cette methode retourne tous les concepts instances de CO
"""
l = []
for child in self.mc_liste:
- l.extend(child.get_all_co())
+ l.extend(child.getAllCo())
return l
def getVal(self):
"""
Une autre méthode qui retourne une "autre" valeur du mot clé facteur.
- Elle est utilisée par la méthode get_mocle
+ Elle est utilisée par la méthode getMocle
"""
return [self]
"""
if key == 0:
return self
- return self.get_mocle(key)
+ return self.getMocle(key)
def accept(self, visitor):
"""
def getVal(self):
"""
Une autre méthode qui retourne une "autre" valeur d'une MCList
- Elle est utilisée par la méthode get_mocle
+ Elle est utilisée par la méthode getMocle
"""
return self
for child in self.data:
child.supprime()
- def get_child(self, name,restreint='non'):
+ def getChild(self, name,restreint='non'):
"""
Retourne le fils de nom name s'il est contenu dans self
Par défaut retourne le fils du premier de la liste
# Phase 2 : on cherche dans les blocs de self
for child in obj.mc_liste:
if child.isBLOC():
- resu = child.get_child(name)
+ resu = child.getChild(name)
if resu != None:
return resu
# Phase 3 : on cherche dans les entites possibles pour les défauts
"""
visitor.visitMCList(self)
- def get_sd_utilisees(self):
+ def getSd_utilisees(self):
"""
Retourne la liste des concepts qui sont utilisés à l'intérieur de self
( comme valorisation d'un MCS)
"""
l = []
for child in self.data:
- l.extend(child.get_sd_utilisees())
+ l.extend(child.getSd_utilisees())
return l
- def get_sd_mcs_utilisees(self):
+ def getSd_mcs_utilisees(self):
"""
Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
- Si aucune sd n'est utilisée, le dictionnaire est vide.
"""
dico = {}
for child in self.data:
- daux = child.get_sd_mcs_utilisees()
+ daux = child.getSd_mcs_utilisees()
for cle in daux:
dico[cle] = dico.get(cle, [])
dico[cle].extend(daux[cle])
return dico
- def get_mcs_with_co(self, co):
+ def getMcsWithCo(self, co):
"""
Cette methode retourne l'objet MCSIMP fils de self
qui a le concept co comme valeur.
"""
l = []
for child in self.data:
- l.extend(child.get_mcs_with_co(co))
+ l.extend(child.getMcsWithCo(co))
return l
- def get_all_co(self):
+ def getAllCo(self):
"""
Cette methode retourne tous les concepts instances de CO
"""
l = []
for child in self.data:
- l.extend(child.get_all_co())
+ l.extend(child.getAllCo())
return l
def copy(self):
for mcfact in self.data:
mcfact.reparent(parent)
- def get_etape(self):
+ def getEtape(self):
"""
Retourne l'étape à laquelle appartient self
Un objet de la catégorie etape doit retourner self pour indiquer que
"""
if self.parent == None:
return None
- return self.parent.get_etape()
+ return self.parent.getEtape()
def __getitem__(self, key):
"""
Dans le cas d un mot cle facteur de longueur 1 on simule un scalaire
"""
if type(key) != int and len(self) == 1:
- return self.data[0].get_mocle(key)
+ return self.data[0].getMocle(key)
else:
return self.data[key]
from Noyau.N_CO import CO
from . import N_OBJECT
from .N_CONVERT import ConversionFactory
-from .N_types import force_list, is_sequence
+from .N_types import forceList, isSequence
class MCSIMP(N_OBJECT.OBJECT):
# par "not has_attr(v, '__iter__')".
if v is None:
pass
- elif is_sequence(v) and len(v) == 1 and self.definition.max == 1:
+ elif isSequence(v) and len(v) == 1 and self.definition.max == 1:
v = v[0]
- elif not is_sequence(v) and self.definition.max != 1:
+ elif not isSequence(v) and self.definition.max != 1:
v = (v, )
# traitement particulier pour les complexes ('RI', r, i)
if 'C' in self.definition.type and self.definition.max != 1 and v != None and v[0] in ('RI', 'MP'):
def getVal(self):
"""
Une autre méthode qui retourne une "autre" valeur du mot clé simple.
- Elle est utilisée par la méthode get_mocle
+ Elle est utilisée par la méthode getMocle
"""
return self.valeur
self.jdc = parent.jdc
self.etape = parent.etape
- def get_sd_utilisees(self):
+ def getSd_utilisees(self):
"""
Retourne une liste qui contient la ou les SD utilisée par self si c'est le cas
ou alors une liste vide
l.append(val)
return l
- def get_sd_mcs_utilisees(self):
+ def getSd_mcs_utilisees(self):
"""
Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
- Si aucune sd n'est utilisée, le dictionnaire est vide.
{ 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
<Cata.cata.fonction_sdaster instance at 0x941a204> ] }
"""
- l = self.get_sd_utilisees()
+ l = self.getSd_utilisees()
dico = {}
if len(l) > 0:
dico[self.nom] = l
return dico
- def get_mcs_with_co(self, co):
+ def getMcsWithCo(self, co):
"""
Cette methode retourne l'objet MCSIMP self s'il a le concept co
comme valeur.
"""
- if co in force_list(self.valeur):
+ if co in forceList(self.valeur):
return [self, ]
return []
- def get_all_co(self):
+ def getAllCo(self):
"""
Cette methode retourne la liste de tous les concepts co
associés au mot cle simple
"""
- return [co for co in force_list(self.valeur)
- if isinstance(co, CO) and co.is_typco()]
+ return [co for co in forceList(self.valeur)
+ if isinstance(co, CO) and co.isTypCO()]
"""
- def get_etape(self):
+ def getEtape(self):
"""
Retourne l'étape à laquelle appartient self
Un objet de la catégorie etape doit retourner self pour indiquer que
"""
if self.parent == None:
return None
- return self.parent.get_etape()
+ return self.parent.getEtape()
def supprime(self):
"""
# operateur sauf si == None
self.op_init = op_init
self.entites = args
- current_cata = CONTEXT.get_current_cata()
+ current_cata = CONTEXT.getCurrentCata()
if niveau == None:
self.niveau = None
current_cata.enregistre(self)
else:
- self.niveau = current_cata.get_niveau(niveau)
+ self.niveau = current_cata.getNiveau(niveau)
self.niveau.enregistre(self)
self.UIinfo = UIinfo
self.affecter_parente()
"""
nomsd = self.nommage.getNomConceptResultat(self.nom)
etape = self.class_instance(oper=self, reuse=reuse, args=args)
- etape.McBuild()
+ etape.MCBuild()
return etape.buildSd(nomsd)
def make_objet(self, mc_list='oui'):
"""
etape = self.class_instance(oper=self, reuse=None, args={})
if mc_list == 'oui':
- etape.McBuild()
+ etape.MCBuild()
return etape
- def verif_cata(self):
+ def verifCata(self):
"""
Méthode de vérification des attributs de définition
"""
- self.check_regles()
- self.check_fr()
- self.check_reentrant()
- self.check_docu()
- self.check_nom()
- self.check_op(valmin=0)
- self.verif_cata_regles()
+ self.checkRegles()
+ self.checkFr()
+ self.checkReentrant()
+ self.checkDocu()
+ self.checkNom()
+ self.checkOp(valmin=0)
+ self.verifCataRegles()
def supprime(self):
"""
from builtins import object
except :
pass
-from .N_utils import import_object
+from .N_utils import importObject
class OPS(object):
def __call__(self, *args, **kwargs):
"""Import the real function and call it."""
- func = import_object(self.uri)
+ func = importObject(self.uri)
return func(*args, **kwargs)
# operateur sauf si == None
self.op_init = op_init
self.entites = args
- current_cata = CONTEXT.get_current_cata()
+ current_cata = CONTEXT.getCurrentCata()
if niveau == None:
self.niveau = None
current_cata.enregistre(self)
else:
- self.niveau = current_cata.get_niveau(niveau)
+ self.niveau = current_cata.getNiveau(niveau)
self.niveau.enregistre(self)
self.UIinfo = UIinfo
self.affecter_parente()
puis demande la construction de ses sous-objets et du concept produit.
"""
etape = self.class_instance(oper=self, args=args)
- etape.McBuild()
+ etape.MCBuild()
return etape.buildSd()
def make_objet(self, mc_list='oui'):
"""
etape = self.class_instance(oper=self, args={})
if mc_list == 'oui':
- etape.McBuild()
+ etape.MCBuild()
return etape
- def verif_cata(self):
+ def verifCata(self):
"""
Méthode de vérification des attributs de définition
"""
- self.check_regles()
- self.check_fr()
- self.check_reentrant()
- self.check_docu()
- self.check_nom()
- self.check_op(valmin=0)
- self.verif_cata_regles()
+ self.checkRegles()
+ self.checkFr()
+ self.checkReentrant()
+ self.checkDocu()
+ self.checkNom()
+ self.checkOp(valmin=0)
+ self.verifCataRegles()
def supprime(self):
"""
"""
raise NotImplementedError('class REGLE should be derived')
- def liste_to_dico(self, args):
+ def listeToDico(self, args):
"""
Cette méthode est utilitaire pour les seuls besoins
des classes dérivées.
if not type(valeur) in (list, tuple):
valeur = [valeur,]
for v in valeur:
- if not v.get_name() in etape.sd.sensi:
- etape.sd.sensi[v.get_name()] = id_etape
+ if not v.getName() in etape.sd.sensi:
+ etape.sd.sensi[v.getName()] = id_etape
return '', 1
if self.min == '**' : self.min = float('-inf')
if self.val_min == '**' : self.val_min = float('-inf')
- def verif_cata(self):
+ def verifCata(self):
"""
Cette methode sert à valider les attributs de l'objet de définition
de la classe SIMP
"""
- self.check_min_max()
- self.check_fr()
- self.check_statut()
- self.check_homo()
- self.check_into()
- self.check_position()
- self.check_validators()
+ self.checkMinMax()
+ self.checkFr()
+ self.checkStatut()
+ self.checkHomo()
+ self.checkInto()
+ self.checkPosition()
+ self.checkValidators()
def __call__(self, val, nom, parent=None):
"""
import traceback
import re
from .N_ASSD import ASSD
-from .N_types import is_int, is_float_or_int, is_complex, is_number, is_str, is_sequence
+from .N_types import isInt, isFloat_or_int, isComplex, isNumber, isStr, isSequence
from Extensions.i18n import tr
import six
from six.moves import range
elif obj == None:
# pas de valeur affecte. La cardinalite vaut 0
return obj
- elif is_str(obj):
+ elif isStr(obj):
# il s'agit d'une chaine. La cardinalite vaut 1
return (obj,)
else:
err = ""
for type_permis in typ:
if type_permis == 'R':
- if is_float_or_int(obj):
+ if isFloat_or_int(obj):
return obj
elif type_permis == 'I':
- if is_int(obj):
+ if isInt(obj):
return obj
elif type_permis == 'C':
- if self.is_complexe(obj):
+ if self.isComplexe(obj):
return obj
elif type_permis == 'TXM':
- if is_str(obj):
+ if isStr(obj):
return obj
elif type_permis == 'shell':
- if is_str(obj):
+ if isStr(obj):
return obj
elif type_permis == 'Fichier':
import os
raise ValError( "%s n'est pas un fichier ou un repertoire valide" % repr(obj))
elif type(type_permis) == type or isinstance(type_permis, type):
try:
- if self.is_object_from(obj, type_permis):
+ if self.isObjectFrom(obj, type_permis):
return obj
except Exception as err:
pass
raise ValError(
tr("%s (de type %s) n'est pas d'un type autorise: %s %s") % (repr(obj), type(obj), typ, err))
- def is_complexe(self, valeur):
+ def isComplexe(self, valeur):
""" Retourne 1 si valeur est un complexe, 0 sinon """
- if is_number(valeur):
+ if isNumber(valeur):
# Pour permettre l'utilisation de complexes Python (accepte les
# entiers et réels)
return 1
else:
return 0
- def is_object_from(self, objet, classe):
+ def isObjectFrom(self, objet, classe):
"""
Retourne 1 si objet est une instance de la classe classe, 0 sinon
"""
else:
# on est dans le cas d'un ensemble continu de valeurs possibles
# (intervalle)
- if is_float_or_int(obj):
+ if isFloat_or_int(obj):
if val_min == '**':
val_min = obj - 1
if val_max == '**':
self.max = max
def __convert__(self, valeur):
- if is_str(valeur) and self.min <= len(valeur) <= self.max: return valeur
+ if isStr(valeur) and self.min <= len(valeur) <= self.max: return valeur
raise ValError(
"%s n'est pas une chaine de longueur comprise entre %s et %s" % (valeur, self.min, self.max))
"""
raise NotImplementedError("Must be implemented")
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
"""
La methode verif du validateur effectue une validation complete de
la valeur. valeur peut etre un scalaire ou une liste. Le validateur
"""
return self.verif(liste_courante)
- def verif_cata(self):
+ def verifCata(self):
"""
Cette methode sert a realiser des verifications du validateur lui meme.
Elle est facultative et retourne 1 (valide) par defaut.
"""
return 0
- def get_into(self, liste_courante=None, into_courant=None):
+ def getInto(self, liste_courante=None, into_courant=None):
"""
Cette méthode retourne la liste de choix proposée par le validateur.
Si le validateur ne propose pas de liste de choix, la méthode
retourne None.
L'argument d'entrée liste_courante, s'il est différent de None, donne
la liste des choix déjà effectués par l'utilisateur. Dans ce cas, la
- méthode get_into doit calculer la liste des choix en en tenant
+ méthode getInto doit calculer la liste des choix en en tenant
compte. Par exemple, si le validateur n'autorise pas les répétitions,
la liste des choix retournée ne doit pas contenir les choix déjà
contenus dans liste_courante.
L'argument d'entrée into_courant, s'il est différent de None, donne
la liste des choix proposés par d'autres validateurs. Dans ce cas,
- la méthode get_into doit calculer la liste des choix à retourner
+ la méthode getInto doit calculer la liste des choix à retourner
en se limitant à cette liste initiale. Par exemple, si into_courant
vaut (1,2,3) et que le validateur propose la liste de choix (3,4,5),
la méthode ne doit retourner que (3,).
- La méthode get_into peut retourner une liste vide [], ce qui veut
+ La méthode getInto peut retourner une liste vide [], ce qui veut
dire qu'il n'y a pas (ou plus) de choix possible. Cette situation
peut etre normale : l''utilisateur a utilisé tous les choix, ou
résulter d'une incohérence des validateurs :
def isList(self):
return 1
- def get_into(self, liste_courante=None, into_courant=None):
+ def getInto(self, liste_courante=None, into_courant=None):
"""
- Cette méthode get_into effectue un traitement général qui consiste
+ Cette méthode getInto effectue un traitement général qui consiste
a filtrer la liste de choix into_courant, si elle existe, en ne
conservant que les valeurs valides (appel de la méthode valid).
"""
def convert(self, valeur):
"""
Méthode convert pour les validateurs de listes. Cette méthode
- fait appel à la méthode convert_item sur chaque élément de la
+ fait appel à la méthode convertItem sur chaque élément de la
liste.
"""
- if is_sequence(valeur):
+ if isSequence(valeur):
for val in valeur:
- self.convert_item(val)
+ self.convertItem(val)
return valeur
else:
- return self.convert_item(valeur)
+ return self.convertItem(valeur)
def verif(self, valeur):
"""
Méthode verif pour les validateurs de listes. Cette méthode
- fait appel à la méthode verif_item sur chaque élément de la
+ fait appel à la méthode verifItem sur chaque élément de la
liste. Si valeur est un paramètre, on utilise sa valeur effective
valeur.valeur.
"""
- if is_sequence(valeur):
+ if isSequence(valeur):
for val in valeur:
- if not self.verif_item(val):
+ if not self.verifItem(val):
return 0
return 1
else:
- return self.verif_item(valeur)
+ return self.verifItem(valeur)
class Compulsory(ListVal):
registry = {}
def __init__(self, elem=()):
- if not is_sequence(elem):
+ if not isSequence(elem):
elem = (elem,)
Valid.__init__(self, elem=elem)
self.elem = elem
def default(self, valeur, elem):
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
return 1
def convert(self, valeur):
return 1
def verif(self, valeur):
- if not is_sequence(valeur):
+ if not isSequence(valeur):
liste = list(valeur)
else:
liste = valeur
registry = {}
def __init__(self, elem=()):
- if not is_sequence(elem):
+ if not isSequence(elem):
elem = (elem,)
Valid.__init__(self, elem=elem)
self.elem = elem
def default(self, valeur, elem):
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
return 1
def convert(self, valeur):
return 1
def verif(self, valeur):
- if not is_sequence(valeur):
+ if not isSequence(valeur):
liste = list(valeur)
else:
liste = valeur
registry = {}
def __init__(self, elem=()):
- if not is_sequence(elem):
+ if not isSequence(elem):
elem = (elem,)
Valid.__init__(self, elem=elem)
self.elem = elem
def default(self, valeur, elem):
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
return 1
def convert(self, valeur):
return 1
def verif(self, valeur):
- if not is_sequence(valeur):
+ if not isSequence(valeur):
liste = list(valeur)
else:
liste = valeur
self.liste.append(v)
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
return 1
def verif(self, valeur):
- if is_sequence(valeur):
+ if isSequence(valeur):
liste = list(valeur)
for val in liste:
if liste.count(val) != 1:
else:
return 1
- def get_into(self, liste_courante=None, into_courant=None):
+ def getInto(self, liste_courante=None, into_courant=None):
"""
- Methode get_into spécifique pour validateur NoRepeat, on retourne
+ Methode getInto spécifique pour validateur NoRepeat, on retourne
une liste de choix qui ne contient aucune valeur de into_courant
déjà contenue dans liste_courante
"""
v = self.adapt(val)
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
try:
self.adapt(valeur)
return 1
return 0
def default(self, valeur, low, high):
- if not is_str(valeur):
+ if not isStr(valeur):
raise ValError ("%s n'est pas une chaine" % repr(valeur))
if valeur[0] == "'" and valeur[-1] == "'":
low = low + 2
v = self.adapt(val)
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
try:
self.adapt(valeur)
return 1
return 0
def default(self, valeur):
- if not is_str(valeur):
+ if not isStr(valeur):
raise ValError (tr("%s n'est pas une chaine") % repr(valeur))
return valeur
self.val = valeur
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
return 1
- def get_into(self, liste_courante=None, into_courant=None):
+ def getInto(self, liste_courante=None, into_courant=None):
"""
- Methode get_into spécifique pour validateur OrdList, on retourne
+ Methode getInto spécifique pour validateur OrdList, on retourne
une liste de choix qui ne contient aucune valeur de into_courant
dont la valeur est inférieure à la dernière valeur de
liste_courante, si elle est différente de None.
"""
def __init__(self, validators=()):
- if not is_sequence(validators):
+ if not isSequence(validators):
validators = (validators,)
self.validators = []
for validator in validators:
return 1
return 0
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
for validator in self.validators:
- v = validator.verif_item(valeur)
+ v = validator.verifItem(valeur)
if v:
return 1
return 0
- def verif_cata(self):
+ def verifCata(self):
infos = []
for validator in self.validators:
- v = validator.verif_cata()
+ v = validator.verifCata()
if not v:
infos.append(validator.cata_info)
if infos:
return 0
return 1
- def get_into(self, liste_courante=None, into_courant=None):
+ def getInto(self, liste_courante=None, into_courant=None):
"""
Dans le cas ou plusieurs validateurs sont reliés par un OU
tous les validateurs doivent proposer un choix pour
"""
validator_into = []
for validator in self.validators:
- v_into = validator.get_into(liste_courante, into_courant)
+ v_into = validator.getInto(liste_courante, into_courant)
if v_into is None:
return v_into
validator_into.extend(v_into)
"""
def __init__(self, validators=()):
- if not is_sequence(validators):
+ if not isSequence(validators):
validators = (validators,)
self.validators = []
for validator in validators:
return 0
return 1
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
for validator in self.validators:
- v = validator.verif_item(valeur)
+ v = validator.verifItem(valeur)
if not v:
# L'info n'est probablement pas la meme que pour verif ???
self.local_info = validator.info()
return 0
return 1
- def verif_cata(self):
+ def verifCata(self):
infos = []
for validator in self.validators:
- v = validator.verif_cata()
+ v = validator.verifCata()
if not v:
infos.append(validator.cata_info)
if infos:
return 1
return 0
- def get_into(self, liste_courante=None, into_courant=None):
+ def getInto(self, liste_courante=None, into_courant=None):
"""
Dans le cas ou plusieurs validateurs sont reliés par un ET
il suffit qu'un seul validateur propose un choix pour
En revanche, Enum(1,2,3) ET Enum(4,5,6) ne propose pas de choix.
"""
for validator in self.validators:
- into_courant = validator.get_into(liste_courante, into_courant)
+ into_courant = validator.getInto(liste_courante, into_courant)
if into_courant in ([], None):
break
return into_courant
def info(self):
return (tr("valeur dans l'intervalle %s , %s") %( self.low, self.high))
- def convert_item(self, valeur):
+ def convertItem(self, valeur):
if valeur > self.low and valeur < self.high:
return valeur
raise ValError(tr("%s devrait etre comprise entre %s et %s") % (valeur, self.low, self.high))
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
return valeur > self.low and valeur < self.high
def infoErreurItem(self):
return (tr("la valeur %s doit etre comprise entre %s et %s") % (valeur, self.low, self.high))
- def verif_cata(self):
+ def verifCata(self):
if self.low > self.high:
return 0
return 1
def isList(self):
return self.max == '**' or self.max > 1
- def get_into(self, liste_courante=None, into_courant=None):
+ def getInto(self, liste_courante=None, into_courant=None):
if into_courant is None:
return None
elif liste_courante is None:
return []
def convert(self, valeur):
- if is_sequence(valeur):
+ if isSequence(valeur):
l = len(valeur)
elif valeur is None:
l = 0
tr("%s devrait etre de longueur superieure a %s") % (valeur, self.min))
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
return 1
def verif(self, valeur):
- if is_sequence(valeur):
+ if isSequence(valeur):
if self.max != '**' and len(valeur) > self.max:
return 0
if self.min != '**' and len(valeur) < self.min:
return 0
return 1
- def verif_cata(self):
+ def verifCata(self):
if self.min != '**' and self.max != '**' and self.min > self.max:
return 0
return 1
def default(self, valeur):
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
if type(valeur) not in six.integer_types:
return 0
return valeur % 2 == 0
def verif(self, valeur):
- if is_sequence(valeur):
+ if isSequence(valeur):
for val in valeur:
if val % 2 != 0:
return 0
"""
def __init__(self, into=()):
- if not is_sequence(into):
+ if not isSequence(into):
into = (into,)
self.into = into
self.cata_info = ""
def info(self):
return ("valeur dans %s" % self.into)
- def convert_item(self, valeur):
+ def convertItem(self, valeur):
if valeur in self.into:
return valeur
raise ValError(
tr("%s contient des valeurs hors des choix possibles: %s ") % (valeur, self.into))
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
if valeur not in self.into:
return 0
return 1
def hasInto(self):
return 1
- def get_into(self, liste_courante=None, into_courant=None):
+ def getInto(self, liste_courante=None, into_courant=None):
if into_courant is None:
liste_choix = list(self.into)
else:
Cette fonction est un validateur. Elle verifie que la valeur passee
est bien un nombre impair.
"""
- if is_sequence(valeur):
+ if isSequence(valeur):
for val in valeur:
if val % 2 != 1:
return 0
return (tr("valeur %s pour la somme des cles A et B ") % self.somme)
def verif(self, valeur):
- if is_sequence(valeur):
+ if isSequence(valeur):
for val in valeur:
if not "A" in val:
return 0
def verif(self, valeur):
return self.function(valeur)
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
return self.function(valeur)
def convert(self, valeur):
return value
raise ValError
- def convert_item(self, valeur):
+ def convertItem(self, valeur):
return self.coerce(valeur)
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
try:
self.coerce(valeur)
except:
def info(self):
return (tr("valeur d'instance de %s") % self.aClass.__name__)
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
if not isinstance(valeur, self.aClass):
return 0
return 1
def isList(self):
return 1
- def convert_item(self, valeur):
+ def convertItem(self, valeur):
if len(valeur) != len(self.typeDesTuples):
raise ValError(
tr("%s devrait etre de type %s ") %( valeur, self.typeDesTuples))
tr("%s devrait etre de type %s ") % (valeur, self.typeDesTuples))
return valeur
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
try:
if len(valeur) != len(self.typeDesTuples):
return 0
if type(valeur) in (int, int):
return 1
elif type_permis == 'C':
- if self.is_complexe(valeur):
+ if self.isComplexe(valeur):
return 1
elif type_permis == 'TXM':
if type(valeur) == bytes:
if type(valeur) in (list, tuple):
liste = list(valeur)
for val in liste:
- if self.verif_item(val) != 1:
+ if self.verifItem(val) != 1:
return 0
return 1
self.niveauVerif = niveauVerif
self.MCSimp = None
self.listeDesFreres = ()
- self.fonctions = ('verifie_liste', 'set_MCSimp')
+ self.fonctions = ('verifieListe', 'set_MCSimp')
def isList(self):
return 1
- def verifie_liste(self, liste):
+ def verifieListe(self, liste):
self.set_MCSimp(self.MCSimp)
for item in liste:
if not(item in self.listeDesFreres):
return 0
return 1
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
self.set_MCSimp(self.MCSimp)
if valeur in self.listeDesFreres:
return 1
parent.forceRecalcul = self.niveauVerif
self.listeDesFreres = parent.listeMcPresents()
- def convert_item(self, valeur):
+ def convertItem(self, valeur):
if valeur in self.listeDesFreres:
return valeur
raise ValError(
def infoErreurItem(self):
return tr('Une chaîne correspondant au motif ') + str(self.pattern) + tr(" est attendue")
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
if self.compiled_regexp.match(valeur):
return 1
else:
return (0, self.errormsg % {"value": valeur, "pattern": self.pattern})
- def convert_item(self, valeur):
+ def convertItem(self, valeur):
if self.compiled_regexp.match(valeur):
return valeur
else:
if hasattr(parent, 'inhibeValidator') and parent.inhibeValidator: return lval
- if parent.get_child(self.MotClef) == None : longueur=0
- else : longueur=len(parent.get_child(self.MotClef))
+ if parent.getChild(self.MotClef) == None : longueur=0
+ else : longueur=len(parent.getChild(self.MotClef))
pos=parent.getIndexChild(self.MCSimp.nom)+1
while longueur < valeur :
parent.addEntite(self.MotClef,pos)
pos=pos+1
parent.inhibeValidator=0
- longueur=len(parent.get_child(self.MotClef))
+ longueur=len(parent.getChild(self.MotClef))
if longueur > valeur :
parent.inhibeValide=1
- parentObj=parent.get_child(self.MotClef)
- obj=parent.get_child(self.MotClef)[-1]
+ parentObj=parent.getChild(self.MotClef)
+ obj=parent.getChild(self.MotClef)[-1]
parentObj.suppEntite(obj)
- longueur=len(parent.get_child(self.MotClef))
+ longueur=len(parent.getChild(self.MotClef))
parent.inhibeValide=0
return lval
def info(self):
return "Cree le bon nombre de Mot %s" % self.MotClef
- def verif_item(self, valeur):
+ def verifItem(self, valeur):
return 1
def set_MCSimp(self, MCSimp):
# inherit from python scalars but are numpy.float64 or numpy.int32...
-def is_int(obj):
+def isInt(obj):
return isinstance(obj, int) or type(obj) is int
-def is_float(obj):
+def isFloat(obj):
return isinstance(obj, float)
-def is_complex(obj):
+def isComplex(obj):
return isinstance(obj, complex)
from decimal import Decimal
-def is_float_or_int(obj):
- return is_float(obj) or is_int(obj) or isinstance(obj, Decimal)
+def isFloat_or_int(obj):
+ return isFloat(obj) or isInt(obj) or isinstance(obj, Decimal)
-def is_number(obj):
- return is_float_or_int(obj) or is_complex(obj)
+def isNumber(obj):
+ return isFloat_or_int(obj) or isComplex(obj)
-def is_str(obj):
+def isStr(obj):
return isinstance(obj, (str, six.text_type))
return type(obj) is list
-def is_tuple(obj):
+def isTuple(obj):
return type(obj) is tuple
-def is_array(obj):
+def isArray(obj):
"""a numpy array ?"""
return type(obj) is _np_arr
-def is_sequence(obj):
+def isSequence(obj):
"""a sequence (allow iteration, not a string) ?"""
- return isList(obj) or is_tuple(obj) or is_array(obj)
+ return isList(obj) or isTuple(obj) or isArray(obj)
-def is_assd(obj):
+def isASSD(obj):
from .N_ASSD import ASSD
return isinstance(obj, ASSD)
-def force_list(obj):
+def forceList(obj):
"""Retourne `obj` si c'est une liste ou un tuple,
sinon retourne [obj,] (en tant que list).
"""
- if not is_sequence(obj):
+ if not isSequence(obj):
obj = [obj, ]
return list(obj)
-def force_tuple(obj):
+def forceTuple(obj):
"""Return `obj` as a tuple."""
- return tuple(force_list(obj))
+ return tuple(forceList(obj))
# backward compatibility
from warnings import warn
-def is_enum(obj):
- """same as is_sequence"""
- warn("'is_enum' is deprecated, use 'is_sequence'",
+def isEnum(obj):
+ """same as isSequence"""
+ warn("'isEnum' is deprecated, use 'isSequence'",
DeprecationWarning, stacklevel=2)
- return is_sequence(obj)
+ return isSequence(obj)
# Modules EFICAS
from .N_Exception import AsException
-from .N_types import is_int, is_float, is_complex, is_str, is_sequence, is_assd
-from .strfunc import get_encoding
+from .N_types import isInt, isFloat, isComplex, isStr, isSequence, isASSD
+from .strfunc import getEncoding
import six
SEP = '_'
except :
print ('pb avec la version de python pour cur_frame = sys._getframe')
-def callee_where(niveau=4):
+def calleeWhere(niveau=4):
"""
recupere la position de l appel
"""
# Python 2.7 compile function does not accept unicode filename, so we encode it
# with the current locale encoding in order to have a correct traceback.
# Here, we convert it back to unicode.
- filename = six.text_type(frame.f_code.co_filename, get_encoding())
- return frame.f_lineno, filename, frame.f_code.co_firstlineno, frame.f_locals
+ filename = six.text_type(frame.f_code.co_filename, getEncoding())
+ return frame.fLineNo, filename, frame.f_code.co_firstlineno, frame.f_locals
except:
return 0, "inconnu", 0, {}
Retourne le type d'un concept (a) à partir
des caractéristiques de l'objet Python
"""
- if is_sequence(a):
+ if isSequence(a):
return AsType(a[0])
- if is_assd(a):
+ if isASSD(a):
return type(a)
- if is_float(a):
+ if isFloat(a):
return "R"
- if is_int(a):
+ if isInt(a):
return "I"
- if is_str(a):
+ if isStr(a):
return "TXM"
if a == None:
return None
return s
-def import_object(uri):
+def importObject(uri):
"""Load and return a python object (class, function...).
Its `uri` looks like "mainpkg.subpkg.module.object", this means
that "mainpkg.subpkg.module" is imported and "object" is
def exists(self, value):
"""Tell if value is in the enumeration"""
- return self.get_id(value) is not None
+ return self.getId(value) is not None
- def get_id(self, value):
+ def getId(self, value):
"""Return the key associated to the given value"""
return self._dict_keys.get(value, None)
"""
# Avant toutes choses, on met le module context dans le global de l'interpreteur (__builtin__)
# sous le nom CONTEXT afin d'avoir acces aux fonctions
-# get_current_step, setCurrentStep et unsetCurrentStep de n'importe ou
+# getCurrentStep, setCurrentStep et unsetCurrentStep de n'importe ou
from __future__ import absolute_import
from . import context
_root = step
-def get_current_step():
+def getCurrentStep():
"""
Fonction qui permet d'obtenir la valeur de l'etape courante
"""
_root = None
-def set_current_cata(cata):
+def setCurrentCata(cata):
"""
Fonction qui permet de changer l'objet catalogue courant
"""
_cata = cata
-def get_current_cata():
+def getCurrentCata():
"""
Fonction qui retourne l'objet catalogue courant
"""
return _cata
-def unset_current_cata():
+def unsetCurrentCata():
"""
Fonction qui permet de remettre a None le catalogue courant
"""
# Modules EFICAS
from . import N_utils
-from .strfunc import get_encoding
+from .strfunc import getEncoding
import six
from six.moves import range
Cette fonction recherche dans la pile des appels, l'appel à la commande
qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)).
On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne
- dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename).
+ dans le source f.fLineNo et le nom du fichier source (f.f_code.co_filename).
A partir de là, on récupère la ligne de source avec linecache.getline
et on vérifie que cette ligne correspond véritablement à l'appel.
"""
f = N_utils.cur_frame(level)
- lineno = f.f_lineno # XXX Too bad if -O is used
- # lineno = f_lineno(f) # Ne marche pas toujours
+ lineno = f.fLineNo # XXX Too bad if -O is used
+ # lineno = fLineNo(f) # Ne marche pas toujours
co = f.f_code
- filename = six.text_type(co.co_filename, get_encoding())
+ filename = six.text_type(co.co_filename, getEncoding())
name = co.co_name
# pattern pour identifier le debut de la commande
pattern_oper = re.compile(regex1 % ope)
return lll
-def f_lineno(f):
+def fLineNo(f):
"""
Calcule le numero de ligne courant
Devrait marcher meme avec -O
"""
c = f.f_code
if not hasattr(c, 'co_lnotab'):
- return f.f_lineno
+ return f.fLineNo
tab = c.co_lnotab
line = c.co_firstlineno
stopat = f.f_lasti
def __init__(self):
"""Initialisation"""
self.native = _getNomConceptResultat
- self.use_global_naming()
+ self.useGlobalNaming()
- def use_naming_function(self, function):
+ def useNamingFunction(self, function):
"""Utilise une fonction particulière de nommage."""
self.naming_func = function
- def use_global_naming(self):
+ def useGlobalNaming(self):
"""Utilise la fonction native de nommage."""
self.naming_func = partial(self.native, level=3)
_encoding = None
-def get_encoding():
+def getEncoding():
"""Return local encoding
"""
global _encoding
return _encoding
-def to_unicode(string):
+def toUnicode(string):
"""Try to convert string into a unicode string."""
if type(string) is six.text_type:
return string
elif type(string) is dict:
new = {}
for k, v in list(string.items()):
- new[k] = to_unicode(v)
+ new[k] = toUnicode(v)
return new
elif type(string) is list:
- return [to_unicode(elt) for elt in string]
+ return [toUnicode(elt) for elt in string]
elif type(string) is tuple:
- return tuple(to_unicode(list(string)))
+ return tuple(toUnicode(list(string)))
elif type(string) is not str:
return string
assert type(string) is str, u"unsupported object: %s" % string
return six.text_type(string, 'utf-8', 'replace')
-#def from_unicode(ustring, encoding, errors='replace'):
+#def fromUnicode(ustring, encoding, errors='replace'):
# """Try to encode a unicode string using encoding."""
# try:
# return ustring.encode(encoding)
# if type(content) not in (str, six.text_type):
# content = six.text_type(content)
# if type(content) == str:
-# content = to_unicode(content)
-# return from_unicode(content, encoding or get_encoding(), errors)
+# content = toUnicode(content)
+# return fromUnicode(content, encoding or getEncoding(), errors)
#
#
#def ufmt(uformat, *args):
# """Helper function to format a string by converting all its arguments to unicode"""
# if type(uformat) is not six.text_type:
-# uformat = to_unicode(uformat)
+# uformat = toUnicode(uformat)
# if len(args) == 1 and type(args[0]) is dict:
-# arguments = to_unicode(args[0])
+# arguments = toUnicode(args[0])
# else:
# nargs = []
# for arg in args:
# if type(arg) in (str, six.text_type, list, tuple, dict):
-# nargs.append(to_unicode(arg))
+# nargs.append(toUnicode(arg))
# elif type(arg) not in (int, int, float):
-# nargs.append(to_unicode(str(arg)))
+# nargs.append(toUnicode(str(arg)))
# else:
# nargs.append(arg)
# arguments = tuple(nargs)
if not self.accessible() :
raise Accas.AsException("Erreur dans cham_elem.EXTR_COMP en PAR_LOT='OUI'")
- ncham=self.get_name()
+ ncham=self.getName()
ncham=ncham+(8-len(ncham))*' '
nchams=ncham[0:7]+'S'
ncmp=comp+(8-len(comp))*' '
if not self.accessible() :
raise Accas.AsException("Erreur dans cham_no.EXTR_COMP en PAR_LOT='OUI'")
- ncham=self.get_name()
+ ncham=self.getName()
ncham=ncham+(8-len(ncham))*' '
nchams=ncham[0:7]+'S'
ncmp=comp+(8-len(comp))*' '
# on recupere le nom du maillage
__nomMaillage=self.sdj.REFE.get()[0].strip()
# on recupere l'objet du maillage
- __maillage=CONTEXT.get_current_step().get_concept(__nomMaillage)
+ __maillage=CONTEXT.getCurrentStep().getConcept(__nomMaillage)
__CHAM = CREA_CHAMP(OPERATION='ASSE',
MAILLAGE=__maillage,
TYPE_CHAM=__type,
from Utilitai.Utmess import UTMESS
if self.accessible():
TypeProl={'E':'EXCLU', 'L':'LINEAIRE', 'C':'CONSTANT' }
- objev = '%-19s.PROL' % self.get_name()
+ objev = '%-19s.PROL' % self.getName()
prol = self.sdj.PROL.get()
if prol == None:
UTMESS('F', 'SDVERI_2', valk=[objev])
"""
from Utilitai.Utmess import UTMESS
if self.accessible():
- vale = '%-19s.VALE' % self.get_name()
+ vale = '%-19s.VALE' % self.getName()
lbl = self.sdj.VALE.get()
if lbl == None:
UTMESS('F', 'SDVERI_2', valk=[vale])
"""
from Utilitai.Utmess import UTMESS
if self.accessible():
- vale = '%-19s.VALE' % self.get_name()
+ vale = '%-19s.VALE' % self.getName()
lbl = self.sdj.VALE.get()
if lbl == None:
UTMESS('F', 'SDVERI_2', valk=[vale])
from Utilitai.Utmess import UTMESS
if not self.accessible():
raise Accas.AsException("Erreur dans nappe.Valeurs en PAR_LOT='OUI'")
- nsd = '%-19s' % self.get_name()
+ nsd = '%-19s' % self.getName()
dicv=aster.getcolljev(nsd+'.VALE')
# les cles de dicv sont 1,...,N (indice du parametre)
lpar=aster.getvectjev(nsd+'.PARA')
if not self.accessible():
raise Accas.AsException("Erreur dans nappe.Parametres en PAR_LOT='OUI'")
TypeProl={'E':'EXCLU', 'L':'LINEAIRE', 'C':'CONSTANT' }
- objev = '%-19s.PROL' % self.get_name()
+ objev = '%-19s.PROL' % self.getName()
prol=aster.getvectjev(objev)
if prol == None:
UTMESS('F', 'SDVERI_2', valk=[objev])
if not self.accessible():
raise Accas.AsException("Erreur dans macr_elem_dyna.RECU_MATR_GENE en PAR_LOT='OUI'")
- nommacr=self.get_name()
+ nommacr=self.getName()
if (typmat=='MASS_GENE') :
macr_elem = self.sdj.MAEL_MASS
elif (typmat=='RIGI_GENE') :
if not self.accessible():
raise Accas.AsException("Erreur dans matr_asse_gene.RECU_MATR_GENE en PAR_LOT='OUI'")
- ncham=self.get_name()
+ ncham=self.getName()
desc=numpy.array(self.sdj.DESC.get())
# On teste si le DESC de la matrice existe
raise Accas.AsException("Erreur dans matr_asse_gene_c.RECU_MATR_GENE en PAR_LOT='OUI'")
numpy.asarray(matrice)
- ncham=self.get_name()
+ ncham=self.getName()
desc=numpy.array(self.sdj.DESC.get())
# On teste si le DESC de la matrice existe
la liste des macro-elements sous-jacents"""
if not self.accessible():
raise Accas.AsException("Erreur dans modele_gene.LIST_SOUS_STRUCT en PAR_LOT='OUI'")
- nommodgen=self.get_name()
+ nommodgen=self.getName()
ncham=nommodgen+(8-len(nommodgen))*' '
ssno=aster.getvectjev(ncham+(14-len(ncham))*' '+'.MODG.SSNO')
ssme=aster.getcolljev(ncham+(14-len(ncham))*' '+'.MODG.SSME')
[ (ss1, nom_liais1, ss2 , nom_liais2), ...] """
if not self.accessible() :
raise Accas.AsException("Erreur dans modele_gene.LIST_LIAIS_STRUCT en PAR_LOT='OUI'")
- nommodgen=self.get_name()
+ nommodgen=self.getName()
ncham=nommodgen+(8-len(nommodgen))*' '
lidf=aster.getcolljev(ncham+(14-len(ncham))*' '+'.MODG.LIDF')
return [([(lidf[ind][indb]) for indb in range(4)]) for ind in lidf]
def LIST_CHAMPS (self) :
if not self.accessible():
raise Accas.AsException("Erreur dans resultat.LIST_CHAMPS en PAR_LOT='OUI'")
- return aster.GetResu(self.get_name(), "CHAMPS")
+ return aster.GetResu(self.getName(), "CHAMPS")
def LIST_NOM_CMP (self) :
if not self.accessible():
raise Accas.AsException("Erreur dans resultat.LIST_NOM_CMP en PAR_LOT='OUI'")
- return aster.GetResu(self.get_name(), "COMPOSANTES")
+ return aster.GetResu(self.getName(), "COMPOSANTES")
def LIST_VARI_ACCES (self) :
if not self.accessible():
raise Accas.AsException("Erreur dans resultat.LIST_VARI_ACCES en PAR_LOT='OUI'")
- return aster.GetResu(self.get_name(), "VARI_ACCES")
+ return aster.GetResu(self.getName(), "VARI_ACCES")
def LIST_PARA (self) :
if not self.accessible():
raise Accas.AsException("Erreur dans resultat.LIST_PARA en PAR_LOT='OUI'")
- return aster.GetResu(self.get_name(), "PARAMETRES")
+ return aster.GetResu(self.getName(), "PARAMETRES")
class resultat_jeveux(resultat_sdaster):
"""Classe permettant d'accéder à un resultat jeveux qui n'a pas d'ASSD associée,
c'est le cas des concepts résultats (table, evol_xxxx) dérivés."""
def __init__(self, nom_jeveux):
resultat_sdaster.__init__(self)
- self.set_name(nom_jeveux)
+ self.setName(nom_jeveux)
class comb_fourier(resultat_sdaster): pass
class fourier_elas(resultat_sdaster): pass
"""
if not self.accessible():
raise Accas.AsException("Erreur dans table.TITRE en PAR_LOT='OUI'")
- #titj = aster.getvectjev('%-19s.TITR' % self.get_name())
+ #titj = aster.getvectjev('%-19s.TITR' % self.getName())
titj = self.sdj.TITR.get()
if titj != None:
titr = '\n'.join(titj)
# titre
titr = self.TITRE()
# récupération des paramètres
- #v_tblp = aster.getvectjev('%-19s.TBLP' % self.get_name())
+ #v_tblp = aster.getvectjev('%-19s.TBLP' % self.getName())
v_tblp = self.sdj.TBLP.get()
if v_tblp == None:
# retourne une table vide
c'est le cas des concepts résultats (table, evol_xxxx) dérivés."""
def __init__(self, nom_jeveux):
table_sdaster.__init__(self)
- self.set_name(nom_jeveux)
+ self.setName(nom_jeveux)
class table_fonction(table_sdaster):
"""Table contenant une colonne FONCTION et/ou FONCTION_C dont les
import numpy
if not self.accessible():
raise Accas.AsException("Erreur dans vect_asse_gene_r.EXTR_VECT_GENE en PAR_LOT='OUI'")
- #ncham=self.get_name()
+ #ncham=self.getName()
#ncham=ncham+(8-len(ncham))*' '
#valeur=numpy.array(aster.getvectjev(ncham+(19-len(ncham))*' '+'.VALE'))
valeur = numpy.array(self.sdj.VALE.get())
raise Accas.AsException("Erreur dans vect_asse_gene_r.RECU_VECT_GENE en PAR_LOT='OUI'")
import numpy
numpy.asarray(vecteur)
- ncham=self.get_name()
+ ncham=self.getName()
ncham=ncham+(8-len(ncham))*' '
#desc=numpy.array(aster.getvectjev(ncham+(19-len(ncham))*' '+'.DESC'))
desc = numpy.array(self.sdj.DESC.get())
if not self.accessible():
raise Accas.AsException("Erreur dans vect_asse_gene_c.EXTR_VECT_GENE en PAR_LOT='OUI'")
- #ncham=self.get_name()
+ #ncham=self.getName()
#ncham=ncham+(8-len(ncham))*' '
#valeur=numpy.array(aster.getvectjev(ncham+(19-len(ncham))*' '+'.VALE'), complex)
valeur=numpy.array(self.sdj.VALE.get(), complex)
raise Accas.AsException("Erreur dans vect_asse_gene_c.RECU_VECT_GENE en PAR_LOT='OUI'")
import numpy
numpy.asarray(vecteur)
- ncham=self.get_name()
+ ncham=self.getName()
ncham=ncham+(8-len(ncham))*' '
desc=numpy.array(aster.getvectjev(ncham+(19-len(ncham))*' '+'.DESC'))
# On teste si le DESC de la matrice existe
for res in RESU_ASSE_SSD:
for mc, typ in MTYPES.items():
if res[mc]:
- self.type_sdprod(res[mc], typ)
+ self.typeSDProd(res[mc], typ)
return None
ASSE_ELEM_SSD=MACRO(nom="ASSE_ELEM_SSD",
def assemblage_prod(self,NUME_DDL,MATR_ASSE,VECT_ASSE,**args):
if ((not MATR_ASSE) and (not VECT_ASSE)): raise AsException("Aucun concept a assembler")
if not NUME_DDL : raise AsException("Impossible de typer les concepts resultats")
- if NUME_DDL.is_typco():
- self.type_sdprod(NUME_DDL,nume_ddl_sdaster)
+ if NUME_DDL.isTypCO():
+ self.typeSDProd(NUME_DDL,nume_ddl_sdaster)
if MATR_ASSE !=None:
for m in MATR_ASSE:
if opti == "RIGI_MECA_HYST" : t= matr_asse_depl_c
- self.type_sdprod(m['MATRICE'],t)
+ self.typeSDProd(m['MATRICE'],t)
if VECT_ASSE !=None:
for v in VECT_ASSE:
- self.type_sdprod(v['VECTEUR'],cham_no_sdaster)
+ self.typeSDProd(v['VECTEUR'],cham_no_sdaster)
return None
def calc_ecrevisse_prod(self,CHARGE_MECA,CHARGE_THER1,CHARGE_THER2,TABLE,DEBIT,**args):
- self.type_sdprod(CHARGE_MECA,char_meca)
- self.type_sdprod(CHARGE_THER1,char_ther)
- self.type_sdprod(CHARGE_THER2,char_ther)
- self.type_sdprod(TABLE,table_sdaster)
- self.type_sdprod(DEBIT,table_sdaster)
+ self.typeSDProd(CHARGE_MECA,char_meca)
+ self.typeSDProd(CHARGE_THER1,char_ther)
+ self.typeSDProd(CHARGE_THER2,char_ther)
+ self.typeSDProd(TABLE,table_sdaster)
+ self.typeSDProd(DEBIT,table_sdaster)
return None
if RESU_IDENTIFICATION != None:
for res in RESU_IDENTIFICATION:
- self.type_sdprod(res['TABLE'],interspectre)
+ self.typeSDProd(res['TABLE'],interspectre)
MTYPES = {
'MODELE' : modele_sdaster,
for res in RESU_MODIFSTRU:
for mc, typ in MTYPES.items():
if res[mc]:
- self.type_sdprod(res[mc], typ)
+ self.typeSDProd(res[mc], typ)
return None
for DicoEssai in List_essais :
if DicoEssai.has_key('TABLE_RESU'):
for Table in DicoEssai['TABLE_RESU']:
- self.type_sdprod(Table,table_sdaster)
+ self.typeSDProd(Table,table_sdaster)
return None
def calc_europlexus_prod(self,COURBE=None,**args):
if COURBE is not None:
- self.type_sdprod(args['TABLE_COURBE'],table_sdaster)
+ self.typeSDProd(args['TABLE_COURBE'],table_sdaster)
return evol_noli
CALC_EUROPLEXUS = MACRO(nom="CALC_EUROPLEXUS",
if TRANCHE_2D['ZONE_MAIL']== "NON":
for ss_cop in TRANCHE_2D:
if ss_cop['CHAMP_VISU']!= None:
- self.type_sdprod(ss_cop['CHAMP_VISU'], cham_elem)
+ self.typeSDProd(ss_cop['CHAMP_VISU'], cham_elem)
if GPMAX !=None:
- self.type_sdprod(GPMAX, table_sdaster)
+ self.typeSDProd(GPMAX, table_sdaster)
return table_sdaster
matr_hm1 = args['MATR_HM1']
matr_hm2 = args['MATR_HM2']
- self.type_sdprod(matr_mh,corresp_2_mailla)
- self.type_sdprod(matr_hm1,corresp_2_mailla)
- self.type_sdprod(matr_hm2,corresp_2_mailla)
+ self.typeSDProd(matr_mh,corresp_2_mailla)
+ self.typeSDProd(matr_hm1,corresp_2_mailla)
+ self.typeSDProd(matr_hm2,corresp_2_mailla)
return None
raise AsException("type de chainage THM non prevu")
def crea_elem_ssd_prod(self,NUME_DDL,**args):
if NUME_DDL:
- self.type_sdprod(NUME_DDL,nume_ddl_sdaster)
+ self.typeSDProd(NUME_DDL,nume_ddl_sdaster)
return macr_elem_dyna
CREA_ELEM_SSD=MACRO(nom="CREA_ELEM_SSD",
def exec_logiciel_prod(self, MAILLAGE, **args):
if MAILLAGE != None:
mcf = MAILLAGE[0]
- self.type_sdprod(mcf['MAILLAGE'], maillage_sdaster)
+ self.typeSDProd(mcf['MAILLAGE'], maillage_sdaster)
return None
EXEC_LOGICIEL = MACRO(nom="EXEC_LOGICIEL",
if ( args.has_key('MAILLAGE_NP1') ) :
if ( args['MAILLAGE_NP1'] is not None ) :
maillage_np1=args['MAILLAGE_NP1']
- self.type_sdprod(maillage_np1, maillage_sdaster)
+ self.typeSDProd(maillage_np1, maillage_sdaster)
#
if ( args.has_key('MAILLAGE_NP1_ANNEXE') ) :
if ( args['MAILLAGE_NP1_ANNEXE'] is not None ) :
maillage_np1_annexe=args['MAILLAGE_NP1_ANNEXE']
- self.type_sdprod(maillage_np1_annexe, maillage_sdaster)
+ self.typeSDProd(maillage_np1_annexe, maillage_sdaster)
#
#print "MAJ_CHAM =", MAJ_CHAM
if MAJ_CHAM is not None :
# Remarque : la liste qui suit doit etre conforme à son homologue de LIRE_CHAMP
for ch in MAJ_CHAM:
t=ch['TYPE_CHAM']
- if t[0:5] == "NOEU_":self.type_sdprod(ch['CHAM_MAJ'],cham_no_sdaster)
- if t[0:2] == "EL": self.type_sdprod(ch['CHAM_MAJ'],cham_elem)
+ if t[0:5] == "NOEU_":self.typeSDProd(ch['CHAM_MAJ'],cham_no_sdaster)
+ if t[0:2] == "EL": self.typeSDProd(ch['CHAM_MAJ'],cham_elem)
#
#print "ADD_CHAM =", ADD_CHAM
if ADD_CHAM is not None :
for ch in ADD_CHAM:
- self.type_sdprod(ch['CHAM_GD'],carte_sdaster)
+ self.typeSDProd(ch['CHAM_GD'],carte_sdaster)
#
return None
# person_in_charge: samuel.geniaut at edf.fr
def macr_ascouf_calc_prod(self,MODELE,CHAM_MATER,CARA_ELEM,FOND_FISS,RESU_THER,**args):
- self.type_sdprod(MODELE,modele_sdaster)
- if CHAM_MATER != None:self.type_sdprod(CHAM_MATER,cham_mater)
- if CARA_ELEM != None:self.type_sdprod(CARA_ELEM,cara_elem)
- if FOND_FISS != None:self.type_sdprod(FOND_FISS,fond_fiss)
- if RESU_THER != None:self.type_sdprod(RESU_THER,evol_ther)
+ self.typeSDProd(MODELE,modele_sdaster)
+ if CHAM_MATER != None:self.typeSDProd(CHAM_MATER,cham_mater)
+ if CARA_ELEM != None:self.typeSDProd(CARA_ELEM,cara_elem)
+ if FOND_FISS != None:self.typeSDProd(FOND_FISS,fond_fiss)
+ if RESU_THER != None:self.typeSDProd(RESU_THER,evol_ther)
return evol_noli
MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",
# person_in_charge: samuel.geniaut at edf.fr
def macr_aspic_calc_prod(self,MODELE,CHAM_MATER,CARA_ELEM,FOND_FISS_1,FOND_FISS_2,RESU_THER,**args):
- if MODELE != None:self.type_sdprod(MODELE,modele_sdaster)
- if CHAM_MATER != None:self.type_sdprod(CHAM_MATER,cham_mater)
- if CARA_ELEM != None:self.type_sdprod(CARA_ELEM,cara_elem)
- if FOND_FISS_1 != None:self.type_sdprod(FOND_FISS_1,fond_fiss)
- if FOND_FISS_2 != None:self.type_sdprod(FOND_FISS_2,fond_fiss)
- if RESU_THER != None:self.type_sdprod(RESU_THER,evol_ther)
+ if MODELE != None:self.typeSDProd(MODELE,modele_sdaster)
+ if CHAM_MATER != None:self.typeSDProd(CHAM_MATER,cham_mater)
+ if CARA_ELEM != None:self.typeSDProd(CARA_ELEM,cara_elem)
+ if FOND_FISS_1 != None:self.typeSDProd(FOND_FISS_1,fond_fiss)
+ if FOND_FISS_2 != None:self.typeSDProd(FOND_FISS_2,fond_fiss)
+ if RESU_THER != None:self.typeSDProd(RESU_THER,evol_ther)
return evol_noli
MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",
def macr_ecla_pg_prod(self,RESULTAT,MAILLAGE,RESU_INIT,**args):
- self.type_sdprod(RESULTAT,AsType(RESU_INIT))
- self.type_sdprod(MAILLAGE,maillage_sdaster)
+ self.typeSDProd(RESULTAT,AsType(RESU_INIT))
+ self.typeSDProd(MAILLAGE,maillage_sdaster)
return None
def macr_ecre_calc_prod(self,TABLE,DEBIT,**args):
- self.type_sdprod(TABLE,table_sdaster)
- self.type_sdprod(DEBIT,table_sdaster)
+ self.typeSDProd(TABLE,table_sdaster)
+ self.typeSDProd(DEBIT,table_sdaster)
return None
MACR_ECRE_CALC=MACRO(nom="MACR_ECRE_CALC",
def macr_ecrevisse_prod(self,TABLE,TEMPER,DEBIT,**args):
# On definit ici les concepts produits
- self.type_sdprod(TABLE,table_sdaster)
- self.type_sdprod(TEMPER,evol_ther)
- self.type_sdprod(DEBIT,table_sdaster)
+ self.typeSDProd(TABLE,table_sdaster)
+ self.typeSDProd(TEMPER,evol_ther)
+ self.typeSDProd(DEBIT,table_sdaster)
# concept retourne
return evol_noli
def macro_elas_mult_prod(self,NUME_DDL,CAS_CHARGE,**args ):
- if NUME_DDL is not None and NUME_DDL.is_typco():
- self.type_sdprod(NUME_DDL,nume_ddl_sdaster)
+ if NUME_DDL is not None and NUME_DDL.isTypCO():
+ self.typeSDProd(NUME_DDL,nume_ddl_sdaster)
if CAS_CHARGE[0]['NOM_CAS'] != None : return mult_elas
if CAS_CHARGE[0]['MODE_FOURIER'] != None : return fourier_elas
raise AsException("type de concept resultat non prevu")
def macro_expans_prod(self, MODELE_MESURE, RESU_NX, RESU_EX, RESU_ET, RESU_RD, **args):
RESU_EXP = MODELE_MESURE['MESURE']
- self.type_sdprod(RESU_NX, mode_meca)
+ self.typeSDProd(RESU_NX, mode_meca)
for res in (RESU_EX, RESU_ET, RESU_RD):
- if res is not None and res.is_typco():
+ if res is not None and res.isTypCO():
if AsType(RESU_EXP) == mode_meca:
- self.type_sdprod(res, mode_meca)
+ self.typeSDProd(res, mode_meca)
else:
- self.type_sdprod(res, dyna_harmo)
+ self.typeSDProd(res, dyna_harmo)
return None
MACRO_EXPANS=MACRO(nom="MACRO_EXPANS",
def macro_matr_ajou_prod(self,MATR_AMOR_AJOU,MATR_MASS_AJOU,MATR_RIGI_AJOU,FORC_AJOU,**args):
- self.type_sdprod(MATR_AMOR_AJOU,matr_asse_gene_r)
- self.type_sdprod(MATR_MASS_AJOU,matr_asse_gene_r)
- self.type_sdprod(MATR_RIGI_AJOU,matr_asse_gene_r)
+ self.typeSDProd(MATR_AMOR_AJOU,matr_asse_gene_r)
+ self.typeSDProd(MATR_MASS_AJOU,matr_asse_gene_r)
+ self.typeSDProd(MATR_RIGI_AJOU,matr_asse_gene_r)
if FORC_AJOU != None:
for m in FORC_AJOU:
- self.type_sdprod(m['VECTEUR'],vect_asse_gene)
+ self.typeSDProd(m['VECTEUR'],vect_asse_gene)
return None
def post_endo_fiss_prod(self,TABLE,**args) :
- self.type_sdprod(TABLE,table_sdaster)
+ self.typeSDProd(TABLE,table_sdaster)
return maillage_sdaster
POST_ENDO_FISS=MACRO(nom="POST_ENDO_FISS",
def proj_base_prod(self,MATR_ASSE_GENE,VECT_ASSE_GENE,
RESU_GENE, NUME_DDL_GENE,
STOCKAGE,**args ):
- if NUME_DDL_GENE is not None and NUME_DDL_GENE.is_typco():
- self.type_sdprod(NUME_DDL_GENE, nume_ddl_gene)
+ if NUME_DDL_GENE is not None and NUME_DDL_GENE.isTypCO():
+ self.typeSDProd(NUME_DDL_GENE, nume_ddl_gene)
if MATR_ASSE_GENE != None:
for m in MATR_ASSE_GENE:
- self.type_sdprod(m['MATRICE'],matr_asse_gene_r)
+ self.typeSDProd(m['MATRICE'],matr_asse_gene_r)
if VECT_ASSE_GENE != None:
for v in VECT_ASSE_GENE:
- self.type_sdprod(v['VECTEUR'],vect_asse_gene)
+ self.typeSDProd(v['VECTEUR'],vect_asse_gene)
if RESU_GENE != None:
for v in RESU_GENE:
- self.type_sdprod(v['RESULTAT'],tran_gene)
+ self.typeSDProd(v['RESULTAT'],tran_gene)
return None
PROJ_BASE=MACRO(nom="PROJ_BASE",
def propa_fiss_prod(self,**args):
if args.has_key('MAIL_TOTAL') :
MAIL_TOTAL = args['MAIL_TOTAL']
- self.type_sdprod(MAIL_TOTAL,maillage_sdaster)
+ self.typeSDProd(MAIL_TOTAL,maillage_sdaster)
if args.has_key('MAIL_FISS') :
MAIL_FISS = args['MAIL_FISS']
- self.type_sdprod(MAIL_FISS,maillage_sdaster)
+ self.typeSDProd(MAIL_FISS,maillage_sdaster)
if args.has_key('FISSURE') :
FISSURE = args['FISSURE']
for numfis in FISSURE :
if (args['METHODE_PROPA']=='MAILLAGE') :
- self.type_sdprod(numfis['MAIL_PROPAGE'],maillage_sdaster)
+ self.typeSDProd(numfis['MAIL_PROPAGE'],maillage_sdaster)
else :
- self.type_sdprod(numfis['FISS_PROPAGEE'],fiss_xfem)
+ self.typeSDProd(numfis['FISS_PROPAGEE'],fiss_xfem)
return None
PROPA_FISS=MACRO(nom="PROPA_FISS",
from Accas import ASSD
from Noyau.ascheckers import CheckLog
from Noyau.N_info import message, SUPERV
-from Noyau.N_types import force_list
+from Noyau.N_types import forceList
try:
import aster
"""Fonction sdprod partie commune à DEBUT et POURSUITE.
(on stocke un entier au lieu du logique)
"""
- jdc.set_par_lot(PAR_LOT, user_value=True)
+ jdc.set_parLot(PAR_LOT, user_value=True)
jdc.impr_macro = int(IMPR_MACRO == 'OUI')
jdc.jxveri = int(CODE != None or (DEBUG != None and DEBUG['JXVERI'] == 'OUI'))
jdc.sdveri = int(DEBUG != None and DEBUG['SDVERI'] == 'OUI')
if LANG:
from Execution.i18n import localization
localization.install(LANG)
- # pb en cas d'erreur dans FIN : appeler reset_print_function dans traiter_fin_exec ?
+ # pb en cas d'erreur dans FIN : appeler reset_print_function dans traiterFinExec ?
#from functools import partial
#asprint = partial(aster.affiche, 'MESSAGE')
#message.register_print_function(asprint)
"""
self.jdc.UserError=self.codex.error
- if self.jdc.par_lot == 'NON' :
+ if self.jdc.parLot == 'NON' :
self.jdc._Build()
# On execute la fonction debut pour initialiser les bases
# Cette execution est indispensable avant toute autre action sur ASTER
if not (UNITE or DONNEE) or hasattr(self, '_mark'):
return
self._mark = 1
- if self.jdc and self.jdc.par_lot == 'NON':
+ if self.jdc and self.jdc.parLot == 'NON':
# On est en mode commande par commande, on appelle la methode speciale
self.Execute_alone()
if UNITE:
list_co = set()
# par nom de concept (typ=assd)
for mc in self['CONCEPT'] or []:
- list_co.update(force_list(mc["NOM"]))
+ list_co.update(forceList(mc["NOM"]))
# par chaine de caractères (typ='TXM')
for mc in self['OBJET'] or []:
# longueur <= 8, on cherche les concepts existants
- for nom in force_list(mc['CHAINE']):
+ for nom in forceList(mc['CHAINE']):
assert type(nom) in (str, unicode), 'On attend une chaine de caractères : %s' % nom
if len(nom.strip()) <= 8:
if self.jdc.sds_dict.get(nom) != None:
# The catalogName can be consider as the -c option
sys.argv.append("-c")
sys.argv.append(catalogName)
- eficas_go.lance_eficas(code=prefs.code)
+ eficas_go.lanceEficas(code=prefs.code)
# ===================================================================
# This part is to manage the data saved from Eficas to comm file.
from InterfaceTK import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas_ssIhm_cherche_Groupes(code=prefs.code,version='STA10.3')
+eficas_go.lanceEficas_ssIhm_cherche_Groupes(code=prefs.code,version='STA10.3')
if len(sys.argv) > 1 :
# on veut ouvrir un fichier directement au lancement d'Eficas
- eficas_go.lance_eficas_ssIhm_reecrit(code='ASTER',fichier = sys.argv[1],version='STA11')
+ eficas_go.lanceEficas_ssIhm_reecrit(code='ASTER',fichier = sys.argv[1],version='STA11')
if len(sys.argv) > 1 :
# on veut ouvrir un fichier directement au lancement d'Eficas
- eficas_go.lance_eficas_ssIhm_cherche_cr(code='ASTER',fichier = sys.argv[1],version='STA10.3')
+ eficas_go.lanceEficas_ssIhm_cherche_cr(code='ASTER',fichier = sys.argv[1],version='STA10.3')
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
from PyQt4.QtCore import *
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
configuration.configBase.__init__(self,appli,repIni)\r
\r
#---------------------------------------\r
- def lecture_fichier_ini_standard(self):\r
+ def lectureFichierIniStandard(self):\r
#---------------------------------------\r
- configuration.configBase.lecture_fichier_ini_standard(self)\r
+ configuration.configBase.lectureFichierIniStandard(self)\r
if hasattr(self,'OpenTURNS_path') : self.oldOTPath=self.OpenTURNS_path\r
\r
#---------------------------------------\r
- def lecture_fichier_ini_integrateur(self):\r
+ def lectureFichierIniIntegrateur(self):\r
#---------------------------------------\r
- configuration.configBase.lecture_fichier_ini_utilisateur(self)\r
+ configuration.configBase.lectureFichierIniUtilisateur(self)\r
if hasattr(self,'OpenTURNS_path') :\r
if hasattr(self,'oldOTPath') and (self.OpenTURNS_path != self.oldOTPath):\r
import sys\r
import sys
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
configuration.configBase.__init__(self,appli,repIni)\r
\r
#---------------------------------------\r
- def lecture_fichier_ini_standard(self):\r
+ def lectureFichierIniStandard(self):\r
#---------------------------------------\r
- configuration.configBase.lecture_fichier_ini_standard(self)\r
+ configuration.configBase.lectureFichierIniStandard(self)\r
if hasattr(self,'OpenTURNS_path') : self.oldOTPath=self.OpenTURNS_path\r
\r
#---------------------------------------\r
- def lecture_fichier_ini_integrateur(self):\r
+ def lectureFichierIniIntegrateur(self):\r
#---------------------------------------\r
- configuration.configBase.lecture_fichier_ini_utilisateur(self)\r
+ configuration.configBase.lectureFichierIniUtilisateur(self)\r
if hasattr(self,'OpenTURNS_path') :\r
if hasattr(self,'oldOTPath') and (self.OpenTURNS_path != self.oldOTPath):\r
import sys\r
import sys
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
def processXLS(listeparam) :
print "dans processXLS"
item=listeparam[0]
- fileNameObj=item.object.get_child('XLS_file')
+ fileNameObj=item.object.getChild('XLS_file')
if fileNameObj : fileName=fileNameObj.getValeur()
else : fileName = ""
if fileName == "" : return 0, 'Nom de fichier invalide'
- ongletListObj=item.object.get_child('Onglets')
+ ongletListObj=item.object.getChild('Onglets')
if ongletListObj : ongletList= ongletListObj.getValeur()
else : ongletList = []
if ongletList == [] : return 0, 'ongletList invalide'
- busListObj=item.object.get_child('BusList')
+ busListObj=item.object.getChild('BusList')
if busListObj : busList= busListObj.getValeur()
else : busList = []
if busList == [] : return 0, 'BusList invalide'
- contListObj=item.object.get_child('ContList')
+ contListObj=item.object.getChild('ContList')
if contListObj : contList=contListObj.getValeur()
else : contList = []
if contList == [] : return 0, 'ContList invalide'
self.OngletsValeurs=[]
else :
# On teste si on a modifie la liste des onglets
- OngletsValeurs= self.get_child('Onglets').getVal()
+ OngletsValeurs= self.getChild('Onglets').getVal()
if not (hasattr(self,'OngletsValeurs')) : self.OngletsValeurs=OngletsValeurs
self.OngletsValeurs=[]
return
- OldBusValeurs= self.get_child('BusList').getVal()
- OldContValeurs= self.get_child('ContList').getVal()
+ OldBusValeurs= self.getChild('BusList').getVal()
+ OldContValeurs= self.getChild('ContList').getVal()
if OldBusValeurs == None : OldBusValeurs=[]
if OldContValeurs == None : OldContValeurs=[]
__import__(name)
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
from InterfaceQT4 import eficas_go
#from InterfaceQT import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
def view_med(params,appli) :
- mcSimp=params[0].object.get_child('cracked_name')
+ mcSimp=params[0].object.getChild('cracked_name')
fileName=mcSimp.valeur
import os
if not os.path.isfile(fileName) :
repertoire=SIMP(typ='Repertoire',fr= "Repertoire ",ang= " Directory",statut= "f",),
),
GROUPES=FACT(statut='f',
- regles=(AU_MOINS_UN('elset_names','faset_names','liset_names','nset_names'),),
- elset_names=SIMP(typ=grma,fr="",ang="names of volume element groups to be kept",min=1,max="**",statut="f"),
- faset_names=SIMP(typ=grma,fr="",ang="names of surface element groups to be kept",min=1,max="**",statut="f"),
- liset_names=SIMP(typ=grma,fr="",ang="names of line element groups to be kept",min=1,max="**",statut="f"),
- nset_names=SIMP(typ=grno,fr="" ,ang="names of node element groups to be kept",min=1,max="**",statut="f"),
+ regles=(AU_MOINS_UN('elsetNames','fasetNames','lisetNames','nsetNames'),),
+ elsetNames=SIMP(typ=grma,fr="",ang="names of volume element groups to be kept",min=1,max="**",statut="f"),
+ fasetNames=SIMP(typ=grma,fr="",ang="names of surface element groups to be kept",min=1,max="**",statut="f"),
+ lisetNames=SIMP(typ=grma,fr="",ang="names of line element groups to be kept",min=1,max="**",statut="f"),
+ nsetNames=SIMP(typ=grno,fr="" ,ang="names of node element groups to be kept",min=1,max="**",statut="f"),
)
)
from PyQt4.QtCore import *
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
pass
nouvelleVal=[]
- prob=item.object.get_child('Probability')
+ prob=item.object.getChild('Probability')
valeur=prob.getValeur()
texte=""
for v in valeur :
#fn=open('Classeur1.csv')
if not fn : return
nouvelleVal=[]
- prob=item.object.get_child('Probability')
+ prob=item.object.getChild('Probability')
monType=prob.definition.validators.typeDesTuples[0]
listeObjet=item.object.etape.parent.getSdAvantDuBonType(item.object.etape,(monType,))
for ligne in fn.readlines():
texte += nom + " : ignored (not known in Eficas) \n "
continue
try :
- concept=item.jdc.get_concept(nom)
+ concept=item.jdc.getConcept(nom)
except :
texte += nom + ": ignored (not known in Eficas) \n "
continue
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
def PROCESS_context(self,d):
print "dans le init du Process"
- if self.get_child('XLS_file').valeur == "" or self.get_child('XLS_file').valeur== None : return
- self.OngletsSelectionnes= self.get_child('b_TabList').get_child('TabList').valeur
+ if self.getChild('XLS_file').valeur == "" or self.getChild('XLS_file').valeur== None : return
+ self.OngletsSelectionnes= self.getChild('b_TabList').getChild('TabList').valeur
print "fin de PROCESS_context"
def PROCESS(self,XLS_file,**args):
# On a selectionne un onglet
# On teste si on a modifie la liste des onglets
- nouveauxOngletsSelectionnes= self.get_child('b_TabList').get_child('TabList').valeur
+ nouveauxOngletsSelectionnes= self.getChild('b_TabList').getChild('TabList').valeur
if nouveauxOngletsSelectionnes==self.OngletsSelectionnes : return
if nouveauxOngletsSelectionnes==() or nouveauxOngletsSelectionnes == [] :
for MC in self.MCAjoutes : self.jdc.editor.deleteMC(self,MC,('b_TabList',))
print ('kjlkjlkjkl')
from InterfaceQT4 import eficas_go
-if __name__ == '__main__': eficas_go.lance_eficas(code=prefs.code)
+if __name__ == '__main__': eficas_go.lanceEficas(code=prefs.code)
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
print ("traitement de : ", 'CasEn/'+f)
# on veut ouvrir un fichier directement au lancement d'Eficas
- eficas_go.lance_eficas_ssIhm_reecrit(code='TELEMAC',fichier = 'CasEn/'+f,ou = 'CasEn_Reecrits',cr=True)
+ eficas_go.lanceEficas_ssIhm_reecrit(code='TELEMAC',fichier = 'CasEn/'+f,ou = 'CasEn_Reecrits',cr=True)
print ("\n")
if __name__ == "__main__":
import optparse
- parser=optparse.OptionParser(usage="utilisation : %prog [options]")
+ parser=optparse.Optionparser(usage="utilisation : %prog [options]")
parser.add_option(u"-i","--input",dest="fichierIn",type='string',
help=("nom du fichier ts a traduire"))
parser.add_option(u"-d","--dico",dest="fichierDico",type='string',
if __name__ == "__main__":
import optparse
- parser=optparse.OptionParser(usage="utilisation : %prog [options]")
+ parser=optparse.Optionparser(usage="utilisation : %prog [options]")
parser.add_option(u"-i","--input",dest="fichierIn",type='string',
help=("nom du fichier ts a traduire"))
parser.add_option(u"-d","--dico",dest="fichierDico",type='string',
import prefs
from InterfaceTK import eficas_go
-eficas_go.lance_eficas()
+eficas_go.lanceEficas()
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
i=0
for f in glob.glob(os.path.join(ASTERDIR[version],files)):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
i=0
for f in glob.glob(os.path.join(ASTERDIR[version],files)):
return co
def add_mcsimp(obj,nom,valeur):
- mcs=obj.get_child(nom,restreint='oui')
+ mcs=obj.getChild(nom,restreint='oui')
if mcs is None:
- pos=obj.getIndex_child(nom)
+ pos=obj.getIndexChild(nom)
mcs=obj.addEntite(nom,pos)
- mcs.set_valeur(mcs.eval_val(valeur))
+ mcs.set_valeur(mcs.evalVal(valeur))
return mcs
def cdiff(text1,text2):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
i=0
files= os.path.join(os.path.dirname(__file__),"*.comm")
err=f.read()
f.close()
j=self.app.openJDC(file=file)
- assert j.cr.get_mess_exception() == ""
+ assert j.cr.getMessException() == ""
if err == "":
assert j.isValid(),j.report()
txt=str(j.report())
assert txt == err,cdiff(err,txt)
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
j.supprime()
assert sys.getrefcount(j) == 2,sys.getrefcount(j)
return co
def add_mcsimp(obj,nom,valeur):
- mcs=obj.get_child(nom,restreint='oui')
+ mcs=obj.getChild(nom,restreint='oui')
if mcs is None:
- pos=obj.getIndex_child(nom)
+ pos=obj.getIndexChild(nom)
mcs=obj.addEntite(nom,pos)
- mcs.set_valeur(mcs.eval_val(valeur))
+ mcs.set_valeur(mcs.evalVal(valeur))
return mcs
def cdiff(text1,text2):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
i=0
files= os.path.join(os.path.dirname(__file__),"*.comm")
err=f.read()
f.close()
j=self.app.openJDC(file=file)
- assert j.cr.get_mess_exception() == ""
+ assert j.cr.getMessException() == ""
if err == "":
assert j.isValid(),j.report()
txt=str(j.report())
assert txt == err,cdiff(err,txt)
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
j.supprime()
assert sys.getrefcount(j) == 2,sys.getrefcount(j)
return co
def add_mcsimp(obj,nom,valeur):
- mcs=obj.get_child(nom,restreint='oui')
+ mcs=obj.getChild(nom,restreint='oui')
if mcs is None:
- pos=obj.getIndex_child(nom)
+ pos=obj.getIndexChild(nom)
mcs=obj.addEntite(nom,pos)
- mcs.set_valeur(mcs.eval_val(valeur))
+ mcs.set_valeur(mcs.evalVal(valeur))
return mcs
def cdiff(text1,text2):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
i=0
files= os.path.join(os.path.dirname(__file__),"*.comm")
err=f.read()
f.close()
j=self.app.openJDC(file=file)
- assert j.cr.get_mess_exception() == ""
+ assert j.cr.getMessException() == ""
if err == "":
assert j.isValid(),j.report()
txt=str(j.report())
assert txt == err,cdiff(err,txt)
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
j.supprime()
assert sys.getrefcount(j) == 2,sys.getrefcount(j)
class CATA:
def __init__(self):
- CONTEXT.unset_current_cata()
- CONTEXT.set_current_cata(self)
+ CONTEXT.unsetCurrentCata()
+ CONTEXT.setCurrentCata(self)
def enregistre(self,cmd):
pass
def op5_prod(FFT,**args):
if (FFT != None) :
- vale=FFT.get_child('FONCTION').getValeur()
+ vale=FFT.getChild('FONCTION').getValeur()
if (AsType(vale) == concept ) : return concept
if (AsType(vale) == concept2) : return concept2
raise AsException("type de concept resultat non prevu")
class CATA:
def __init__(self):
- CONTEXT.unset_current_cata()
- CONTEXT.set_current_cata(self)
+ CONTEXT.unsetCurrentCata()
+ CONTEXT.setCurrentCata(self)
def enregistre(self,cmd):
pass
class concept3(ASSD,Noyau.AsBase):pass
def op2_prod(self,MATR,**args):
- self.type_sdprod(MATR,concept2)
+ self.typeSDProd(MATR,concept2)
return concept
OP2=MACRO(nom='OP2',op=-2,sd_prod=op2_prod,
def op3_prod(self,MATR,**args):
for m in MATR:
t=m['CHAM']
- if t == 'R':self.type_sdprod(m['MM'],concept)
+ if t == 'R':self.typeSDProd(m['MM'],concept)
return concept
OP3=MACRO(nom='OP3',op=-3,sd_prod=op3_prod,
class concept3(ASSD):pass
def op2_prod(self,MATR,**args):
- self.type_sdprod(MATR,concept2)
+ self.typeSDProd(MATR,concept2)
return concept
OP2=MACRO(nom='OP2',op=-2,sd_prod=op2_prod,
def op3_prod(self,MATR,**args):
for m in MATR:
t=m['CHAM']
- if t == 'R':self.type_sdprod(m['MM'],concept)
+ if t == 'R':self.typeSDProd(m['MM'],concept)
return concept
OP3=MACRO(nom='OP3',op=-3,sd_prod=op3_prod,
# le contexte de l etape pere (global au sens Python)
# et le contexte de l etape (local au sens Python)
code=compile(text,f,'exec')
- if self.jdc and self.jdc.par_lot == 'NON':
+ if self.jdc and self.jdc.parLot == 'NON':
# On est en mode commande par commande
# On teste la validite de la commande avec interruption eventuelle
cr=self.report()
return ier
def op2_prod(self,MATR,**args):
- self.type_sdprod(MATR,concept2)
+ self.typeSDProd(MATR,concept2)
return concept
OP1=MACRO(nom='OP1',op=OP_ops,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=CO),)
OP2=MACRO(nom='OP2',op=OP_ops,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=(CO,concept2)),)
def op3_prod(self,MATR,**args):
for m in MATR:
t=m['CHAM']
- if t == 'R':self.type_sdprod(m['MM'],concept)
+ if t == 'R':self.typeSDProd(m['MM'],concept)
return concept
OP3=MACRO(nom='OP3',op=OP_ops,sd_prod=op3_prod,
MATR=FACT(statut='f',min=1,max='**',
OP5=MACRO(nom='OP5',op=OP_ops,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=CO),)
def op6_prod(self,MATR,**args):
- self.type_sdprod(MATR,concept4)
+ self.typeSDProd(MATR,concept4)
return concept
def OP6_ops(self,MATR,**args):
ier=0
#j.UserError=j.codex.error
j.actif_status=1
j.fico=None
- j.set_par_lot(PAR_LOT)
+ j.set_parLot(PAR_LOT)
if hasattr(self,'already_init'):return
self.already_init=None
context={}
#j.UserError=j.codex.error
j.actif_status=1
j.fico=None
- j.set_par_lot(PAR_LOT)
+ j.set_parLot(PAR_LOT)
return None
def debut(self,PAR_LOT):
return co
def add_mcsimp(obj,nom,valeur):
- mcs=obj.get_child(nom,restreint='oui')
+ mcs=obj.getChild(nom,restreint='oui')
if mcs is None:
- pos=obj.getIndex_child(nom)
+ pos=obj.getIndexChild(nom)
mcs=obj.addEntite(nom,pos)
- mcs.set_valeur(mcs.eval_val(valeur))
+ mcs.set_valeur(mcs.evalVal(valeur))
return mcs
def cdiff(text1,text2):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
def test000(self):
""" Test de construction du fichier de commandes az.comm de zero"""
co=j.addEntite("LIRE_MAILLAGE",pos)
test,mess=co.nommeSd("MAILLA2")
mcs=co.addEntite("UNITE")
- valeur=mcs.eval_val("P4[1]")
+ valeur=mcs.evalVal("P4[1]")
test=mcs.set_valeur(valeur)
# formule
pos=pos+1
co=j.addEntite("FORMULE",pos)
- co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
+ co.updateFormulePython(("aaa","REEL","a+z","(a,z)"))
# commande LIRE_MAILLAGE
pos=pos+1
ma=co=j.addEntite("LIRE_MAILLAGE",pos)
test,mess=co.nommeSd("MAIL")
mcs=co.addEntite("UNITE")
- valeur,validite=mcs.eval_valeur("P3")
+ valeur,validite=mcs.evalValeur("P3")
test=mcs.set_valeur(valeur)
#
pos=pos+1
# formule
pos=pos+1
co=j.addEntite("FORMULE",pos)
- co.update_formule_python(("az","REEL","aaaaa","(ae,inst)"))
+ co.updateFormulePython(("az","REEL","aaaaa","(ae,inst)"))
# commande AFFE_MODELE
pos=pos+1
co=j.addEntite("AFFE_MODELE",pos)
- mcs=co.get_child("MAILLAGE")
- valeur,validite=mcs.eval_valeur("MAIL")
+ mcs=co.getChild("MAILLAGE")
+ valeur,validite=mcs.evalValeur("MAIL")
assert valeur == ma.sd
test=mcs.set_valeur(valeur)
assert valeur == co["MAILLAGE"]
mcf=co.addEntite("AFFE")
- mcs=mcf[0].get_child("PHENOMENE")
- valeur=mcs.eval_val_item('MECANIQUE')
+ mcs=mcf[0].getChild("PHENOMENE")
+ valeur=mcs.evalValItem('MECANIQUE')
assert valeur=='MECANIQUE',str(valeur)
test=mcs.set_valeur(valeur)
assert mcf["PHENOMENE"] == 'MECANIQUE'
- mcs=mcf[0].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[0].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
assert mcf["MODELISATION"] == 'DIS_T'
mcs=add_mcsimp(mcf[0],"GROUP_MA",('RESSORT','eee',))
mcf=co.addEntite("AFFE")
- mcs=mcf[1].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
- mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[1].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('MECANIQUE'))
+ mcs=mcf[1].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
mcf=co.addEntite("AFFE")
- mcs=mcf[2].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('ACOUSTIQUE'))
- mcs=mcf[2].get_child("b_acoustique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('PLAN'))
+ mcs=mcf[2].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('ACOUSTIQUE'))
+ mcs=mcf[2].getChild("b_acoustique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('PLAN'))
#mcs=add_mcsimp(mcf[2],"GROUP_NO",'GNP3,GNP5,GNP6,GNP7,GNP8,GNP9,GNP10,GNP11,GNP12')
mcs=add_mcsimp(mcf[2],"GROUP_NO","'GNP3','GNP5','GNP6','GNP7','GNP8','GNP9','GNP10','GNP11','GNP12'")
# commande AFFE_MODELE
pos=pos+1
co=j.addEntite("AFFE_MODELE",pos)
- mcs=co.get_child("MAILLAGE")
- mcs.set_valeur(mcs.eval_val("MAIL"))
+ mcs=co.getChild("MAILLAGE")
+ mcs.set_valeur(mcs.evalVal("MAIL"))
mcf=co.addEntite("AFFE")
- mcs=mcf[0].get_child("PHENOMENE")
- valeur=mcs.eval_val_item('MECANIQUE')
+ mcs=mcf[0].getChild("PHENOMENE")
+ valeur=mcs.evalValItem('MECANIQUE')
test=mcs.set_valeur(valeur)
- mcs=mcf[0].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[0].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
mcs=add_mcsimp(mcf[0],"GROUP_MA",'RESSORT')
mcf=co.addEntite("AFFE")
- mcs=mcf[1].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
- mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[1].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('MECANIQUE'))
+ mcs=mcf[1].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
mcf=co.addEntite("AFFE")
- mcs=mcf[2].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('THERMIQUE'))
- mcs=mcf[2].get_child("b_thermique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('COQUE'))
+ mcs=mcf[2].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('THERMIQUE'))
+ mcs=mcf[2].getChild("b_thermique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('COQUE'))
mcs=add_mcsimp(mcf[2],"TOUT",'OUI')
co.nommeSd("MOD")
# VALE=(3.0,P6,),),);
pos=pos+1
co=j.addEntite("AFFE_CARA_ELEM",pos)
- mcs=co.get_child("MODELE")
- mcs.set_valeur(mcs.eval_val("MOD"))
+ mcs=co.getChild("MODELE")
+ mcs.set_valeur(mcs.evalVal("MOD"))
mcf=co.addEntite("POUTRE")
- mcs=mcf[0].get_child("SECTION")
- mcs.set_valeur(mcs.eval_val('CERCLE'))
+ mcs=mcf[0].getChild("SECTION")
+ mcs.set_valeur(mcs.evalVal('CERCLE'))
assert mcf[0]["SECTION"] == 'CERCLE'
mcs=add_mcsimp(mcf[0],"GROUP_MA",'MA')
- mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("CARA")
- mcs.set_valeur(mcs.eval_val('R'))
- mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("VALE")
- mcs.set_valeur(mcs.eval_val('3.0,P6'))
+ mcs=mcf[0].getChild("b_cercle").getChild("b_constant").getChild("CARA")
+ mcs.set_valeur(mcs.evalVal('R'))
+ mcs=mcf[0].getChild("b_cercle").getChild("b_constant").getChild("VALE")
+ mcs.set_valeur(mcs.evalVal('3.0,P6'))
co.nommeSd("CARA")
# commentaire
pos=pos+1
# VALE=(5.0,3.0,P4[1],P3,),);
pos=pos+1
co=j.addEntite("DEFI_FONCTION",pos)
- mcs=co.get_child("NOM_PARA")
- mcs.set_valeur(mcs.eval_val("DX"))
+ mcs=co.getChild("NOM_PARA")
+ mcs.set_valeur(mcs.evalVal("DX"))
mcs=co.addEntite("VALE")
- mcs.set_valeur(mcs.eval_val("5.0,3.0,P4[1],P3"))
+ mcs.set_valeur(mcs.evalVal("5.0,3.0,P4[1],P3"))
co.nommeSd("F1")
#F3=DEFI_FONCTION(NOM_PARA='DRX',
# VALE_C=(5.0,7.0,9.0,9.0,8.0,7.0,),);
pos=pos+1
co=j.addEntite("DEFI_FONCTION",pos)
- mcs=co.get_child("NOM_PARA")
- mcs.set_valeur(mcs.eval_val("DRX"))
+ mcs=co.getChild("NOM_PARA")
+ mcs.set_valeur(mcs.evalVal("DRX"))
mcs=co.addEntite("VALE_C")
- mcs.set_valeur(mcs.eval_val("5.0,7.0,9.0,9.0,8.0,7.0"))
+ mcs.set_valeur(mcs.evalVal("5.0,7.0,9.0,9.0,8.0,7.0"))
co.nommeSd("F3")
# commentaire
pos=pos+1
pos=pos+1
co=j.addEntite("DEFI_MATERIAU",pos)
mcf=co.addEntite("ELAS")
- mcs=mcf[0].get_child("E")
- mcs.set_valeur(mcs.eval_val("100000000000.0"))
- mcs=mcf[0].get_child("NU")
- mcs.set_valeur(mcs.eval_val("0.0"))
+ mcs=mcf[0].getChild("E")
+ mcs.set_valeur(mcs.evalVal("100000000000.0"))
+ mcs=mcf[0].getChild("NU")
+ mcs.set_valeur(mcs.evalVal("0.0"))
mcf=co.addEntite("ECRO_ASYM_LINE")
- mcs=mcf[0].get_child("DC_SIGM_EPSI")
- mcs.set_valeur(mcs.eval_val("0.0"))
- mcs=mcf[0].get_child("DT_SIGM_EPSI")
- mcs.set_valeur(mcs.eval_val("0.0"))
- mcs=mcf[0].get_child("SY_C")
- mcs.set_valeur(mcs.eval_val("200000000.0"))
- mcs=mcf[0].get_child("SY_T")
- mcs.set_valeur(mcs.eval_val("50000000.0"))
+ mcs=mcf[0].getChild("DC_SIGM_EPSI")
+ mcs.set_valeur(mcs.evalVal("0.0"))
+ mcs=mcf[0].getChild("DT_SIGM_EPSI")
+ mcs.set_valeur(mcs.evalVal("0.0"))
+ mcs=mcf[0].getChild("SY_C")
+ mcs.set_valeur(mcs.evalVal("200000000.0"))
+ mcs=mcf[0].getChild("SY_T")
+ mcs.set_valeur(mcs.evalVal("50000000.0"))
co.nommeSd("MATER2")
#PS1=DEFI_PARA_SENSI(VALE=1.0,);
#PS2=DEFI_PARA_SENSI(VALE=1.0,);
#PS3=DEFI_PARA_SENSI(VALE=1.0,);
pos=pos+1
co=j.addEntite("DEFI_PARA_SENSI",pos)
- mcs=co.get_child("VALE")
- mcs.set_valeur(mcs.eval_val("1.0"))
+ mcs=co.getChild("VALE")
+ mcs.set_valeur(mcs.evalVal("1.0"))
co.nommeSd("PS1")
pos=pos+1
co=j.addEntite("DEFI_PARA_SENSI",pos)
- mcs=co.get_child("VALE")
- mcs.set_valeur(mcs.eval_val("1.0"))
+ mcs=co.getChild("VALE")
+ mcs.set_valeur(mcs.evalVal("1.0"))
co.nommeSd("PS2")
pos=pos+1
co=j.addEntite("DEFI_PARA_SENSI",pos)
- mcs=co.get_child("VALE")
- mcs.set_valeur(mcs.eval_val("1.0"))
+ mcs=co.getChild("VALE")
+ mcs.set_valeur(mcs.evalVal("1.0"))
co.nommeSd("PS3")
#CHMAT2=AFFE_MATERIAU(MAILLAGE=MAIL,
# AFFE=_F(TOUT='OUI',
pos=pos+1
co=j.addEntite("AFFE_MATERIAU",pos)
add_mcsimp(co,"MAILLAGE","MAIL")
- mcf=co.get_child("AFFE")
+ mcf=co.getChild("AFFE")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"MATER","MATER2")
co.nommeSd("CHMAT2")
co=j.addEntite("THER_LINEAIRE",pos)
add_mcsimp(co,"MODELE","AFFE1")
add_mcsimp(co,"CHAM_MATER","CHMAT2")
- mcf=co.get_child("EXCIT")
+ mcf=co.getChild("EXCIT")
add_mcsimp(mcf[0],"CHARGE","AAAZ")
add_mcsimp(co,"SENSIBILITE","PS1,PS2")
co.nommeSd("TH1")
pos=pos+1
co=j.addEntite("MACRO_MATR_ASSE",pos)
add_mcsimp(co,"MODELE","AFFE1")
- mcs=co.get_child("NUME_DDL")
+ mcs=co.getChild("NUME_DDL")
mcs.set_valeur_co('DDL1')
- mcf=co.get_child("MATR_ASSE")
+ mcf=co.getChild("MATR_ASSE")
add_mcsimp(mcf[0],"OPTION","RIGI_THER")
- mcs=mcf[0].get_child("MATRICE")
+ mcs=mcf[0].getChild("MATRICE")
mcs.set_valeur_co('MAT1')
# commentaire
pos=pos+1
# formule
pos=pos+1
co=j.addEntite("FORMULE",pos)
- co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
+ co.updateFormulePython(("aaa","REEL","a+z","(a,z)"))
#parametre de formule
pos=pos+1
co=add_param(j,pos,"P3","aaa(P1,2.)")
class CATA:
def __init__(self):
- CONTEXT.unset_current_cata()
- CONTEXT.set_current_cata(self)
+ CONTEXT.unsetCurrentCata()
+ CONTEXT.setCurrentCata(self)
def enregistre(self,cmd):
pass
def test032(self):
cata=FACT(max=3,a=SIMP(typ='I',statut='o'),)
mcfact=cata({'a':1},'mcf',None)
- self.assertEqual(mcfact[0].get_mocle('a') , 1)
+ self.assertEqual(mcfact[0].getMocle('a') , 1)
self.assertEqual(mcfact['a'] , 1)
mcfact=cata(({'a':1},{'a':2}),'mcf',None)
dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
#dico=mcfact.creeDictValeurs(mcfact.mc_liste)
self.assertEqual(dico , valeur_attendue)
- self.assertEqual(mcfact[0].get_mocle('TOTO') , 'AAA')
- self.assertEqual(mcfact[0].get_mocle('ZORGLUB') , 'OOO')
+ self.assertEqual(mcfact[0].getMocle('TOTO') , 'AAA')
+ self.assertEqual(mcfact[0].getMocle('ZORGLUB') , 'OOO')
self.assertEqual(mcfact['TOTO'] , 'AAA')
self.assertRaises(IndexError, mcfact.__getitem__, 'TITI')
dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
#dico=mcfact.creeDictValeurs(mcfact.mc_liste)
self.assertEqual(dico , valeur_attendue)
- self.assertEqual(mcfact[0].get_mocle('ZORGLUB') , 'OOO')
+ self.assertEqual(mcfact[0].getMocle('ZORGLUB') , 'OOO')
def test003(self):
cata=FACT(ZORGLUB =SIMP(statut='f',typ='TXM',defaut='OOO'),
valeur_attendue={'ZORGLUB':'ZZZ', 'TOTO':'AAA'}
dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
self.assertEqual(dico , valeur_attendue)
- self.assertEqual(mcfact[0].get_mocle('ZORGLUB') , 'ZZZ')
+ self.assertEqual(mcfact[0].getMocle('ZORGLUB') , 'ZZZ')
self.assertEqual(mcfact['TOTO'] , 'AAA')
def test004(self):
valeur_attendue={'ZORGLUB':'OOO','TOTO':None}
dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
self.assertEqual(dico , valeur_attendue)
- self.assertEqual(mcfact[0].get_mocle('TOTO') , None)
- self.assertEqual(mcfact[0].get_child('ZORGLUB').getValeur() , 'OOO')
- self.assertEqual(mcfact[0].get_child('b_unit1').get_child('TOTO').getValeur() , None)
+ self.assertEqual(mcfact[0].getMocle('TOTO') , None)
+ self.assertEqual(mcfact[0].getChild('ZORGLUB').getValeur() , 'OOO')
+ self.assertEqual(mcfact[0].getChild('b_unit1').getChild('TOTO').getValeur() , None)
self.assertEqual(mcfact['TOTO'] , None)
def test005(self):
dico=mcfact[0].creeDictValeurs(mcfact[0].mc_liste)
self.assertEqual(dico , valeur_attendue)
- self.assertEqual(mcfact[0].get_child('TATA').getValeur() , 'AAA')
- self.assertEqual(mcfact[0].get_child('TITI').getValeur() , 'AAA')
- self.assertEqual(mcfact[0].get_child('TUTU').getValeur() , 'AAA')
- self.assertEqual(mcfact[0].get_child('TOTO').getValeur() , 'BBB')
+ self.assertEqual(mcfact[0].getChild('TATA').getValeur() , 'AAA')
+ self.assertEqual(mcfact[0].getChild('TITI').getValeur() , 'AAA')
+ self.assertEqual(mcfact[0].getChild('TUTU').getValeur() , 'AAA')
+ self.assertEqual(mcfact[0].getChild('TOTO').getValeur() , 'BBB')
self.assertEqual(mcfact['TITI'] , 'AAA')
self.assertEqual(mcfact['TUTU'] , 'AAA')
self.assertEqual(mcfact['TATA'] , 'AAA')
self.assertEqual(mcfact['TOTO1'] , 'AAA')
self.assertEqual(mcfact['TOTO2'] , 'AAA')
self.assertEqual(mcfact['TOTO4'] , 'AAA')
- self.assertRaises(IndexError, mcfact[0].get_mocle, 'TOTO3')
+ self.assertRaises(IndexError, mcfact[0].getMocle, 'TOTO3')
self.assertEqual(mcfact['UNITE1'] , 25)
self.assertEqual(mcfact['UNITE4'] , 25)
self.assertRaises(IndexError, mcfact.__getitem__, 'UNITE2')
self.assertRaises(IndexError, mcfact.__getitem__, 'UNITE3')
- self.assertRaises(IndexError, mcfact[0].get_mocle, 'UNITE2')
- self.assertRaises(IndexError, mcfact[0].get_mocle, 'UNITE3')
+ self.assertRaises(IndexError, mcfact[0].getMocle, 'UNITE2')
+ self.assertRaises(IndexError, mcfact[0].getMocle, 'UNITE3')
- self.assertEqual(mcfact[0].get_child('b_unit4').get_child('TOTO4').getValeur(),'AAA')
- self.assertEqual(mcfact[0].get_child('b_unit4').getValeur(),{'TOTO4': 'AAA', 'UNITE4': 25})
+ self.assertEqual(mcfact[0].getChild('b_unit4').getChild('TOTO4').getValeur(),'AAA')
+ self.assertEqual(mcfact[0].getChild('b_unit4').getValeur(),{'TOTO4': 'AAA', 'UNITE4': 25})
return co
def add_mcsimp(obj,nom,valeur):
- mcs=obj.get_child(nom,restreint='oui')
+ mcs=obj.getChild(nom,restreint='oui')
if mcs is None:
- pos=obj.getIndex_child(nom)
+ pos=obj.getIndexChild(nom)
mcs=obj.addEntite(nom,pos)
- mcs.set_valeur(mcs.eval_val(valeur))
+ mcs.set_valeur(mcs.evalVal(valeur))
return mcs
def cdiff(text1,text2):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
def test001(self):
"""Test comploader"""
if it.nom in ("AFFE_MODELE","AFFE_MATERIAU") :
for mc in it.getSubList():
if mc.nom == "MAILLAGE":
- valeur,validite=mc.eval_valeur("MAIL")
+ valeur,validite=mc.evalValeur("MAIL")
test = mc.set_valeur(valeur)
text1=app.get_text_JDC(j,'python')
f=open(file)
return co
def add_mcsimp(obj,nom,valeur):
- mcs=obj.get_child(nom,restreint='oui')
+ mcs=obj.getChild(nom,restreint='oui')
if mcs is None:
- pos=obj.getIndex_child(nom)
+ pos=obj.getIndexChild(nom)
mcs=obj.addEntite(nom,pos)
- mcs.set_valeur(mcs.eval_val(valeur))
+ mcs.set_valeur(mcs.evalVal(valeur))
return mcs
def cdiff(text1,text2):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
def test000(self):
app=appli.STANDALONE(version=version)
co=j.addEntite("LIRE_MAILLAGE",pos)
test,mess=co.nommeSd("MAILLA2")
mcs=co.addEntite("UNITE")
- valeur=mcs.eval_val("P4[1]")
+ valeur=mcs.evalVal("P4[1]")
test=mcs.set_valeur(valeur)
# formule
pos=pos+1
co=j.addEntite("FORMULE",pos)
- co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
+ co.updateFormulePython(("aaa","REEL","a+z","(a,z)"))
# commande LIRE_MAILLAGE
pos=pos+1
ma=co=j.addEntite("LIRE_MAILLAGE",pos)
test,mess=co.nommeSd("MAIL")
mcs=co.addEntite("UNITE")
- valeur,validite=mcs.eval_valeur("P3")
+ valeur,validite=mcs.evalValeur("P3")
test=mcs.set_valeur(valeur)
#
pos=pos+1
# formule
pos=pos+1
co=j.addEntite("FORMULE",pos)
- co.update_formule_python(("az","REEL","aaaaa","(ae,inst)"))
+ co.updateFormulePython(("az","REEL","aaaaa","(ae,inst)"))
# commande AFFE_MODELE
pos=pos+1
co=j.addEntite("AFFE_MODELE",pos)
- mcs=co.get_child("MAILLAGE")
- valeur,validite=mcs.eval_valeur("MAIL")
+ mcs=co.getChild("MAILLAGE")
+ valeur,validite=mcs.evalValeur("MAIL")
assert valeur == ma.sd
test=mcs.set_valeur(valeur)
assert valeur == co["MAILLAGE"]
mcf=co.addEntite("AFFE")
- mcs=mcf[0].get_child("PHENOMENE")
- valeur=mcs.eval_val_item('MECANIQUE')
+ mcs=mcf[0].getChild("PHENOMENE")
+ valeur=mcs.evalValItem('MECANIQUE')
assert valeur=='MECANIQUE',str(valeur)
test=mcs.set_valeur(valeur)
assert mcf["PHENOMENE"] == 'MECANIQUE'
- mcs=mcf[0].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[0].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
assert mcf["MODELISATION"] == 'DIS_T'
mcs=add_mcsimp(mcf[0],"GROUP_MA",('RESSORT','eee',))
mcf=co.addEntite("AFFE")
- mcs=mcf[1].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
- mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[1].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('MECANIQUE'))
+ mcs=mcf[1].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
mcf=co.addEntite("AFFE")
- mcs=mcf[2].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('ACOUSTIQUE'))
- mcs=mcf[2].get_child("b_acoustique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('PLAN'))
+ mcs=mcf[2].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('ACOUSTIQUE'))
+ mcs=mcf[2].getChild("b_acoustique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('PLAN'))
#mcs=add_mcsimp(mcf[2],"GROUP_NO",'GNP3,GNP5,GNP6,GNP7,GNP8,GNP9,GNP10,GNP11,GNP12')
mcs=add_mcsimp(mcf[2],"GROUP_NO","'GNP3','GNP5','GNP6','GNP7','GNP8','GNP9','GNP10','GNP11','GNP12'")
# commande AFFE_MODELE
pos=pos+1
co=j.addEntite("AFFE_MODELE",pos)
- mcs=co.get_child("MAILLAGE")
- mcs.set_valeur(mcs.eval_val("MAIL"))
+ mcs=co.getChild("MAILLAGE")
+ mcs.set_valeur(mcs.evalVal("MAIL"))
mcf=co.addEntite("AFFE")
- mcs=mcf[0].get_child("PHENOMENE")
- valeur=mcs.eval_val_item('MECANIQUE')
+ mcs=mcf[0].getChild("PHENOMENE")
+ valeur=mcs.evalValItem('MECANIQUE')
test=mcs.set_valeur(valeur)
- mcs=mcf[0].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[0].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
mcs=add_mcsimp(mcf[0],"GROUP_MA",'RESSORT')
mcf=co.addEntite("AFFE")
- mcs=mcf[1].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
- mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[1].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('MECANIQUE'))
+ mcs=mcf[1].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
mcf=co.addEntite("AFFE")
- mcs=mcf[2].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('THERMIQUE'))
- mcs=mcf[2].get_child("b_thermique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('COQUE'))
+ mcs=mcf[2].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('THERMIQUE'))
+ mcs=mcf[2].getChild("b_thermique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('COQUE'))
mcs=add_mcsimp(mcf[2],"TOUT",'OUI')
co.nommeSd("MOD")
# VALE=(3.0,P6,),),);
pos=pos+1
co=j.addEntite("AFFE_CARA_ELEM",pos)
- mcs=co.get_child("MODELE")
- mcs.set_valeur(mcs.eval_val("MOD"))
+ mcs=co.getChild("MODELE")
+ mcs.set_valeur(mcs.evalVal("MOD"))
mcf=co.addEntite("POUTRE")
- mcs=mcf[0].get_child("SECTION")
- mcs.set_valeur(mcs.eval_val('CERCLE'))
+ mcs=mcf[0].getChild("SECTION")
+ mcs.set_valeur(mcs.evalVal('CERCLE'))
assert mcf[0]["SECTION"] == 'CERCLE'
mcs=add_mcsimp(mcf[0],"GROUP_MA",'MA')
- mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("CARA")
- mcs.set_valeur(mcs.eval_val('R'))
- mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("VALE")
- mcs.set_valeur(mcs.eval_val('3.0,P6'))
+ mcs=mcf[0].getChild("b_cercle").getChild("b_constant").getChild("CARA")
+ mcs.set_valeur(mcs.evalVal('R'))
+ mcs=mcf[0].getChild("b_cercle").getChild("b_constant").getChild("VALE")
+ mcs.set_valeur(mcs.evalVal('3.0,P6'))
co.nommeSd("CARA")
# commentaire
pos=pos+1
# VALE=(5.0,3.0,P4[1],P3,),);
pos=pos+1
co=j.addEntite("DEFI_FONCTION",pos)
- mcs=co.get_child("NOM_PARA")
- mcs.set_valeur(mcs.eval_val("DX"))
+ mcs=co.getChild("NOM_PARA")
+ mcs.set_valeur(mcs.evalVal("DX"))
mcs=co.addEntite("VALE")
- mcs.set_valeur(mcs.eval_val("5.0,3.0,P4[1],P3"))
+ mcs.set_valeur(mcs.evalVal("5.0,3.0,P4[1],P3"))
co.nommeSd("F1")
#F3=DEFI_FONCTION(NOM_PARA='DRX',
# VALE_C=(5.0,7.0,9.0,9.0,8.0,7.0,),);
pos=pos+1
co=j.addEntite("DEFI_FONCTION",pos)
- mcs=co.get_child("NOM_PARA")
- mcs.set_valeur(mcs.eval_val("DRX"))
+ mcs=co.getChild("NOM_PARA")
+ mcs.set_valeur(mcs.evalVal("DRX"))
mcs=co.addEntite("VALE_C")
- mcs.set_valeur(mcs.eval_val("5.0,7.0,9.0,9.0,8.0,7.0"))
+ mcs.set_valeur(mcs.evalVal("5.0,7.0,9.0,9.0,8.0,7.0"))
co.nommeSd("F3")
# commentaire
pos=pos+1
pos=pos+1
co=j.addEntite("DEFI_MATERIAU",pos)
mcf=co.addEntite("ELAS")
- mcs=mcf[0].get_child("E")
- mcs.set_valeur(mcs.eval_val("100000000000.0"))
- mcs=mcf[0].get_child("NU")
- mcs.set_valeur(mcs.eval_val("0.0"))
+ mcs=mcf[0].getChild("E")
+ mcs.set_valeur(mcs.evalVal("100000000000.0"))
+ mcs=mcf[0].getChild("NU")
+ mcs.set_valeur(mcs.evalVal("0.0"))
mcf=co.addEntite("ECRO_ASYM_LINE")
- mcs=mcf[0].get_child("DC_SIGM_EPSI")
- mcs.set_valeur(mcs.eval_val("0.0"))
- mcs=mcf[0].get_child("DT_SIGM_EPSI")
- mcs.set_valeur(mcs.eval_val("0.0"))
- mcs=mcf[0].get_child("SY_C")
- mcs.set_valeur(mcs.eval_val("200000000.0"))
- mcs=mcf[0].get_child("SY_T")
- mcs.set_valeur(mcs.eval_val("50000000.0"))
+ mcs=mcf[0].getChild("DC_SIGM_EPSI")
+ mcs.set_valeur(mcs.evalVal("0.0"))
+ mcs=mcf[0].getChild("DT_SIGM_EPSI")
+ mcs.set_valeur(mcs.evalVal("0.0"))
+ mcs=mcf[0].getChild("SY_C")
+ mcs.set_valeur(mcs.evalVal("200000000.0"))
+ mcs=mcf[0].getChild("SY_T")
+ mcs.set_valeur(mcs.evalVal("50000000.0"))
co.nommeSd("MATER2")
#PS1=DEFI_PARA_SENSI(VALE=1.0,);
#PS2=DEFI_PARA_SENSI(VALE=1.0,);
#PS3=DEFI_PARA_SENSI(VALE=1.0,);
pos=pos+1
co=j.addEntite("DEFI_PARA_SENSI",pos)
- mcs=co.get_child("VALE")
- mcs.set_valeur(mcs.eval_val("1.0"))
+ mcs=co.getChild("VALE")
+ mcs.set_valeur(mcs.evalVal("1.0"))
co.nommeSd("PS1")
pos=pos+1
co=j.addEntite("DEFI_PARA_SENSI",pos)
- mcs=co.get_child("VALE")
- mcs.set_valeur(mcs.eval_val("1.0"))
+ mcs=co.getChild("VALE")
+ mcs.set_valeur(mcs.evalVal("1.0"))
co.nommeSd("PS2")
pos=pos+1
co=j.addEntite("DEFI_PARA_SENSI",pos)
- mcs=co.get_child("VALE")
- mcs.set_valeur(mcs.eval_val("1.0"))
+ mcs=co.getChild("VALE")
+ mcs.set_valeur(mcs.evalVal("1.0"))
co.nommeSd("PS3")
#CHMAT2=AFFE_MATERIAU(MAILLAGE=MAIL,
# AFFE=_F(TOUT='OUI',
pos=pos+1
co=j.addEntite("AFFE_MATERIAU",pos)
add_mcsimp(co,"MAILLAGE","MAIL")
- mcf=co.get_child("AFFE")
+ mcf=co.getChild("AFFE")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"MATER","MATER2")
co.nommeSd("CHMAT2")
co=j.addEntite("THER_LINEAIRE",pos)
add_mcsimp(co,"MODELE","AFFE1")
add_mcsimp(co,"CHAM_MATER","CHMAT2")
- mcf=co.get_child("EXCIT")
+ mcf=co.getChild("EXCIT")
add_mcsimp(mcf[0],"CHARGE","AAAZ")
add_mcsimp(co,"SENSIBILITE","PS1,PS2")
co.nommeSd("TH1")
pos=pos+1
co=j.addEntite("MACRO_MATR_ASSE",pos)
add_mcsimp(co,"MODELE","AFFE1")
- mcs=co.get_child("NUME_DDL")
+ mcs=co.getChild("NUME_DDL")
mcs.set_valeur_co('DDL1')
- mcf=co.get_child("MATR_ASSE")
+ mcf=co.getChild("MATR_ASSE")
add_mcsimp(mcf[0],"OPTION","RIGI_THER")
- mcs=mcf[0].get_child("MATRICE")
+ mcs=mcf[0].getChild("MATRICE")
mcs.set_valeur_co('MAT1')
# commentaire
pos=pos+1
# formule
pos=pos+1
co=j.addEntite("FORMULE",pos)
- co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
+ co.updateFormulePython(("aaa","REEL","a+z","(a,z)"))
#parametre de formule
pos=pos+1
co=add_param(j,pos,"P3","aaa(P1,2.)")
j=cata.JdC(procedure=text_jdc,cata=cata,nom="bidon")
j.actif_status=1
j.fico=None
- j.set_par_lot("OUI")
+ j.set_parLot("OUI")
# On compile le texte Python
j.compile()
# On initialise les tops de mesure globale de temps d'execution du jdc
j.supprime()
return
- j.exec_compile()
+ j.execCompile()
#print j.cr
if err2 == "":
- self.assert_(j.cr.estvide(),msg='Erreur non attendue dans exec_compile (err2):\n%s' % str(j.cr))
+ self.assert_(j.cr.estvide(),msg='Erreur non attendue dans execCompile (err2):\n%s' % str(j.cr))
else:
- self.assert_(self.check(err2,str(j.cr)),msg='Erreur non attendue dans exec_compile(err2):\n%s\n!=\n%s' % (str(j.cr),err2))
+ self.assert_(self.check(err2,str(j.cr)),msg='Erreur non attendue dans execCompile(err2):\n%s\n!=\n%s' % (str(j.cr),err2))
j.supprime()
return
cr=j.report()
#print cr
if err3 == "":
- self.assert_(cr.estvide(),msg='Erreur non attendue dans exec_compile (err3):\n%s' % str(cr))
+ self.assert_(cr.estvide(),msg='Erreur non attendue dans execCompile (err3):\n%s' % str(cr))
else:
- self.assert_(self.check(err3,str(cr)),msg='Erreur non attendue dans exec_compile(err3):\n%s\n!=\n%s' % (str(cr),err3))
+ self.assert_(self.check(err3,str(cr)),msg='Erreur non attendue dans execCompile(err3):\n%s\n!=\n%s' % (str(cr),err3))
j.supprime()
return
- j.set_par_lot("NON")
+ j.set_parLot("NON")
j.supprime()
return co
def add_mcsimp(obj,nom,valeur):
- mcs=obj.get_child(nom,restreint='oui')
+ mcs=obj.getChild(nom,restreint='oui')
if mcs is None:
- pos=obj.getIndex_child(nom)
+ pos=obj.getIndexChild(nom)
mcs=obj.addEntite(nom,pos)
- mcs.set_valeur(mcs.eval_val(valeur))
+ mcs.set_valeur(mcs.evalVal(valeur))
return mcs
def cdiff(text1,text2):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
def test001(self):
""" Test de commentarisation/decommentarisation de commandes dans fichier az.comm"""
return co
def add_mcsimp(obj,nom,valeur):
- mcs=obj.get_child(nom,restreint='oui')
+ mcs=obj.getChild(nom,restreint='oui')
if mcs is None:
- pos=obj.getIndex_child(nom)
+ pos=obj.getIndexChild(nom)
mcs=obj.addEntite(nom,pos)
- mcs.set_valeur(mcs.eval_val(valeur))
+ mcs.set_valeur(mcs.evalVal(valeur))
return mcs
def cdiff(text1,text2):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
i=0
for f in ("params.comm",):
def test06(self):
""" Test fonction sd_prod
- Test sur un mot-clé simple d'un mot-clé facteur : mcf.get_child(mcs).getValeur()
+ Test sur un mot-clé simple d'un mot-clé facteur : mcf.getChild(mcs).getValeur()
"""
co2=OP1(a=1)
co1=OP5(FFT={'FONCTION':co2})
def test09(self):
co2=OP1(a=1)
co1=OP5(FFT={'FONCTION':co2})
- l= co1.etape.get_sd_utilisees()
+ l= co1.etape.getSd_utilisees()
self.assert_(len(l)==1)
self.assert_(co2 in l )
- d=co1.etape.get_sd_mcs_utilisees()
+ d=co1.etape.getSd_mcs_utilisees()
self.assert_(len(d.keys())==1)
self.assert_(len(d['FONCTION'])==1)
self.assert_(co2 in d['FONCTION'])
def setUp(self):
self.j=cata3.JdC(procedure="",nom="bidon")
self.j.actif_status=1
- CONTEXT.set_current_step(self.j)
+ CONTEXT.setCurrentStep(self.j)
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
self.j.supprime()
def test001(self):
return co
def add_mcsimp(obj,nom,valeur):
- mcs=obj.get_child(nom,restreint='oui')
+ mcs=obj.getChild(nom,restreint='oui')
if mcs is None:
- pos=obj.getIndex_child(nom)
+ pos=obj.getIndexChild(nom)
mcs=obj.addEntite(nom,pos)
- mcs.set_valeur(mcs.eval_val(valeur))
+ mcs.set_valeur(mcs.evalVal(valeur))
return mcs
def cdiff(text1,text2):
pass
def tearDown(self):
- CONTEXT.unset_current_step()
+ CONTEXT.unsetCurrentStep()
def test000(self):
""" Test de construction du fichier de commandes az.comm de zero"""
co=j.addEntite("LIRE_MAILLAGE",pos)
test,mess=co.nommeSd("MAILLA2")
mcs=co.addEntite("UNITE")
- valeur=mcs.eval_val("P4[1]")
+ valeur=mcs.evalVal("P4[1]")
test=mcs.set_valeur(valeur)
# formule
pos=pos+1
co=j.addEntite("FORMULE",pos)
- co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
+ co.updateFormulePython(("aaa","REEL","a+z","(a,z)"))
# commande LIRE_MAILLAGE
pos=pos+1
ma=co=j.addEntite("LIRE_MAILLAGE",pos)
test,mess=co.nommeSd("MAIL")
mcs=co.addEntite("UNITE")
- valeur,validite=mcs.eval_valeur("P3")
+ valeur,validite=mcs.evalValeur("P3")
test=mcs.set_valeur(valeur)
#
pos=pos+1
# formule
pos=pos+1
co=j.addEntite("FORMULE",pos)
- co.update_formule_python(("az","REEL","aaaaa","(ae,inst)"))
+ co.updateFormulePython(("az","REEL","aaaaa","(ae,inst)"))
# commande AFFE_MODELE
pos=pos+1
co=j.addEntite("AFFE_MODELE",pos)
- mcs=co.get_child("MAILLAGE")
- valeur,validite=mcs.eval_valeur("MAIL")
+ mcs=co.getChild("MAILLAGE")
+ valeur,validite=mcs.evalValeur("MAIL")
assert valeur == ma.sd
test=mcs.set_valeur(valeur)
assert valeur == co["MAILLAGE"]
mcf=co.addEntite("AFFE")
- mcs=mcf[0].get_child("PHENOMENE")
- valeur=mcs.eval_val_item('MECANIQUE')
+ mcs=mcf[0].getChild("PHENOMENE")
+ valeur=mcs.evalValItem('MECANIQUE')
assert valeur=='MECANIQUE',str(valeur)
test=mcs.set_valeur(valeur)
assert mcf["PHENOMENE"] == 'MECANIQUE'
- mcs=mcf[0].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[0].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
assert mcf["MODELISATION"] == 'DIS_T'
mcs=add_mcsimp(mcf[0],"GROUP_MA",('RESSORT','eee',))
mcf=co.addEntite("AFFE")
- mcs=mcf[1].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
- mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[1].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('MECANIQUE'))
+ mcs=mcf[1].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
mcf=co.addEntite("AFFE")
- mcs=mcf[2].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('ACOUSTIQUE'))
- mcs=mcf[2].get_child("b_acoustique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('PLAN'))
+ mcs=mcf[2].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('ACOUSTIQUE'))
+ mcs=mcf[2].getChild("b_acoustique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('PLAN'))
#mcs=add_mcsimp(mcf[2],"GROUP_NO",'GNP3,GNP5,GNP6,GNP7,GNP8,GNP9,GNP10,GNP11,GNP12')
mcs=add_mcsimp(mcf[2],"GROUP_NO","'GNP3','GNP5','GNP6','GNP7','GNP8','GNP9','GNP10','GNP11','GNP12'")
# commande AFFE_MODELE
pos=pos+1
co=j.addEntite("AFFE_MODELE",pos)
- mcs=co.get_child("MAILLAGE")
- mcs.set_valeur(mcs.eval_val("MAIL"))
+ mcs=co.getChild("MAILLAGE")
+ mcs.set_valeur(mcs.evalVal("MAIL"))
mcf=co.addEntite("AFFE")
- mcs=mcf[0].get_child("PHENOMENE")
- valeur=mcs.eval_val_item('MECANIQUE')
+ mcs=mcf[0].getChild("PHENOMENE")
+ valeur=mcs.evalValItem('MECANIQUE')
test=mcs.set_valeur(valeur)
- mcs=mcf[0].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[0].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
mcs=add_mcsimp(mcf[0],"GROUP_MA",'RESSORT')
mcf=co.addEntite("AFFE")
- mcs=mcf[1].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('MECANIQUE'))
- mcs=mcf[1].get_child("b_mecanique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('DIS_T'))
+ mcs=mcf[1].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('MECANIQUE'))
+ mcs=mcf[1].getChild("b_mecanique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('DIS_T'))
mcs=add_mcsimp(mcf[1],"GROUP_MA",'MASSES')
mcf=co.addEntite("AFFE")
- mcs=mcf[2].get_child("PHENOMENE")
- mcs.set_valeur(mcs.eval_val_item('THERMIQUE'))
- mcs=mcf[2].get_child("b_thermique").get_child("MODELISATION")
- mcs.set_valeur(mcs.eval_val_item('COQUE'))
+ mcs=mcf[2].getChild("PHENOMENE")
+ mcs.set_valeur(mcs.evalValItem('THERMIQUE'))
+ mcs=mcf[2].getChild("b_thermique").getChild("MODELISATION")
+ mcs.set_valeur(mcs.evalValItem('COQUE'))
mcs=add_mcsimp(mcf[2],"TOUT",'OUI')
co.nommeSd("MOD")
# VALE=(3.0,P6,),),);
pos=pos+1
co=j.addEntite("AFFE_CARA_ELEM",pos)
- mcs=co.get_child("MODELE")
- mcs.set_valeur(mcs.eval_val("MOD"))
+ mcs=co.getChild("MODELE")
+ mcs.set_valeur(mcs.evalVal("MOD"))
mcf=co.addEntite("POUTRE")
- mcs=mcf[0].get_child("SECTION")
- mcs.set_valeur(mcs.eval_val('CERCLE'))
+ mcs=mcf[0].getChild("SECTION")
+ mcs.set_valeur(mcs.evalVal('CERCLE'))
assert mcf[0]["SECTION"] == 'CERCLE'
mcs=add_mcsimp(mcf[0],"GROUP_MA",'MA')
- mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("CARA")
- mcs.set_valeur(mcs.eval_val('R'))
- mcs=mcf[0].get_child("b_cercle").get_child("b_constant").get_child("VALE")
- mcs.set_valeur(mcs.eval_val('3.0,P6'))
+ mcs=mcf[0].getChild("b_cercle").getChild("b_constant").getChild("CARA")
+ mcs.set_valeur(mcs.evalVal('R'))
+ mcs=mcf[0].getChild("b_cercle").getChild("b_constant").getChild("VALE")
+ mcs.set_valeur(mcs.evalVal('3.0,P6'))
co.nommeSd("CARA")
# commentaire
pos=pos+1
# VALE=(5.0,3.0,P4[1],P3,),);
pos=pos+1
co=j.addEntite("DEFI_FONCTION",pos)
- mcs=co.get_child("NOM_PARA")
- mcs.set_valeur(mcs.eval_val("DX"))
+ mcs=co.getChild("NOM_PARA")
+ mcs.set_valeur(mcs.evalVal("DX"))
mcs=co.addEntite("VALE")
- mcs.set_valeur(mcs.eval_val("5.0,3.0,P4[1],P3"))
+ mcs.set_valeur(mcs.evalVal("5.0,3.0,P4[1],P3"))
co.nommeSd("F1")
#F3=DEFI_FONCTION(NOM_PARA='DRX',
# VALE_C=(5.0,7.0,9.0,9.0,8.0,7.0,),);
pos=pos+1
co=j.addEntite("DEFI_FONCTION",pos)
- mcs=co.get_child("NOM_PARA")
- mcs.set_valeur(mcs.eval_val("DRX"))
+ mcs=co.getChild("NOM_PARA")
+ mcs.set_valeur(mcs.evalVal("DRX"))
mcs=co.addEntite("VALE_C")
- mcs.set_valeur(mcs.eval_val("5.0,7.0,9.0,9.0,8.0,7.0"))
+ mcs.set_valeur(mcs.evalVal("5.0,7.0,9.0,9.0,8.0,7.0"))
co.nommeSd("F3")
# commentaire
pos=pos+1
pos=pos+1
co=j.addEntite("DEFI_MATERIAU",pos)
mcf=co.addEntite("ELAS")
- mcs=mcf[0].get_child("E")
- mcs.set_valeur(mcs.eval_val("100000000000.0"))
- mcs=mcf[0].get_child("NU")
- mcs.set_valeur(mcs.eval_val("0.0"))
+ mcs=mcf[0].getChild("E")
+ mcs.set_valeur(mcs.evalVal("100000000000.0"))
+ mcs=mcf[0].getChild("NU")
+ mcs.set_valeur(mcs.evalVal("0.0"))
mcf=co.addEntite("ECRO_ASYM_LINE")
- mcs=mcf[0].get_child("DC_SIGM_EPSI")
- mcs.set_valeur(mcs.eval_val("0.0"))
- mcs=mcf[0].get_child("DT_SIGM_EPSI")
- mcs.set_valeur(mcs.eval_val("0.0"))
- mcs=mcf[0].get_child("SY_C")
- mcs.set_valeur(mcs.eval_val("200000000.0"))
- mcs=mcf[0].get_child("SY_T")
- mcs.set_valeur(mcs.eval_val("50000000.0"))
+ mcs=mcf[0].getChild("DC_SIGM_EPSI")
+ mcs.set_valeur(mcs.evalVal("0.0"))
+ mcs=mcf[0].getChild("DT_SIGM_EPSI")
+ mcs.set_valeur(mcs.evalVal("0.0"))
+ mcs=mcf[0].getChild("SY_C")
+ mcs.set_valeur(mcs.evalVal("200000000.0"))
+ mcs=mcf[0].getChild("SY_T")
+ mcs.set_valeur(mcs.evalVal("50000000.0"))
co.nommeSd("MATER2")
#PS1=DEFI_PARA_SENSI(VALE=1.0,);
#PS2=DEFI_PARA_SENSI(VALE=1.0,);
#PS3=DEFI_PARA_SENSI(VALE=1.0,);
pos=pos+1
co=j.addEntite("DEFI_PARA_SENSI",pos)
- mcs=co.get_child("VALE")
- mcs.set_valeur(mcs.eval_val("1.0"))
+ mcs=co.getChild("VALE")
+ mcs.set_valeur(mcs.evalVal("1.0"))
co.nommeSd("PS1")
pos=pos+1
co=j.addEntite("DEFI_PARA_SENSI",pos)
- mcs=co.get_child("VALE")
- mcs.set_valeur(mcs.eval_val("1.0"))
+ mcs=co.getChild("VALE")
+ mcs.set_valeur(mcs.evalVal("1.0"))
co.nommeSd("PS2")
pos=pos+1
co=j.addEntite("DEFI_PARA_SENSI",pos)
- mcs=co.get_child("VALE")
- mcs.set_valeur(mcs.eval_val("1.0"))
+ mcs=co.getChild("VALE")
+ mcs.set_valeur(mcs.evalVal("1.0"))
co.nommeSd("PS3")
#CHMAT2=AFFE_MATERIAU(MAILLAGE=MAIL,
# AFFE=_F(TOUT='OUI',
pos=pos+1
co=j.addEntite("AFFE_MATERIAU",pos)
add_mcsimp(co,"MAILLAGE","MAIL")
- mcf=co.get_child("AFFE")
+ mcf=co.getChild("AFFE")
add_mcsimp(mcf[0],"TOUT","OUI")
add_mcsimp(mcf[0],"MATER","MATER2")
co.nommeSd("CHMAT2")
co=j.addEntite("THER_LINEAIRE",pos)
add_mcsimp(co,"MODELE","AFFE1")
add_mcsimp(co,"CHAM_MATER","CHMAT2")
- mcf=co.get_child("EXCIT")
+ mcf=co.getChild("EXCIT")
add_mcsimp(mcf[0],"CHARGE","AAAZ")
add_mcsimp(co,"SENSIBILITE","PS1,PS2")
co.nommeSd("TH1")
pos=pos+1
co=j.addEntite("MACRO_MATR_ASSE",pos)
add_mcsimp(co,"MODELE","AFFE1")
- mcs=co.get_child("NUME_DDL")
+ mcs=co.getChild("NUME_DDL")
mcs.set_valeur_co('DDL1')
- mcf=co.get_child("MATR_ASSE")
+ mcf=co.getChild("MATR_ASSE")
add_mcsimp(mcf[0],"OPTION","RIGI_THER")
- mcs=mcf[0].get_child("MATRICE")
+ mcs=mcf[0].getChild("MATRICE")
mcs.set_valeur_co('MAT1')
# commentaire
pos=pos+1
# formule
pos=pos+1
co=j.addEntite("FORMULE",pos)
- co.update_formule_python(("aaa","REEL","a+z","(a,z)"))
+ co.updateFormulePython(("aaa","REEL","a+z","(a,z)"))
#parametre de formule
pos=pos+1
co=add_param(j,pos,"P3","aaa(P1,2.)")
def __init__(self, list_arg):
self.genea = list_arg
- def cherche_mot(self, niveau, commande):
+ def chercheMot(self, niveau, commande):
"""
Recherche du mot
"""
for c in commande.childNodes :
if c.name == texte :
niveau = niveau+1
- return self.cherche_mot(niveau, c)
+ return self.chercheMot(niveau, c)
return None
def verif(self, commande):
"""
Vérification
"""
- bool = self.cherche_mot(0, commande)
+ bool = self.chercheMot(0, commande)
if bool == None : bool = 0
return bool
def __init__(self, list_arg):
self.genea = list_arg
- def cherche_mot(self, niveau, commande):
+ def chercheMot(self, niveau, commande):
"""
Recherche du mot
"""
for c in commande.childNodes :
if c.name == texte :
niveau = niveau+1
- return self.cherche_mot(niveau, c)
+ return self.chercheMot(niveau, c)
return None
def verif(self, commande):
"""
Vérification
"""
- bool = self.cherche_mot(0, commande)
+ bool = self.chercheMot(0, commande)
if bool : return 0
return 1
# on compte le nombre de mots cles presents
text = ''
count = 0
- args = self.liste_to_dico(args)
+ args = self.listeToDico(args)
for mc in self.mcs:
if mc in args :
count = count + 1
# on compte le nombre de mots cles presents
text = ''
count = 0
- args = self.liste_to_dico(args)
+ args = self.listeToDico(args)
for mc in self.mcs:
count = count + args.get(mc, 0)
if count > 1:
return text, 0
return text, 1
- def liste_to_dico(self, args):
+ def listeToDico(self, args):
if type(args) is dict:
return args
elif type(args) in (list, tuple):
liste.extend(self.args0)
liste.extend(self.args1)
self.mcs = liste
- self.init_couples_permis()
+ self.initCouplesPermis()
- def init_couples_permis(self):
+ def initCouplesPermis(self):
""" Cree la liste des couples permis parmi les self.args, cad pour chaque element
de self.args0 cree tous les couples possibles avec un element de self.args1"""
liste = []
# figurant dans la regle
text = ''
test = 1
- args = self.liste_to_dico(args)
+ args = self.listeToDico(args)
pivot = None
for mc in self.mcs:
if mc in args:
def valid_regles(self, cr):
""" Cette methode teste la validite des regles de l'etape """
- text_erreurs, test_regles = self.verif_regles()
+ text_erreurs, test_regles = self.verifRegles()
if not test_regles:
if cr == 'oui':
self.cr.fatal( "Regle(s) non respectee(s) : %s" % text_erreurs)
self.valid = None
return None
- def set_valid(self, valid):
+ def setValid(self, valid):
old_valid = self.getValid()
self.valid = valid
self.state = 'unchanged'
if valid:
valid = self.updateSdprod(cr)
- self.set_valid(valid)
+ self.setValid(valid)
return self.valid
if CONTEXT.debug:
print(("changement de type:", self.sd, sd_prod))
if self.sd.__class__ != sd_prod:
- self.sd.change_type(sd_prod)
+ self.sd.changeType(sd_prod)
else:
# Le sd n existait pas , on ne le cree pas
if cr == 'oui':
# on compte le nombre de mots cles presents
text = ''
count = 0
- args = self.liste_to_dico(args)
+ args = self.listeToDico(args)
for mc in self.mcs:
if mc in args:
count = count + 1
return self.valid
else:
valid = 1
- texte, test = self.verif_regles()
+ texte, test = self.verifRegles()
if test == 0:
if cr == 'oui':
if texte != "" and (' '.strip(texte) == "") : self.cr.fatal(texte)
self.valid = valid
return self.valid
- def verif_regles(self):
+ def verifRegles(self):
"""
Effectue la verification de validite des regles du jeu de commandes
"""
valid = 1
# On marque les concepts CO pour verification ulterieure de leur
# bonne utilisation
- l = self.get_all_co()
- # On verifie que les concepts CO sont bien passes par type_sdprod
+ l = self.getAllCo()
+ # On verifie que les concepts CO sont bien passes par typeSDProd
for c in l:
# if c.etape is self.parent:
- if c.is_typco() != 2:
+ if c.isTypCO() != 2:
# le concept est propriete de l'etape parent
- # Il n'a pas ete transforme par type_sdprod
+ # Il n'a pas ete transforme par typeSDProd
# Cette situation est interdite
# Pb: La macro-commande a passe le concept a une commande
# (macro ?) mal definie
if cr == 'oui':
- self.cr.fatal("Macro-commande mal definie : le concept n'a pas ete type par un appel a type_sdprod pour %s" % c.nom)
+ self.cr.fatal("Macro-commande mal definie : le concept n'a pas ete type par un appel a typeSDProd pour %s" % c.nom)
valid = 0
valid = valid * self.valid_child()
valid = 0
break
- self.set_valid(valid)
+ self.setValid(valid)
return self.valid
try:
# la sd_prod d'une macro a l'objet lui meme en premier argument
# contrairement a une ETAPE ou PROC_ETAPE
- # Comme sd_prod peut invoquer la methode type_sdprod qui ajoute
+ # Comme sd_prod peut invoquer la methode typeSDProd qui ajoute
# les concepts produits dans self.sdprods, il faut le mettre a
# zero
self.sdprods = []
if CONTEXT.debug:
print(("changement de type:", self.sd, sd_prod))
if self.sd.__class__ != sd_prod:
- self.sd.change_type(sd_prod)
+ self.sd.changeType(sd_prod)
self.typret = sd_prod
else:
# Le sd n existait pas , on ne le cree pas
break
# Apres avoir verifie la validite de tous les sous-objets, on verifie
# la validite des regles
- text_erreurs, test_regles = self.verif_regles()
+ text_erreurs, test_regles = self.verifRegles()
if not test_regles:
if cr == 'oui':
self.cr.fatal( "Regle(s) non respectee(s) : %s" % text_erreurs)
self.cr.fatal(' '.join((self.txt_nat, self.nom, str(e))))
return self.cr
- def verif_regles(self):
+ def verifRegles(self):
"""
A partir du dictionnaire des mots-cles presents, verifie si les regles
de self sont valides ou non.
break
# Apres avoir verifie la validite de tous les sous-objets, on verifie
# la validite des regles
- text_erreurs, test_regles = self.verif_regles()
+ text_erreurs, test_regles = self.verifRegles()
if not test_regles:
if cr == 'oui':
self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs)
self.valid = None
return None
- def set_valid(self, valid):
+ def setValid(self, valid):
old_valid = self.getValid()
self.valid = valid
self.state = 'unchanged'
except ValError as e:
valid = 0
- self.set_valid(valid)
+ self.setValid(valid)
return self.valid
def isOblig(self):
"""
# on compte le nombre de mots cles presents
text = ''
- args = self.liste_to_dico(args)
+ args = self.listeToDico(args)
size = -1
for mc in self.mcs:
# les autres sont absents
text = ''
test = 1
- args = self.liste_to_dico(args)
+ args = self.listeToDico(args)
mc0 = self.mcs[0]
if mc0 in args :
for mc in self.mcs[1:len(self.mcs)]:
mc0 = self.mcs[0]
text = ''
test = 1
- args = self.liste_to_dico(args)
+ args = self.listeToDico(args)
if mc0 in args :
for mc in self.mcs[1:len(self.mcs)]:
if not mc in args :
class PROC_ETAPE(V_ETAPE.ETAPE):
"""
- On reutilise les methodes report,verif_regles
+ On reutilise les methodes report,verifRegles
de ETAPE par heritage.
"""
self.cr.fatal(
tr("unknown keywords : %s") % ','.join(list(self.reste_val.keys())))
valid = 0
- self.set_valid(valid)
+ self.setValid(valid)
return self.valid
# on compte le nombre de mots cles presents
text = ''
count = 0
- args = self.liste_to_dico(args)
+ args = self.listeToDico(args)
for mc in self.mcs:
if mc in args :
count = count + 1
import prefs
from InterfaceQT4 import eficas_go
-eficas_go.lance_eficas(code=prefs.code)
+eficas_go.lanceEficas(code=prefs.code)
import os
from Editeur.catadesc import CatalogDescription
-from InterfaceQT4.configuration import CONFIG_BASE
+from InterfaceQT4.configuration import configBase
-class CONFIG(CONFIG_BASE):
+class CONFIG(configBase):
def __init__(self, appli, repIni):
"""
This class stores the configuration parameters for Eficas
"""
- CONFIG_BASE.__init__(self, appli, repIni)
+ configBase.__init__(self, appli, repIni)
# Configuration parameters
self.savedir = os.getenv("HOME")
self.lang = 'fr'
self.generator_module = "generator_boundary_conditions"
- def save_params(self):
+ def saveParams(self):
pass
def make_config(appli, rep):
self.buffer=[]
self.buffer_indent=""
- def getoptions(self):
+ def getOptions(self):
m= self.optionprog.match(self.line)
if m:
option=m.group(1)
self.line= self.texte.readline()
#print "line:",self.line
# option ?
- self.getoptions()
+ self.getOptions()
return self.line
def getTexte(self,appli=None):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
import re
-from convert_python import PythonParser
+from convert_python import Pythonparser
def entryPoint():
"""
"""
return {
'name' : 'openturns_study',
- 'factory' : OTStudyParser
+ 'factory' : OTStudyparser
}
-class OTStudyParser(PythonParser):
+class OTStudyparser(Pythonparser):
"""
- This converter works like PythonParser, except that it also initializes all
+ This converter works like Pythonparser, except that it also initializes all
model variables to None in order to avoid Python syntax errors when loading
a file with a different or inexistent definition of variables.
"""
pattern_model_variable = re.compile(r'ModelVariable\s*=\s*(\w+)\s*,')
def convert(self, outformat, appli=None):
- text = PythonParser.convert(self, outformat, appli)
+ text = Pythonparser.convert(self, outformat, appli)
varnames = self.pattern_model_variable.findall(text)
newtext = ""
for var in varnames:
# Le nom du plugin
'name' : 'openturns_wrapper',
# La factory pour créer une instance du plugin
- 'factory' : PythonParser,
+ 'factory' : Pythonparser,
}
#----------------------------------------------------------------------------------------
def gener(self,obj,format='brut',config=None,appli=None,statut="Entier"):
- print ('je suis dans le gener pour ', obj)
self.statut=statut
self.langue=appli.langue
self.DicoEnumCasEnInverse={}
d[valEficas]=valTelemac
self.DicoEnumCasEnInverse[motClef]=d
self.initDico()
- #print (self.DicoEnumCasEnInverse.keys())
# Pour Simplifier les verifs d ecriture
if hasattr(appli,'listeTelemac') : self.listeTelemac=appli.listeTelemac
else : self.listeTelemac = ()
def generMCSIMP(self,obj) :
"""recuperation de l objet MCSIMP"""
- print ('je genere MCSIMP pour', obj.nom)
s=PythonGenerator.generMCSIMP(self,obj)
#if nom in listeSupprime or s == "" : return s
if s == "None," : s=None
if s == "" or s==None : return s
- print ('je genere MCSIMP 22 pour', obj.nom)
sTelemac=s[0:-1]
if not( type(obj.valeur) in (tuple,list) ):
if obj.nom not in self.dicoCataToCas :
if obj.nom == 'Consigne' : return ""
return s
- print ('apres')
nom=self.dicoCataToCas[obj.nom]
if nom in ["VARIABLES FOR GRAPHIC PRINTOUTS", "VARIABLES POUR LES SORTIES GRAPHIQUES", "VARIABLES TO BE PRINTED","VARIABLES A IMPRIMER"] :
if s3 == "" or s3 == " " : s3 = " "
ligne=nom+ " : " + s3 + "\n"
if len(ligne) > 72 : ligne=self.redecoupeLigne(nom,s3)
- print ('fin pour ', obj.nom, ligne)
self.texteDico+=ligne
def generMCFACT(self,obj):
return s
-# def LIQUID_BOUNDARIES(self,obj):
-# print ('jkljklj')
-# if 'BOUNDARY_TYPE' in obj.listeMcPresents() :
-# objForme=obj.get_child('BOUNDARY_TYPE')
-# valForme=objForme.valeur
-# if valForme == None : return
-
-
-# if valForme == 'Prescribed Unknown':
-# nomBloc='b_'+valForme.split(" ")[1]
-# if nomBloc in obj.listeMcPresents() :
-# objBloc=obj.get_child(nomBloc)
-# valeurPE = objValeur=objBloc.get_child(objBloc.listeMcPresents()[0]).valeur
-# valeurFE = objValeur=objBloc.get_child(objBloc.listeMcPresents()[1]).valeur
-# valeurVE = objValeur=objBloc.get_child(objBloc.listeMcPresents()[2]).valeur
-# if valeurPE== None : valeurPE="0."
-# if valeurFE== None : valeurPE="0."
-# if valeurVE== None : valeurPE="0."
-# self.PE=True
-# self.textPE += str(valeurPE) +"; "
-# self.FE=True
-# self.textFE += str(valeurFE) +"; "
-# self.VE=True
-# self.textVE += str(valeurVE) +"; "
-# else:
-# nomBloc='b_'+valForme.split(" ")[1]
-# if nomBloc in obj.listeMcPresents() :
-# objBloc=obj.get_child(nomBloc)
-# objValeur=objBloc.get_child(objBloc.listeMcPresents()[0])
-# valeur=objValeur.valeur
-# if valeur== None : valeur="0."
-# if valForme == 'Prescribed Elevations' :
-# self.PE=True
-# self.textPE += str(valeur) +"; "
-# else : self.textPE += "0.; "
-# if valForme == 'Prescribed Flowrates' :
-# self.FE=True
-# self.textFE += str(valeur) +"; "
-# else : self.textFE += "0.; "
-# if valForme == 'Prescribed Velocity' :
-# self.VE=True
-# self.textVE += str(valeur) +"; "
-# else : self.textVE += "0.; "
-
-# def BOUNDARY_CONDITIONS(self,obj):
-# # sans '; '
-# if self.FE : self.texteDico += self.textFE[0:-2]+'\n'
-# if self.PE : self.texteDico += self.textPE[0:-2]+'\n'
-# if self.VE : self.texteDico += self.textVE[0:-2]+'\n'
-
def TRACERS(self,obj):
if self.nbTracers != 0 : self.texteDico += 'NUMBER_OF_TRACERS : '+str(self.nbTracers) + '\n'
self.texteDico += "VALIDATION : True \n"
def Date_De_L_Origine_Des_Temps (self,obj):
- an=obj.get_child('Year').valeur
- mois=obj.get_child('Month').valeur
- jour=obj.get_child('Day').valeur
+ an=obj.getChild('Year').valeur
+ mois=obj.getChild('Month').valeur
+ jour=obj.getChild('Day').valeur
self.texteDico += "ORIGINAL DATE OF TIME :"+ str(an)+ " ,"+str(mois)+ "," +str(jour)+ "\n"
def Original_Hour_Of_Time (self,obj):
- hh=obj.get_child('Hour').valeur
- mm=obj.get_child('Minute').valeur
- ss=obj.get_child('Second').valeur
+ hh=obj.getChild('Hour').valeur
+ mm=obj.getChild('Minute').valeur
+ ss=obj.getChild('Second').valeur
self.texteDico += "ORIGINAL HOUR OF TIME :"+str(hh)+" ,"+str(mm)+ ","+str(ss)+"\n"
def Type_Of_Advection(self,obj):
def chercheChildren(self,obj):
for c in obj.listeMcPresents():
- objc=obj.get_child(c)
+ objc=obj.getChild(c)
if hasattr(objc,'listeMcPresents') and objc.listeMcPresents() != [] : self.chercheChildren(objc)
else : self.listeMCAdvection.append(objc)
lval=valeur.split(";")
ligne=" "
for v in lval :
- if len(ligne+ str(v)+'; ') < 72 : ligne += str(v)+'; '
+ if len(ligne+ str(v)+'; ') < 70 : ligne += str(v)+'; '
else :
text+= ligne+"\n"
ligne=" "+str(v)+'; '
Convertit un objet derive d'ASSD en une chaine de caracteres a la
syntaxe aplat
"""
- return obj.get_name()
+ return obj.getName()
def generMCList(self,obj):
"""
Convertit un objet derive d'ASSD en une chaine de caracteres a la
syntaxe python
"""
- return obj.get_name()
+ return obj.getName()
def generMCFACT(self,obj):
"""
return l
- def format_item(self,valeur,etape,obj,vientDeListe=0):
+ def formatItem(self,valeur,etape,obj,vientDeListe=0):
if (type(valeur) == float or 'R' in obj.definition.type) and not(isinstance(valeur,Accas.PARAMETRE)) :
# Pour un flottant on utilise str ou repr si on vient d une liste
# ou la notation scientifique
else :
obj.valeurFormatee=[]
for val in obj.valeur :
- s =s +self.format_item(val,obj.etape,obj,1) + ','
+ s =s +self.formatItem(val,obj.etape,obj,1) + ','
if obj.waitTxm() :
obj.valeurFormatee.append(val)
else :
- obj.valeurFormatee.append(self.format_item(val,obj.etape,obj))
+ obj.valeurFormatee.append(self.formatItem(val,obj.etape,obj))
if len(obj.valeur) >= 1:
s = '(' + s + '),'
if obj.valeur==[] or obj.valeur==() : s="(),"
s=self.formatColonnes(obj.nbrColonnes(),obj.valeur,obj)
else :
obj.valeurFormatee=obj.valeur
- s=self.format_item(obj.valeur,obj.etape,obj) + ','
+ s=self.formatItem(obj.valeur,obj.etape,obj) + ','
return s
try :
#if 1 :
for l in range(nbrColonnes) :
- texteVariable=self.format_item(listeValeurs[indice],obj.etape,obj)
+ texteVariable=self.formatItem(listeValeurs[indice],obj.etape,obj)
textformat=textformat+texteVariable+" ,"
indice=indice+1
textformat=textformat+"\n"
except :
#else :
while ( indice < len(listeValeurs) ) :
- texteVariable=self.format_item(listeValeurs[indice],obj.etape,obj)
+ texteVariable=self.formatItem(listeValeurs[indice],obj.etape,obj)
textformat=textformat+texteVariable+", "
indice=indice+1
textformat=textformat+"\n"
self.dict_traduit={"VARI_SECT":"extrusion","EXCENTREMENT":"Excentre","EPAIS":"Epais","VECTEUR":"Vecteur"}
- self.init_ligne()
+ self.initLigne ()
- def init_jdc(self,jdc) :
+ def initJdc(self,jdc) :
self.jdc=jdc
- def init_ligne (self) :
+ def initLigne (self) :
self.boolGpMa = 0
self.commande = ""
self.dict_attributs = {}
return self.list_commandes
def generator(self,obj):
- if (obj.nom in self.liste_motetat) and (self.calcule_ouinon(obj)):
+ if (obj.nom in self.liste_motetat) and (self.calculeOuiNon(obj)):
PythonGenerator.generator(self,obj)
"""
f1=PythonGenerator.generator(self,obj)
return ""
"""
- def calcule_ouinon(self,obj):
+ def calculeOuiNon(self,obj):
ouinon=1
for l in obj.getGenealogie() :
if not l in self.liste_motetat :
Convertit un objet MCFACT en une liste de chaines de caracteres a la
syntaxe python
"""
- self.init_ligne()
+ self.initLigne ()
self.commande=self.dict_deb_com[obj.nom]
for v in obj.mc_liste:
self.generator(v)
dictVariables = {}
for variable in self.ListeVariablesIn:
- nomVar = variable['ModelVariable'].get_name()
+ nomVar = variable['ModelVariable'].getName()
dictVariables[ nomVar ] = variable['Distribution']
i = 0
marginale = "%s_%d" % (self.variable["marginal"], i)
txt += "# Definit la loi marginale de la composante %d\n" % i
txt += "%s = %s\n" % (marginale, apply( STDGenerateur.__dict__[ loi[ 'Kind' ] ], (self, loi) ))
- txt += "%s.setName( '%s' )\n" % (marginale, conceptloi.get_name())
+ txt += "%s.setName( '%s' )\n" % (marginale, conceptloi.getName())
txt += "%s[ %d ] = '%s'\n" % (self.variable["description"], i, variable)
txt += "%s[ %d ] = Distribution( %s )\n" % (self.variable["collection"], i, marginale)
txt += "\n"
'''
nomVar = "output"
for variable in self.ListeVariablesOut:
- nomVar = variable['ModelVariable'].get_name()
+ nomVar = variable['ModelVariable'].getName()
txt = "# Definit le vecteur aleatoire de sortie\n"
txt += "%s = RandomVector( %s, %s )\n" % (self.variable["outputRandomVector"], self.variable["model"], self.variable["inputRandomVector"])
try:
if usePrefix:
- nomGroupeMaillage = self.nomReelGroupeMaillage(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
+ nomGroupeMaillage = self.nomReelGroupeMaillage(obj.getSdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
else:
- nomGroupeMaillage = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
+ nomGroupeMaillage = obj.getSdname() # nom du groupe de maillage, i.e. nom du concept
# test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
# test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
#assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupeMaillage
texte+=" ]"+"\n"
if self.debug:
print "texte = %s", texte
- self.dictMaterConductor[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
+ self.dictMaterConductor[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
def generMATERIAL_DIELECTRIC(self,obj):
"""preparation du sous bloc DIELECTRIC"""
texte+=" ]"+"\n"
if self.debug:
print "texte = %s", texte
- self.dictMaterDielectric[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
+ self.dictMaterDielectric[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
def generMATERIAL_ZSURFACIC(self,obj):
"""preparation du sous bloc ZSURFACIC"""
texte+=" ]"+"\n"
if self.debug:
print "texte = %s", texte
- self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
+ self.dictMaterZsurfacic[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
def generMATERIAL_EMISO(self,obj):
"""preparation du sous bloc EM_ISOTROPIC_FILES.
#from os.path import basename
#texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
#texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
- # print "obj get sdname= ", obj.get_sdname()
- # if obj.get_sdname() in self.dictMaterEmIso.keys() :
- # self.dictMaterEmIso[obj.get_sdname()].append(texte)
+ # print "obj get sdname= ", obj.getSdname()
+ # if obj.getSdname() in self.dictMaterEmIso.keys() :
+ # self.dictMaterEmIso[obj.getSdname()].append(texte)
# else :
- self.dictMaterEmIso[obj.get_sdname()]=texte
+ self.dictMaterEmIso[obj.getSdname()]=texte
def generMATERIAL_EMANISO(self,obj):
"""preparation du sous bloc EM_ANISOTROPIC_FILES.
"""
texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
- # print "obj get sdname= ", obj.get_sdname()
- # if obj.get_sdname() in self.dictMaterEmAnIso.keys() :
- # self.dictMaterEmAnIso[obj.get_sdname()].append(texte)
+ # print "obj get sdname= ", obj.getSdname()
+ # if obj.getSdname() in self.dictMaterEmAnIso.keys() :
+ # self.dictMaterEmAnIso[obj.getSdname()].append(texte)
# else :
- self.dictMaterEmAnIso[obj.get_sdname()]=texte
+ self.dictMaterEmAnIso[obj.getSdname()]=texte
def generMATERIAL_NILMAT(self,obj):
"""preparation du sous bloc NILMAT"""
texte=""
- self.dictMaterNilmat[obj.get_sdname()]=texte
+ self.dictMaterNilmat[obj.getSdname()]=texte
def generMATERIAL_ZINSULATOR(self,obj):
""""preparation du sous bloc ZINSULATOR"""
texte=""
- self.dictMaterZinsulator[obj.get_sdname()]=texte
+ self.dictMaterZinsulator[obj.getSdname()]=texte
#-------------------------------------------------------------------
else:
print tr("ERREUR! Une forme de la source du \
type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
- self.dictSourceStInd[obj.get_sdname()]=texte
+ self.dictSourceStInd[obj.getSdname()]=texte
if self.debug:
print texte
except Exception:
else:
print tr("ERREUR! Une forme de la source du type \
WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
- self.dictSourceHport[obj.get_sdname()]=texte
+ self.dictSourceHport[obj.getSdname()]=texte
if self.debug:
print texte
except:
else:
print tr("ERREUR! Une forme de la source du type \
WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
- self.dictSourceEport[obj.get_sdname()]=texte
+ self.dictSourceEport[obj.getSdname()]=texte
if self.debug:
print texte
except:
import types,re,os
from Extensions.i18n import tr
from .generator_python import PythonGenerator
-#ListeConcatene=('ridge_names','topo_names','geom_names','elset_names','faset_names','liset_names','nset_names','center','normal','dir')
-ListeConcatene=('ridge_names','topo_names','geom_names','elset_names','faset_names','liset_names','nset_names')
+#ListeConcatene=('ridge_names','topo_names','geom_names','elsetNames','fasetNames','lisetNames','nsetNames','center','normal','dir')
+ListeConcatene=('ridge_names','topo_names','geom_names','elsetNames','fasetNames','lisetNames','nsetNames')
ListeConcatene2=('center','normal','dir')
ListeConcatene3=('ra','rb')
if_ellipse=False
self.text=string.join(liste)
elif format == 'beautifie':
jdc_formate = Formatage(liste,sep=':',l_max=72)
- self.text=jdc_formate.formate_jdc()
+ self.text=jdc_formate.formateJdc()
else:
raise EficasException(tr("Format pas implemente : %s", format))
return self.text
Convertit un objet derive d'ASSD en une chaine de caracteres à la
syntaxe asterv5
"""
- return obj.get_name()
+ return obj.getName()
def generMCFACT(self,obj):
"""
Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
"""
s=PythonGenerator.generMCSIMP(self,obj)
- if not( type(obj.valeur) in (list, tuple)) and (obj.get_min_max()[1] != 1):
+ if not( type(obj.valeur) in (list, tuple)) and (obj.getMinMax()[1] != 1):
valeur=(obj.valeur,)
else :
valeur=obj.valeur
