from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import object
+ from builtins import object
except : pass
import types,re
from Extensions.i18n import tr
filePattern2='"[^\(\)]([^\(\)]*\([^\(\)]*\))*[^\(\)]*"'
class Formatage (object):
- """
- Cette classe contient toutes les méthodes nécessaires au formatage
- de la chaine de caracteres issue d'un generator en un fichier
- 'lisible' ie avec indentations
-
- L'objet attend en parametre du constructeur (argument l_jdc) une representation
- du jeu de commandes sous la forme d'une liste.
-
- Chaque element de la liste est la representation d'une etape.
-
- La representation d'une etape est une liste dont le premier element est une chaine de
- caracteres donnant le debut de la commande ("xxx=lire_maillage(", par exemple).
- Les elements suivants sont les representations des mots cles simples et facteurs.
- Elle se termine avec un element de fin : ");"
-
- La representation d'un mot cle simple est une chaine de caracteres (info=2, par exemple).
-
- La representation d'un mot cle facteur est semblable à celle de l'étape : premier element
- caracteristique du mot cle facteur suivi d'elements representatifs des mots cles simples.
- Elle se termine avec un element de fin : ")" ou "),".
- """
- def __init__(self,l_jdc,code=None,mode=None,sep='=',l_max=72):
- # l_jdc représente le jeu de commandes brut sous forme de liste
- self.l_jdc = l_jdc
- self.jdc_fini =''
- self.count = 0
- self.sep=sep
- self.l_max=l_max
- if mode == '.py':
- self.sep = '='
- self.l_max = 132
- elif code == 'ASTER':
- self.sep = ':'
- self.l_max = 72
-
- def formateJdc(self):
- comment=re.compile("\n#")
- commentaireavant=0
- for etape in self.l_jdc:
- self.count = self.count+1
- self.texte_etape = ''
- if type(etape)==list:
- # L'etape est sous la forme d'une liste dont le premier element est une chaine
- self.indent=[]
- self.indent.append(len(etape[0]))
- self.indent_courant = self.indent[0]
- self.texte_etape = '\n' + etape[0]
- if len(etape)>1 :
- self.formateEtape(etape[1:])
- else :
- # L'etape est deja sous forme de chaine de caracteres
- self.indent=[]
- self.texte_etape = etape
+ """
+ Cette classe contient toutes les méthodes nécessaires au formatage
+ de la chaine de caracteres issue d'un generator en un fichier
+ 'lisible' ie avec indentations
- m=comment.match(self.texte_etape)
- # si ce n est pas la premiere ligne
- if self.jdc_fini != "" :
- # si il n y avait pas de commentaire avant on met un saut de ligne
- if commentaireavant == 0 :
- self.jdc_fini = self.jdc_fini + '\n' + self.texte_etape
- else :
- self.jdc_fini = self.jdc_fini + self.texte_etape
- # si c est la premiere ligne
- else :
- # on ne met pas de saut de ligne avant la premiere ligne
- # si c est un commentaire on enleve le saut de ligne precedent
- if m : self.texte_etape=self.texte_etape[1:]
- self.jdc_fini = self.texte_etape
- if m :
- commentaireavant=1
- else :
- commentaireavant=0
+ L'objet attend en parametre du constructeur (argument l_jdc) une representation
+ du jeu de commandes sous la forme d'une liste.
- return self.jdc_fini
+ Chaque element de la liste est la representation d'une etape.
+ La representation d'une etape est une liste dont le premier element est une chaine de
+ caracteres donnant le debut de la commande ("xxx=lire_maillage(", par exemple).
+ Les elements suivants sont les representations des mots cles simples et facteurs.
+ Elle se termine avec un element de fin : ");"
+ La representation d'un mot cle simple est une chaine de caracteres (info=2, par exemple).
- def formateEtape(self,liste):
+ La representation d'un mot cle facteur est semblable à celle de l'étape : premier element
+ caracteristique du mot cle facteur suivi d'elements representatifs des mots cles simples.
+ Elle se termine avec un element de fin : ")" ou "),".
"""
- Enrichissement de la chaine de caracteres representant l'etape (attribut
- texte_etape de l'objet Formatage).
- Les elements a ajouter sont dans l'argument liste de la methode.
- L'objet "liste" à traiter a été produit par le module generator. En particulier
- les parenthèses et les virgules ont été produites par ce module
- """
- l_patterns_fin_etape = ( ');' , ');\n' )
- l_patterns_fin_mcf = ( ')' , '),' )
-
- ind = 0
- for element in liste :
- if type(element)==list:
+ def __init__(self,l_jdc,code=None,mode=None,sep='=',l_max=72):
+ # l_jdc représente le jeu de commandes brut sous forme de liste
+ self.l_jdc = l_jdc
+ self.jdc_fini =''
+ self.count = 0
+ self.sep=sep
+ self.l_max=l_max
+ if mode == '.py':
+ self.sep = '='
+ self.l_max = 132
+ elif code == 'ASTER':
+ self.sep = ':'
+ self.l_max = 72
+
+ def formateJdc(self):
+ comment=re.compile("\n#")
+ commentaireavant=0
+ for etape in self.l_jdc:
+ self.count = self.count+1
+ self.texte_etape = ''
+ if type(etape)==list:
+ # L'etape est sous la forme d'une liste dont le premier element est une chaine
+ self.indent=[]
+ self.indent.append(len(etape[0]))
+ self.indent_courant = self.indent[0]
+ self.texte_etape = '\n' + etape[0]
+ if len(etape)>1 :
+ self.formateEtape(etape[1:])
+ else :
+ # L'etape est deja sous forme de chaine de caracteres
+ self.indent=[]
+ self.texte_etape = etape
+
+ m=comment.match(self.texte_etape)
+ # si ce n est pas la premiere ligne
+ if self.jdc_fini != "" :
+ # si il n y avait pas de commentaire avant on met un saut de ligne
+ if commentaireavant == 0 :
+ self.jdc_fini = self.jdc_fini + '\n' + self.texte_etape
+ else :
+ self.jdc_fini = self.jdc_fini + self.texte_etape
+ # si c est la premiere ligne
+ else :
+ # on ne met pas de saut de ligne avant la premiere ligne
+ # si c est un commentaire on enleve le saut de ligne precedent
+ if m : self.texte_etape=self.texte_etape[1:]
+ self.jdc_fini = self.texte_etape
+ if m :
+ commentaireavant=1
+ else :
+ commentaireavant=0
+
+ return self.jdc_fini
+
+
+
+ def formateEtape(self,liste):
+ """
+ Enrichissement de la chaine de caracteres representant l'etape (attribut
+ texte_etape de l'objet Formatage).
+ Les elements a ajouter sont dans l'argument liste de la methode.
+ L'objet "liste" à traiter a été produit par le module generator. En particulier
+ les parenthèses et les virgules ont été produites par ce module
+ """
+ l_patterns_fin_etape = ( ');' , ');\n' )
+ l_patterns_fin_mcf = ( ')' , '),' )
+
+ ind = 0
+ for element in liste :
+ if type(element)==list:
+
+ # il s'agit d'un mot-clé facteur
+ # on écrit son nom (element[0])
+ longueur = self.longueur(self.texte_etape)
+ try:
+ increment = len(('\n'+self.indent_courant*' ')*ind + element[0])
+ except:
+ print (tr('ERREUR'))
+ print (liste)
+ print (element)
+ self.texte_etape = self.texte_etape + (u'\n'+self.indent_courant*' ')*ind + element[0]
+ length = len(self.indent)
+ self.indent.insert(length,self.indent[length-1]+len(element[0]))
+ self.indent_courant = self.indent[length]
+ # on écrit ses fils
+ self.formateEtape(element[1:])
+ #elif type(element) == types.StringType:
+ #elif type(element) == bytes:
+ # PNPNPN -> marre du python 2 et 3
+ # on remplace par else dans if
+ else :
- # il s'agit d'un mot-clé facteur
- # on écrit son nom (element[0])
- longueur = self.longueur(self.texte_etape)
- try:
- increment = len(('\n'+self.indent_courant*' ')*ind + element[0])
- except:
- print (tr('ERREUR'))
- print (liste)
- print (element)
- self.texte_etape = self.texte_etape + (u'\n'+self.indent_courant*' ')*ind + element[0]
+ # il s'agit d'un mot-clé simple ou de ')' ou ');' ou '),' ou ');\n'
+
+ if element in l_patterns_fin_mcf :
+ self.traiteMcfact(s_mcfact=element,ind=ind)
+ elif element in l_patterns_fin_etape :
+ self.traiteEtape(s_etape=element,ind=ind)
+ else :
+ self.traiteMcsimp(s_mcsimp=element,ind=ind)
+
+ ind = 1
+
+ def traiteEtape(self,s_etape,ind) :
+ """
+ Traite une partie du jdc formaté : s_etape, une chaîne de caractères
+ contenant une étape
+ L'attribut self.texte_etape est modifié (complété) par le traitement
+ L'attribut self.indent est modifié par le traitement
+ L'attribut self.indent_courant est modifié par le traitement
+ """
length = len(self.indent)
- self.indent.insert(length,self.indent[length-1]+len(element[0]))
- self.indent_courant = self.indent[length]
- # on écrit ses fils
- self.formateEtape(element[1:])
- #elif type(element) == types.StringType:
- #elif type(element) == bytes:
- # PNPNPN -> marre du python 2 et 3
- # on remplace par else dans if
- else :
-
- # il s'agit d'un mot-clé simple ou de ')' ou ');' ou '),' ou ');\n'
-
- if element in l_patterns_fin_mcf :
- self.traiteMcfact(s_mcfact=element,ind=ind)
- elif element in l_patterns_fin_etape :
- self.traiteEtape(s_etape=element,ind=ind)
+ if length > 1:
+ last = self.indent[length-1]
+ self.indent.remove(last)
+ self.indent_courant=self.indent[length-2]
else :
- self.traiteMcsimp(s_mcsimp=element,ind=ind)
-
- ind = 1
-
- def traiteEtape(self,s_etape,ind) :
- """
- Traite une partie du jdc formaté : s_etape, une chaîne de caractères
- contenant une étape
- L'attribut self.texte_etape est modifié (complété) par le traitement
- L'attribut self.indent est modifié par le traitement
- L'attribut self.indent_courant est modifié par le traitement
- """
- length = len(self.indent)
- if length > 1:
- last = self.indent[length-1]
- self.indent.remove(last)
- self.indent_courant=self.indent[length-2]
- else :
- self.indent_courant=self.indent[0]
- self.texte_etape = self.texte_etape + s_etape.strip()
-
- def traiteMcfact(self,s_mcfact,ind) :
- """
- Traite une partie du jdc formaté : s_mcfact, une chaîne de caractères
- contenant un mot-clef facteur.
- L'attribut self.texte_etape est modifié (complété) par le traitement
- L'attribut self.indent est modifié par le traitement
- L'attribut self.indent_courant est modifié par le traitement
- """
- self.texte_etape = self.texte_etape + s_mcfact.strip()
- length = len(self.indent)
- if length > 1:
- last = self.indent[length-1]
- self.indent.remove(last)
- self.indent_courant=self.indent[length-2]
- else :
- self.indent_courant=self.indent[0]
- return
-
-
- def traiteMcsimp(self,s_mcsimp,ind) :
- """
- Traite une partie du jdc formaté : s_mcsimp, une chaîne de caractères
- contenant un mot-clef simple.
- L'attribut self.texte_etape est modifié (complété) par le traitement
- """
- #
- # Ajout PN pour defi_fonction
- if self.texte_etape.find("DEFI_FONCTION") > 1 :
- bool_fonction=1
- if s_mcsimp.find("\n") > 1:
- txt=""; bool = 0; numident=1
- for l in s_mcsimp.splitlines() :
- if bool == 0 :
- bool = 1
- numident=s_mcsimp.find("=")+2
- txt=l
- else :
- txt=txt+('\n'+self.indent_courant*' '+numident*' ')*ind+l
- s_mcsimp = txt
- else :
- bool_fonction=0
- longueur = self.longueur(self.texte_etape)
- increment = len((u'\n'+self.indent_courant*' ')*ind + s_mcsimp.strip())
- if (bool_fonction == 1 ) :
- self.texte_etape = self.texte_etape+'\n'+self.indent_courant*' ' +s_mcsimp
- elif ( ((1-ind)*longueur+increment) <= self.l_max ) :
- self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind +s_mcsimp.strip()
- else :
- # il faut couper ...
- nom,valeur = str.split(s_mcsimp,self.sep,1)
- chaine = self.creerChaine(nom,valeur,'\n'+self.indent_courant*' ',ind)
- self.texte_etape = self.texte_etape + chaine
- return
-
-
- def longueur(self,texte):
- """
- texte est une string qui peut contenir des retours chariots
- Cette méthode retourne la longueur de la dernière ligne de texte
- """
- #liste = texte.split('\n')
- #return len(liste[-1])
- if texte [-1] == '\n' : return 0
- return len(texte[texte.rfind('\n'):-1])
-
-
- def creerChaine(self,nom,valeur,increment,ind):
- """
- La methode creerChaine reconstitue un objet Eficas à partir de
- - son nom,
- - sa valeur.
- """
- s=''
- if len(increment + nom + self.sep) <= self.l_max:
- texte = increment*ind
- label = nom + self.sep
- s=texte + label
- longueur = len(increment + label)
+ self.indent_courant=self.indent[0]
+ self.texte_etape = self.texte_etape + s_etape.strip()
+
+ def traiteMcfact(self,s_mcfact,ind) :
+ """
+ Traite une partie du jdc formaté : s_mcfact, une chaîne de caractères
+ contenant un mot-clef facteur.
+ L'attribut self.texte_etape est modifié (complété) par le traitement
+ L'attribut self.indent est modifié par le traitement
+ L'attribut self.indent_courant est modifié par le traitement
+ """
+ self.texte_etape = self.texte_etape + s_mcfact.strip()
+ length = len(self.indent)
+ if length > 1:
+ last = self.indent[length-1]
+ self.indent.remove(last)
+ self.indent_courant=self.indent[length-2]
+ else :
+ self.indent_courant=self.indent[0]
+ return
+
+
+ def traiteMcsimp(self,s_mcsimp,ind) :
+ """
+ Traite une partie du jdc formaté : s_mcsimp, une chaîne de caractères
+ contenant un mot-clef simple.
+ L'attribut self.texte_etape est modifié (complété) par le traitement
+ """
+ #
+ # Ajout PN pour defi_fonction
+ if self.texte_etape.find("DEFI_FONCTION") > 1 :
+ bool_fonction=1
+ if s_mcsimp.find("\n") > 1:
+ txt=""; bool = 0; numident=1
+ for l in s_mcsimp.splitlines() :
+ if bool == 0 :
+ bool = 1
+ numident=s_mcsimp.find("=")+2
+ txt=l
+ else :
+ txt=txt+('\n'+self.indent_courant*' '+numident*' ')*ind+l
+ s_mcsimp = txt
+ else :
+ bool_fonction=0
+ longueur = self.longueur(self.texte_etape)
+ increment = len((u'\n'+self.indent_courant*' ')*ind + s_mcsimp.strip())
+ if (bool_fonction == 1 ) :
+ self.texte_etape = self.texte_etape+'\n'+self.indent_courant*' ' +s_mcsimp
+ elif ( ((1-ind)*longueur+increment) <= self.l_max ) :
+ self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind +s_mcsimp.strip()
+ else :
+ # il faut couper ...
+ nom,valeur = str.split(s_mcsimp,self.sep,1)
+ chaine = self.creerChaine(nom,valeur,'\n'+self.indent_courant*' ',ind)
+ self.texte_etape = self.texte_etape + chaine
+ return
+
+
+ def longueur(self,texte):
+ """
+ texte est une string qui peut contenir des retours chariots
+ Cette méthode retourne la longueur de la dernière ligne de texte
+ """
+ #liste = texte.split('\n')
+ #return len(liste[-1])
+ if texte [-1] == '\n' : return 0
+ return len(texte[texte.rfind('\n'):-1])
+
+
+ def creerChaine(self,nom,valeur,increment,ind):
+ """
+ La methode creerChaine reconstitue un objet Eficas à partir de
+ - son nom,
+ - sa valeur.
+ """
+ s=''
+ if len(increment + nom + self.sep) <= self.l_max:
+ texte = increment*ind
+ label = nom + self.sep
+ s=texte + label
+ longueur = len(increment + label)
+
+ if ('(' not in valeur) or (valeur[0:3]=='"""') :
+ # il s'agit d'une vraie chaîne de caractères
+ val = len(valeur)
+ texte = (self.l_max-2-val)*' '+valeur
+ s=s+'\\\n'+texte
+ elif re.match(filePattern,valeur) or re.match(filePattern2,valeur):
+ val = len(valeur)
+ texte = (self.l_max-2-val)*' '+valeur
+ s=s+'\\\n'+texte
+ elif ',' in valeur:
+ # il s'agit d'une liste de tuple
+ # c est trop complique on ne splitte pas
+ if valeur[0:2]=='((' or valeur[0:2]=='[(':
+ s=s+valeur
+ return s
+ # il s'agit d'une liste
+ liste = valeur.split(',')
+ i=0
+ for arg in liste :
+ ajout = arg.strip()
+ if len(ajout) == 0 : continue
+ longueur = self.longueur(texte = (texte + label)) + len(ajout +',') + (1-i)*len(increment)
+ if longueur <= self.l_max:
+ if ajout[-1] != ')':
+ texte = texte + ajout +','
+ else :
+ texte = texte + ajout
+ else :
+ i=1
+ if ajout[-1] != ')':
+ texte = texte + increment + (len(label)+2)*' ' + ajout + ','
+ else :
+ texte = texte + increment + (len(label)+2)*' ' + ajout
+
+ s=s+texte
+ s = s + ','
- if ('(' not in valeur) or (valeur[0:3]=='"""') :
- # il s'agit d'une vraie chaîne de caractères
- val = len(valeur)
- texte = (self.l_max-2-val)*' '+valeur
- s=s+'\\\n'+texte
- elif re.match(filePattern,valeur) or re.match(filePattern2,valeur):
- val = len(valeur)
- texte = (self.l_max-2-val)*' '+valeur
- s=s+'\\\n'+texte
- elif ',' in valeur:
- # il s'agit d'une liste de tuple
- # c est trop complique on ne splitte pas
- if valeur[0:2]=='((' or valeur[0:2]=='[(':
- s=s+valeur
- return s
- # il s'agit d'une liste
- liste = valeur.split(',')
- i=0
- for arg in liste :
- ajout = arg.strip()
- if len(ajout) == 0 : continue
- longueur = self.longueur(texte = (texte + label)) + len(ajout +',') + (1-i)*len(increment)
- if longueur <= self.l_max:
- if ajout[-1] != ')':
- texte = texte + ajout +','
- else :
- texte = texte + ajout
- else :
- i=1
- if ajout[-1] != ')':
- texte = texte + increment + (len(label)+2)*' ' + ajout + ','
else :
- texte = texte + increment + (len(label)+2)*' ' + ajout
-
- s=s+texte
- s = s + ','
-
- else :
- # On a une ( mais pas de , . On passe la chaine sans modification
- val = len(valeur) +len(label)
- texte = (self.l_max-2-val)*' '+valeur
- s='\n'+s+texte
- else :
- label = nom + self.sep
- val = len(valeur) +len(label)
- s = '\n'+(self.l_max-2-val)*' '+label+valeur
- return s
+ # On a une ( mais pas de , . On passe la chaine sans modification
+ val = len(valeur) +len(label)
+ texte = (self.l_max-2-val)*' '+valeur
+ s='\n'+s+texte
+ else :
+ label = nom + self.sep
+ val = len(valeur) +len(label)
+ s = '\n'+(self.l_max-2-val)*' '+label+valeur
+ return s
class FormatageLigne(Formatage) :
- def __init__(self,l_jdc,code=None,mode=None,sep='=',l_max="**"):
- Formatage.__init__(self,l_jdc,code=None,mode=None,sep='=',l_max="**")
-
- def formateJdc(self):
- texte1=Formatage.formateJdc(self)
- newText=""
- lignes=texte1.split("\n")
- texte=""
- pattern_debut_blanc = re.compile(r"^ \s*.*")
- pattern_commentaire = re.compile(r"^\s*#.*")
- pattern_vide=re.compile(r"\s*^$")
- for l in lignes :
- if pattern_commentaire.match(l) or pattern_vide.match(l):
- newText+=l+"\n"
- continue
- if not pattern_debut_blanc.match(l) : texte=l
- else : texte+=re.sub(r'^ \s*',' ',l)
- if texte[-1]==";" :
- newText+=texte+"\n"
- texte=""
- return newText
-
-
+ def __init__(self,l_jdc,code=None,mode=None,sep='=',l_max="**"):
+ Formatage.__init__(self,l_jdc,code=None,mode=None,sep='=',l_max="**")
+
+ def formateJdc(self):
+ texte1=Formatage.formateJdc(self)
+ newText=""
+ lignes=texte1.split("\n")
+ texte=""
+ pattern_debut_blanc = re.compile(r"^ \s*.*")
+ pattern_commentaire = re.compile(r"^\s*#.*")
+ pattern_vide=re.compile(r"\s*^$")
+ for l in lignes :
+ if pattern_commentaire.match(l) or pattern_vide.match(l):
+ newText+=l+"\n"
+ continue
+ if not pattern_debut_blanc.match(l) : texte=l
+ else : texte+=re.sub(r'^ \s*',' ',l)
+ if texte[-1]==";" :
+ newText+=texte+"\n"
+ texte=""
+ return newText
import generator
plugins=pluginloader.PluginLoader(generator)
-
+++ /dev/null
-Title = 'toto'
-txt=''
-txt += "Title" + "= " + str(Title) + "\n"
-print txt
-
from .generator_python import PythonGenerator
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'GroupMA',
- # La factory pour creer une instance du plugin
- 'factory' : GroupMAGenerator,
- }
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'GroupMA',
+ # La factory pour creer une instance du plugin
+ 'factory' : GroupMAGenerator,
+ }
class GroupMAGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format homard
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format homard
- """
- # Les extensions de fichier preconisees
- extensions=('.comm',)
+ """
+ # Les extensions de fichier preconisees
+ extensions=('.comm',)
- def __init__(self):
- PythonGenerator.__init__(self)
- self.listeMA=[]
- self.listeNO=[]
+ def __init__(self):
+ PythonGenerator.__init__(self)
+ self.listeMA=[]
+ self.listeNO=[]
- def gener(self,obj,format='brut',config=None):
- self.liste=[]
- self.text=PythonGenerator.gener(self,obj,'brut',config=None)
- return self.listeMA,self.listeNO
+ def gener(self,obj,format='brut',config=None):
+ self.liste=[]
+ self.text=PythonGenerator.gener(self,obj,'brut',config=None)
+ return self.listeMA,self.listeNO
- def generMCSIMP(self,obj) :
- if 'grma' in repr(obj.definition.type) :
- if not type(obj.valeur) in (list, tuple):
- aTraiter=(obj.valeur,)
- else :
- aTraiter=obj.valeur
- for group in aTraiter :
- if group not in self.listeMA :
- self.listeMA.append(group)
- if 'grno' in repr(obj.definition.type) :
- if not type(obj.valeur) in (list, tuple):
- aTraiter=(obj.valeur,)
- else :
- aTraiter=obj.valeur
- for group in aTraiter :
- if group not in self.listeNO :
- self.listeNO.append(group)
- s=PythonGenerator.generMCSIMP(self,obj)
- return s
+ def generMCSIMP(self,obj) :
+ if 'grma' in repr(obj.definition.type) :
+ if not type(obj.valeur) in (list, tuple):
+ aTraiter=(obj.valeur,)
+ else :
+ aTraiter=obj.valeur
+ for group in aTraiter :
+ if group not in self.listeMA :
+ self.listeMA.append(group)
+ if 'grno' in repr(obj.definition.type) :
+ if not type(obj.valeur) in (list, tuple):
+ aTraiter=(obj.valeur,)
+ else :
+ aTraiter=obj.valeur
+ for group in aTraiter :
+ if group not in self.listeNO :
+ self.listeNO.append(group)
+ s=PythonGenerator.generMCSIMP(self,obj)
+ return s
from __future__ import absolute_import
try :
- from builtins import str
+ from builtins import str
except : pass
texte_debut="int main() \n{ \n init_var();\n"
from .generator_dicoImbrique import DicoImbriqueGenerator
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'PSEN',
- # La factory pour creer une instance du plugin
- 'factory' : PSENGenerator,
- }
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'PSEN',
+ # La factory pour creer une instance du plugin
+ 'factory' : PSENGenerator,
+ }
class PSENGenerator(DicoImbriqueGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format dictionnaire
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format dictionnaire
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None, appliEficas=None):
-
- try :
- self.MachineDico = obj.MachineDico
- self.LoadDico = obj.LoadDico
- self.LineDico = obj.LineDico
- self.TransfoDico = obj.TransfoDico
- self.MotorDico = obj.MotorDico
- except :
- self.MachineDico = None
- self.LoadDico = None
- self.LineDico = None
- self.TransfoDico = None
- self.MotorDico = None
-
- self.initDico()
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=DicoImbriqueGenerator.gener(self,obj,format)
- return self.text
+ def gener(self,obj,format='brut',config=None, appliEficas=None):
+
+ try :
+ self.MachineDico = obj.MachineDico
+ self.LoadDico = obj.LoadDico
+ self.LineDico = obj.LineDico
+ self.TransfoDico = obj.TransfoDico
+ self.MotorDico = obj.MotorDico
+ except :
+ self.MachineDico = None
+ self.LoadDico = None
+ self.LineDico = None
+ self.TransfoDico = None
+ self.MotorDico = None
+
+ self.initDico()
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=DicoImbriqueGenerator.gener(self,obj,format)
+ return self.text
#----------------------------------------------------------------------------------------
# initialisations
#----------------------------------------------------------------------------------------
-
- def initDico(self) :
- DicoImbriqueGenerator.initDico(self)
- self.Entete = 'MachineDico = ' + str(self.MachineDico) +'\n'
- self.Entete += 'LoadDico = ' + str(self.LoadDico) +'\n'
- self.Entete += 'LineDico = ' + str(self.LineDico) +'\n'
- self.Entete += 'TransfoDico = ' + str(self.TransfoDico) +'\n'
- self.Entete += 'MotorDico = ' + str(self.MotorDico) + '\n'
- self.Entete +='\n'
+
+ def initDico(self) :
+ DicoImbriqueGenerator.initDico(self)
+ self.Entete = 'MachineDico = ' + str(self.MachineDico) +'\n'
+ self.Entete += 'LoadDico = ' + str(self.LoadDico) +'\n'
+ self.Entete += 'LineDico = ' + str(self.LineDico) +'\n'
+ self.Entete += 'TransfoDico = ' + str(self.TransfoDico) +'\n'
+ self.Entete += 'MotorDico = ' + str(self.MotorDico) + '\n'
+ self.Entete +='\n'
#----------------------------------------------------------------------------------------
# ecriture
#----------------------------------------------------------------------------------------
- def writeDefault(self,fn) :
- fileDico=os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),'..','PSEN_Eficas','PSEN','PSENconfig.py'))
- f = open( str(fileDico), 'wb')
- f.write( self.Entete + "Dico =" + str(self.Dico) )
- f.close()
+ def writeDefault(self,fn) :
+ fileDico=os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),'..','PSEN_Eficas','PSEN','PSENconfig.py'))
+ f = open( str(fileDico), 'wb')
+ f.write( self.Entete + "Dico =" + str(self.Dico) )
+ f.close()
+
-
#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
+# analyse de chaque noeud de l'arbre
#----------------------------------------------------------------------------------------
## def generMCSIMP(self,obj) :
## self.dicoTemp={}
## return s
-
+
# si repertoire on change tous les noms de fichier
from .generator_modification import ModificationGenerator
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'ProcessOutputs',
- # La factory pour creer une instance du plugin
- 'factory' : ProcessOutputsGenerator,
- }
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'ProcessOutputs',
+ # La factory pour creer une instance du plugin
+ 'factory' : ProcessOutputsGenerator,
+ }
class ProcessOutputsGenerator(PythonGenerator,ModificationGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format dictionnaire
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format dictionnaire
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None, appliEficas=None):
+ def gener(self,obj,format='brut',config=None, appliEficas=None):
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- texteModification=self.generTexteModif(obj)
- text=PythonGenerator.gener(self,obj,format)
- self.text=texteModification+text
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ texteModification=self.generTexteModif(obj)
+ text=PythonGenerator.gener(self,obj,format)
+ self.text=texteModification+text
+
+ return self.text
- return self.text
-
# si repertoire on change tous les noms de fichier
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
+ from builtins import str
except : pass
import traceback
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'TELEMAC',
- # La factory pour creer une instance du plugin
- 'factory' : TELEMACGenerator,
- }
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'TELEMAC',
+ # La factory pour creer une instance du plugin
+ 'factory' : TELEMACGenerator,
+ }
class TELEMACGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format dictionnaire
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format dictionnaire
- """
+ """
#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None,appliEficas=None,statut="Leger"):
-
- self.statut = statut
- self.langue = appliEficas.langue
- try : self.TelemacdicoEn = appliEficas.readercata.TelemacdicoEn
- except :
- print ('Attention : pas de TelemacdicoEn declare')
- self.TelemacdicoEn = {}
- self.DicoEnumCasEnInverse = {}
- #from enum_Telemac2d_auto import self.TelemacdicoEn
- for motClef in self.TelemacdicoEn:
- d={}
- for valTelemac in self.TelemacdicoEn[motClef]:
- valEficas = self.TelemacdicoEn[motClef][valTelemac]
- d[valEficas] =valTelemac
- self.DicoEnumCasEnInverse[motClef]=d
- if self.langue == 'fr' :
- #from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
- self.DicoEnumCasFrToEnumCasEn = appliEficas.readercata.DicoEnumCasFrToEnumCasEn
- for motClef in self.DicoEnumCasFrToEnumCasEn:
- d={}
- for valTelemac in self.DicoEnumCasFrToEnumCasEn[motClef]:
- valEficas = self.DicoEnumCasFrToEnumCasEn[motClef][valTelemac]
- d[valEficas] = valTelemac
- self.DicoEnumCasEnInverse[motClef]=d
- self.initDico()
- # Pour Simplifier les verifs d ecriture
- if hasattr(appliEficas,'listeTelemac') : self.listeTelemac=appliEficas.listeTelemac
- else : self.listeTelemac = ()
-
- self.dicoCataToCas={}
- try :
- self.dicoCasToCata=appliEficas.readercata.dicoCasToCata
- except :
- print ('Attention pas de dicoCasToCata declare')
- self.dicoCasToCata={}
- self.dicoCataToCas={}
- for motClef in self.dicoCasToCata:
- self.dicoCataToCas[self.dicoCasToCata[motClef]]=motClef
-
-
-
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
- return self.text
+ def gener(self,obj,format='brut',config=None,appliEficas=None,statut="Leger"):
+
+ self.statut = statut
+ self.langue = appliEficas.langue
+ try : self.TelemacdicoEn = appliEficas.readercata.TelemacdicoEn
+ except :
+ print ('Attention : pas de TelemacdicoEn declare')
+ self.TelemacdicoEn = {}
+ self.DicoEnumCasEnInverse = {}
+ #from enum_Telemac2d_auto import self.TelemacdicoEn
+ for motClef in self.TelemacdicoEn:
+ d={}
+ for valTelemac in self.TelemacdicoEn[motClef]:
+ valEficas = self.TelemacdicoEn[motClef][valTelemac]
+ d[valEficas] =valTelemac
+ self.DicoEnumCasEnInverse[motClef]=d
+ if self.langue == 'fr' :
+ #from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
+ self.DicoEnumCasFrToEnumCasEn = appliEficas.readercata.DicoEnumCasFrToEnumCasEn
+ for motClef in self.DicoEnumCasFrToEnumCasEn:
+ d={}
+ for valTelemac in self.DicoEnumCasFrToEnumCasEn[motClef]:
+ valEficas = self.DicoEnumCasFrToEnumCasEn[motClef][valTelemac]
+ d[valEficas] = valTelemac
+ self.DicoEnumCasEnInverse[motClef]=d
+ self.initDico()
+ # Pour Simplifier les verifs d ecriture
+ if hasattr(appliEficas,'listeTelemac') : self.listeTelemac=appliEficas.listeTelemac
+ else : self.listeTelemac = ()
+
+ self.dicoCataToCas={}
+ try :
+ self.dicoCasToCata=appliEficas.readercata.dicoCasToCata
+ except :
+ print ('Attention pas de dicoCasToCata declare')
+ self.dicoCasToCata={}
+ self.dicoCataToCas={}
+ for motClef in self.dicoCasToCata:
+ self.dicoCataToCas[self.dicoCasToCata[motClef]]=motClef
+
+
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+ return self.text
#----------------------------------------------------------------------------------------
# initialisations
#----------------------------------------------------------------------------------------
- def initDico(self) :
+ def initDico(self) :
- self.PE=False
- self.FE=False
- self.VE=False
- self.commentaireAvant = False
- self.texteCom=''
- if self.langue == "fr" :
- self.textPE = 'COTES IMPOSEES :'
- self.textFE = 'DEBITS IMPOSES :'
- self.textVE = 'VITESSES IMPOSEES :'
- else :
- self.textPE = 'PRESCRIBED ELEVATIONS :'
- self.textFE = 'PRESCRIBED FLOWRATES :'
- self.textVE = 'PRESCRIBED VELOCITIES :'
- self.nbTracers = 0
- self.texteDico = ""
+ self.PE=False
+ self.FE=False
+ self.VE=False
+ self.commentaireAvant = False
+ self.texteCom=''
+ if self.langue == "fr" :
+ self.textPE = 'COTES IMPOSEES :'
+ self.textFE = 'DEBITS IMPOSES :'
+ self.textVE = 'VITESSES IMPOSEES :'
+ else :
+ self.textPE = 'PRESCRIBED ELEVATIONS :'
+ self.textFE = 'PRESCRIBED FLOWRATES :'
+ self.textVE = 'PRESCRIBED VELOCITIES :'
+ self.nbTracers = 0
+ self.texteDico = ""
# ecriture de tout
#----------------------------------------------------------------------------------------
- def writeDefault(self,fn) :
- self.texteDico+='&ETA\n'
- #if self.statut == 'Leger' : extension = ".Lcas"
- #else : extension = ".cas"
- extension=".cas"
- fileDico = fn[:fn.rfind(".")] + extension
- f = open( str(fileDico), 'w')
- f.write( self.texteDico )
- f.close()
+ def writeDefault(self,fn) :
+ self.texteDico+='&ETA\n'
+ #if self.statut == 'Leger' : extension = ".Lcas"
+ #else : extension = ".cas"
+ extension=".cas"
+ fileDico = fn[:fn.rfind(".")] + extension
+ f = open( str(fileDico), 'w')
+ f.write( self.texteDico )
+ f.close()
#----------------------------------------------------------------------------------------
# ecriture de Leger
#----------------------------------------------------------------------------------------
- def writeComplet(self,fn,jdc,config,appliEficas) :
- jdc_formate=self.gener(jdc,config=config,appliEficas=appliEficas,statut="Entier")
- self.writeDefault(fn)
+ def writeComplet(self,fn,jdc,config,appliEficas) :
+ jdc_formate=self.gener(jdc,config=config,appliEficas=appliEficas,statut="Entier")
+ self.writeDefault(fn)
#----------------------------------------------------------------------------------------
# analyse de chaque noeud de l'arbre
#----------------------------------------------------------------------------------------
- def generPROC_ETAPE(self,obj):
+ def generPROC_ETAPE(self,obj):
if not self.commentaireAvant or self.texteCom.find(obj.nom) < 0:
self.texteDico += '/------------------------------------------------------------------/\n'
self.texteDico += '/\t\t\t'+obj.nom +'\n'
return s
- def generMCSIMP(self,obj) :
+ def generMCSIMP(self,obj) :
"""recuperation de l objet MCSIMP"""
s=PythonGenerator.generMCSIMP(self,obj)
# a reflechir avec Yoann
# ajouter le statut ?
if self.statut == 'Leger' :
- if hasattr(obj.definition,'defaut') and (obj.definition.defaut == obj.valeur) and (obj.nom not in self.listeTelemac) : return s
- if hasattr(obj.definition,'defaut') and obj.definition.defaut != None and (type(obj.valeur) == tuple or type(obj.valeur) == list) and (tuple(obj.definition.defaut) == tuple(obj.valeur)) and (obj.nom not in self.listeTelemac) : return s
+ if hasattr(obj.definition,'defaut') and (obj.definition.defaut == obj.valeur) and (obj.nom not in self.listeTelemac) : return s
+ if hasattr(obj.definition,'defaut') and obj.definition.defaut != None and (type(obj.valeur) == tuple or type(obj.valeur) == list) and (tuple(obj.definition.defaut) == tuple(obj.valeur)) and (obj.nom not in self.listeTelemac) : return s
#nomMajuscule=obj.nom.upper()
#nom=nomMajuscule.replace('_',' ')
#if nom in listeSupprime or s == "" : return s
- if s == "None," : s=None
+ if s == "None," : s=None
if s == "" or s==None : return s
sTelemac=s[0:-1]
if not( type(obj.valeur) in (tuple,list) ):
- if obj.nom in self.DicoEnumCasEnInverse:
- try : sTelemac=str(self.DicoEnumCasEnInverse[obj.nom][obj.valeur])
- except :
- if obj.valeur==None : sTelemac=obj.valeur
- else : print(("generMCSIMP Pb valeur avec ", obj.nom, obj.valeur))
- # Si le resultat est du texte on ajoute des guillemets
- if sTelemac[0] not in '0123456789':
- sTelemac = "'" + sTelemac +"'"
+ if obj.nom in self.DicoEnumCasEnInverse:
+ try : sTelemac=str(self.DicoEnumCasEnInverse[obj.nom][obj.valeur])
+ except :
+ if obj.valeur==None : sTelemac=obj.valeur
+ else : print(("generMCSIMP Pb valeur avec ", obj.nom, obj.valeur))
+ # Si le resultat est du texte on ajoute des guillemets
+ if sTelemac[0] not in '0123456789':
+ sTelemac = "'" + sTelemac +"'"
if type(obj.valeur) in (tuple,list) :
- if obj.nom in self.DicoEnumCasEnInverse:
- #sT = "'"
- sT=''
- for v in obj.valeur:
- try : sT +=str(self.DicoEnumCasEnInverse[obj.nom][v]) +";"
- except :
- if obj.definition.intoSug != [] : sT +=str(v) + ";"
- else : print(("generMCSIMP Pb Tuple avec ", obj.nom, v, obj.valeur))
- #sTelemac=sT[0:-1]+"'"
- sTelemac=sT[0:-1]
- else :
- sTelemac=sTelemac[0:-1]
- if sTelemac.find("'") > 0 :
- sTelemac= sTelemac.replace (',',';\n ')
- # on enleve le dernier ';'
- index=(sTelemac.rfind(";"))
- sTelemac=sTelemac[:index]+' '+sTelemac[index+1:]
+ if obj.nom in self.DicoEnumCasEnInverse:
+ #sT = "'"
+ sT=''
+ for v in obj.valeur:
+ try : sT +=str(self.DicoEnumCasEnInverse[obj.nom][v]) +";"
+ except :
+ if obj.definition.intoSug != [] : sT +=str(v) + ";"
+ else : print(("generMCSIMP Pb Tuple avec ", obj.nom, v, obj.valeur))
+ #sTelemac=sT[0:-1]+"'"
+ sTelemac=sT[0:-1]
+ else :
+ sTelemac=sTelemac[0:-1]
+ if sTelemac.find("'") > 0 :
+ sTelemac= sTelemac.replace (',',';\n ')
+ # on enleve le dernier ';'
+ index=(sTelemac.rfind(";"))
+ sTelemac=sTelemac[:index]+' '+sTelemac[index+1:]
if self.langue=='fr' :
- s1=str(sTelemac).replace('True','OUI')
- s2=s1.replace('False','NON')
+ s1=str(sTelemac).replace('True','OUI')
+ s2=s1.replace('False','NON')
else :
- s1=str(sTelemac).replace('True','YES')
- s2=s1.replace('False','NO')
+ s1=str(sTelemac).replace('True','YES')
+ s2=s1.replace('False','NO')
if hasattr(obj.definition,'max'):
- if obj.definition.max != 1:
- s3=s2.replace(',',';')
- else:
- s3=s2
+ if obj.definition.max != 1:
+ s3=s2.replace(',',';')
+ else:
+ s3=s2
if s3 != "" and s3[0]=='(' :
- try : s3=s3[1:-1] # cas de liste vide
- except : s3 = ' '
+ try : s3=s3[1:-1] # cas de liste vide
+ except : s3 = ' '
# LIQUID_BOUNDARIES
# cas des Tuples
if obj.waitTuple() and s3 != '' and s3 != 'None':
- s3=s
- if s3[-1] == ',': s3=s3[:-1]
+ s3=s
+ if s3[-1] == ',': s3=s3[:-1]
if obj.nom not in self.dicoCataToCas :
- if obj.nom == 'Consigne' : return ""
- return s
+ if obj.nom == 'Consigne' : return ""
+ return s
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 != '' and s3 != 'None':
+ if s3 != '' and s3 != 'None':
s3=s3.replace(';',',')
s3="'"+ s3 +"'"
- else:
+ else:
s3 = "''"
if s3 == "" or s3 == " " : s3 = " "
ligne=nom+ " : " + s3 + "\n"
if len(ligne) > 72 : ligne=self.redecoupeLigne(nom,s3)
self.texteDico+=ligne
- def generMCFACT(self,obj):
- """
- """
- s=PythonGenerator.generMCFACT(self,obj)
- if obj.nom in TELEMACGenerator.__dict__ : TELEMACGenerator.__dict__[obj.nom](self,obj)
-
- return s
-
-
- def TRACERS(self,obj):
- if self.nbTracers != 0 : self.texteDico += 'NUMBER_OF_TRACERS : '+str(self.nbTracers) + '\n'
-
-
- def NAME_OF_TRACER(self,obj):
- print((dir(obj) ))
- print((obj.getGenealogiePrecise()))
-
- def Validation(self,obj):
- self.texteDico += "VALIDATION : True \n"
-
- def Date_De_L_Origine_Des_Temps (self,obj):
- 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.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):
- listeAdvection=[1,5,1,1]
- listeSupg=[2,2,2,2]
- listeUpwind=[1.,1.,1.,1.]
- self.listeMCAdvection=[]
- self.chercheChildren(obj)
- dicoSuf={ 'U_And_V' : 0, 'H' : 1, 'K_And_Epsilon' : 2, 'Tracers' : 3}
- for c in self.listeMCAdvection:
- if c.nom[0:18] == 'Type_Of_Advection_' and c.valeur!=None:
- suf=c.nom[18:]
- index=dicoSuf[suf]
- listeAdvection[index]=self.DicoEnumCasEnInverse['Type_Of_Advection'][c.valeur]
- if c.nom[0:13] == 'Supg_Option_' and c.valeur!=None:
- suf=c.nom[13:]
- index=dicoSuf[suf]
- listeAdvection[index]=self.DicoEnumCasEnInverse['Supg_Option'][c.valeur]
- if c.nom[0:23] == 'Upwind_Coefficients_Of_' and c.valeur!=None:
- suf=c.nom[23:]
- index=dicoSuf[suf]
- listeUpwind[index]=c.valeur
- self.texteDico += "TYPE OF ADVECTION = "+ str(listeAdvection) + "\n"
- self.texteDico += "SUPG OPTION = "+ str(listeSupg) + "\n"
- self.texteDico += "UPWIND COEFFICIENTS = "+ str(listeUpwind) + "\n"
-
- def chercheChildren(self,obj):
- for c in obj.listeMcPresents():
- objc=obj.getChild(c)
- if hasattr(objc,'listeMcPresents') and objc.listeMcPresents() != [] : self.chercheChildren(objc)
- else : self.listeMCAdvection.append(objc)
-
-
-
- def redecoupeLigne(self,nom,valeur) :
- text=nom+ " : \n"
- valeur=valeur
- if valeur.find("'") > -1:
- lval=valeur.split(";")
- for v in lval : text+=' '+v+';'
- text=text[0:-1]+'\n'
- else :
- lval=valeur.split(";")
- ligne=" "
- for v in lval :
- if len(ligne+ str(v)+'; ') < 70 : ligne += str(v)+'; '
- else :
- text+= ligne+"\n"
- ligne=" "+str(v)+'; '
- text+= ligne[0:-2]+'\n'
- return text
-
- def generCOMMENTAIRE(self,obj):
- sans_saut = re.sub("\n$","",obj.valeur)
- l_lignes = sans_saut.split('\n')
- txt='/'+66*'-'+'/'+'\n'
- i=1
- for ligne in l_lignes:
- self.texteCom+=ligne+'\n'
- txt = txt + '/'+ligne+'\n'
- txt= txt + '/'+66*'-'+'/'+'\n'
- self.texteDico += txt
- self.commentaireAvant= True
- return PythonGenerator.generCOMMENTAIRE(self,obj)
+ def generMCFACT(self,obj):
+ """
+ """
+ s=PythonGenerator.generMCFACT(self,obj)
+ if obj.nom in TELEMACGenerator.__dict__ : TELEMACGenerator.__dict__[obj.nom](self,obj)
+
+ return s
+ def TRACERS(self,obj):
+ if self.nbTracers != 0 : self.texteDico += 'NUMBER_OF_TRACERS : '+str(self.nbTracers) + '\n'
+
+
+ def NAME_OF_TRACER(self,obj):
+ print((dir(obj) ))
+ print((obj.getGenealogiePrecise()))
+
+ def Validation(self,obj):
+ self.texteDico += "VALIDATION : True \n"
+
+ def Date_De_L_Origine_Des_Temps (self,obj):
+ 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.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):
+ listeAdvection=[1,5,1,1]
+ listeSupg=[2,2,2,2]
+ listeUpwind=[1.,1.,1.,1.]
+ self.listeMCAdvection=[]
+ self.chercheChildren(obj)
+ dicoSuf={ 'U_And_V' : 0, 'H' : 1, 'K_And_Epsilon' : 2, 'Tracers' : 3}
+ for c in self.listeMCAdvection:
+ if c.nom[0:18] == 'Type_Of_Advection_' and c.valeur!=None:
+ suf=c.nom[18:]
+ index=dicoSuf[suf]
+ listeAdvection[index]=self.DicoEnumCasEnInverse['Type_Of_Advection'][c.valeur]
+ if c.nom[0:13] == 'Supg_Option_' and c.valeur!=None:
+ suf=c.nom[13:]
+ index=dicoSuf[suf]
+ listeAdvection[index]=self.DicoEnumCasEnInverse['Supg_Option'][c.valeur]
+ if c.nom[0:23] == 'Upwind_Coefficients_Of_' and c.valeur!=None:
+ suf=c.nom[23:]
+ index=dicoSuf[suf]
+ listeUpwind[index]=c.valeur
+ self.texteDico += "TYPE OF ADVECTION = "+ str(listeAdvection) + "\n"
+ self.texteDico += "SUPG OPTION = "+ str(listeSupg) + "\n"
+ self.texteDico += "UPWIND COEFFICIENTS = "+ str(listeUpwind) + "\n"
+
+ def chercheChildren(self,obj):
+ for c in obj.listeMcPresents():
+ objc=obj.getChild(c)
+ if hasattr(objc,'listeMcPresents') and objc.listeMcPresents() != [] : self.chercheChildren(objc)
+ else : self.listeMCAdvection.append(objc)
+
+
+
+ def redecoupeLigne(self,nom,valeur) :
+ text=nom+ " : \n"
+ valeur=valeur
+ if valeur.find("'") > -1:
+ lval=valeur.split(";")
+ for v in lval : text+=' '+v+';'
+ text=text[0:-1]+'\n'
+ else :
+ lval=valeur.split(";")
+ ligne=" "
+ for v in lval :
+ if len(ligne+ str(v)+'; ') < 70 : ligne += str(v)+'; '
+ else :
+ text+= ligne+"\n"
+ ligne=" "+str(v)+'; '
+ text+= ligne[0:-2]+'\n'
+ return text
+
+ def generCOMMENTAIRE(self,obj):
+ sans_saut = re.sub("\n$","",obj.valeur)
+ l_lignes = sans_saut.split('\n')
+ txt='/'+66*'-'+'/'+'\n'
+ i=1
+ for ligne in l_lignes:
+ self.texteCom+=ligne+'\n'
+ txt = txt + '/'+ligne+'\n'
+ txt= txt + '/'+66*'-'+'/'+'\n'
+ self.texteDico += txt
+ self.commentaireAvant= True
+ return PythonGenerator.generCOMMENTAIRE(self,obj)
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
+ from builtins import str
except : pass
import traceback
from .generator_python import PythonGenerator
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'xml',
- # La factory pour creer une instance du plugin
- 'factory' : XMLGenerator,
- }
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'xml',
+ # La factory pour creer une instance du plugin
+ 'factory' : XMLGenerator,
+ }
class XMLGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None,appliEficas=None):
-
- try :
- #if 1 :
- self.texteXML=obj.toXml()
- except :
- self.texteXML='erreur generation'
- # pass
-
- self.textePourAide =""
- self.dictNbNomObj={}
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
- return self.text
+ def gener(self,obj,format='brut',config=None,appliEficas=None):
+
+ try :
+ #if 1 :
+ self.texteXML=obj.toXml()
+ except :
+ self.texteXML='erreur generation'
+ print (self.texteXML)
+ # pass
+
+ self.textePourAide =""
+ self.dictNbNomObj={}
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+ return self.text
#----------------------------------------------------------------------------------------
# initialisations
#----------------------------------------------------------------------------------------
-
+
# ecriture
#----------------------------------------------------------------------------------------
- def writeDefault(self,fn) :
- fileXML = fn[:fn.rfind(".")] + '.xml'
- #filePyxb = fn[:fn.rfind(".")] + '.py'
- fileBase = os.path.basename(fileXML)
- fileBase = fileBase[:fileBase.rfind(".")] + '.py'
- filePyxb = '/tmp/' + fileBase
- print (filePyxb)
- #fileDico='/tmp/toto.xml'
- #print (self.texteXML)
- f = open( str(fileXML), 'w')
- f.write(str(self.texteXML))
- f.close()
-
- f = open( str(filePyxb), 'w')
- f.write(str(self.textePourAide))
- f.close()
-
-
- def generMCSIMP(self,obj) :
- if obj.nom in self.dictNbNomObj.keys():
- nomUtil = obj.nom + "_" + str(self.dictNbNomObj[obj.nom])
- self.dictNbNomObj[obj.nom] += 1
- else :
- nomUtil = obj.nom
- self.dictNbNomObj[obj.nom] = 1
- self.textePourAide += nomUtil + " = vimmpCase." + obj.getNomDsXML() + "\n"
- #self.textePourAide += "print '"+ nomUtil+ " =' , " + str(nomUtil) + "\n"
- self.textePourAide +='txt += "' + nomUtil + '" + " = " +str( ' + nomUtil + ') ' + "\n"
-
-
-
- s=PythonGenerator.generMCSIMP(self,obj)
- return s
+ def writeDefault(self,fn) :
+ fileXML = fn[:fn.rfind(".")] + '.xml'
+ #filePyxb = fn[:fn.rfind(".")] + '.py'
+ fileBase = os.path.basename(fileXML)
+ fileBase = fileBase[:fileBase.rfind(".")] + '.py'
+ filePyxb = '/tmp/' + fileBase
+ #print (filePyxb)
+ #fileDico='/tmp/toto.xml'
+ #print (self.texteXML)
+ f = open( str(fileXML), 'w')
+ f.write(str(self.texteXML))
+ f.close()
+
+ f = open( str(filePyxb), 'w')
+ f.write(str(self.textePourAide))
+ f.close()
+
+
+ def generMCSIMP(self,obj) :
+ if obj.nom in self.dictNbNomObj.keys():
+ nomUtil = obj.nom + "_" + str(self.dictNbNomObj[obj.nom])
+ self.dictNbNomObj[obj.nom] += 1
+ else :
+ nomUtil = obj.nom
+ self.dictNbNomObj[obj.nom] = 1
+ self.textePourAide += nomUtil + " = vimmpCase." + obj.getNomDsXML() + "\n"
+ #self.textePourAide += "print '"+ nomUtil+ " =' , " + str(nomUtil) + "\n"
+ self.textePourAide +='txt += "' + nomUtil + '" + " = " +str( ' + nomUtil + ') ' + "\n"
+
+
+
+ s=PythonGenerator.generMCSIMP(self,obj)
+ return s
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient le plugin generateur de fichier au format
+ Ce module contient le plugin generateur de fichier au format
aplat pour EFICAS.
"""
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except : pass
import traceback
from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'aplat',
- # La factory pour creer une instance du plugin
- 'factory' : AplatGenerator,
- }
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'aplat',
+ # La factory pour creer une instance du plugin
+ 'factory' : AplatGenerator,
+ }
class AplatGenerator(object):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un fichier au format aplat
-
- L'acquisition et le parcours sont realises par la methode
- generator.gener(objet_jdc,format)
-
- L'ecriture du fichier au format ini par appel de la methode
- generator.writefile(nom_fichier)
-
- Ses caracteristiques principales sont exposees dans des attributs
- de classe :
- - extensions : qui donne une liste d'extensions de fichier preconisees
-
- """
- # Les extensions de fichier preconisees
- extensions=('.*',)
-
- def __init__(self,cr=None):
- # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
- if cr :
- self.cr=cr
- else:
- self.cr=N_CR.CR(debut='CR generateur format aplat pour eficas',
- fin='fin CR format aplat pour eficas')
- self.init=''
- # Le separateur utiise
- self.sep='//'
- # Le texte au format aplat est stocke dans l'attribut text
- self.text=''
-
- def writefile(self,filename):
- fp=open(filename,'w')
- fp.write(self.text)
- fp.close()
-
- def gener(self,obj,format='brut',config=None,appliEficas=None):
- """
- Retourne une representation du JDC obj sous une forme qui est parametree par format.
- Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu de generator
- """
- liste= self.generator(obj)
- if format == 'brut':
- self.text=liste
- elif format == 'standard':
- self.text=liste
- elif format == 'beautifie':
- self.text=liste
- else:
- raise EficasException(tr("Format pas implemente : %s", format))
- return self.text
-
- def generator(self,obj):
- """
- Cette methode joue un role d'aiguillage en fonction du type de obj
- On pourrait utiliser les methodes accept et visitxxx a la
- place (depend des gouts !!!)
- """
- # ATTENTION a l'ordre des tests : il peut avoir de l'importance (heritage)
- if isinstance(obj,PROC_ETAPE):
- return self.generPROC_ETAPE(obj)
- elif isinstance(obj,MACRO_ETAPE):
- return self.generMACRO_ETAPE(obj)
- elif isinstance(obj,FORM_ETAPE):
- return self.generFORM_ETAPE(obj)
- elif isinstance(obj,ETAPE):
- return self.generETAPE(obj)
- elif isinstance(obj,MCFACT):
- return self.generMCFACT(obj)
- elif isinstance(obj,MCList):
- return self.generMCList(obj)
- elif isinstance(obj,MCBLOC):
- return self.generMCBLOC(obj)
- elif isinstance(obj,MCSIMP):
- return self.generMCSIMP(obj)
- elif isinstance(obj,ASSD):
- return self.generASSD(obj)
- elif isinstance(obj,ETAPE_NIVEAU):
- return self.generETAPE_NIVEAU(obj)
- elif isinstance(obj,COMMENTAIRE):
- return self.generCOMMENTAIRE(obj)
- # Attention doit etre place avant PARAMETRE (raison : heritage)
- elif isinstance(obj,PARAMETRE_EVAL):
- return self.generPARAMETRE_EVAL(obj)
- elif isinstance(obj,PARAMETRE):
- return self.generPARAMETRE(obj)
- elif isinstance(obj,EVAL):
- return self.generEVAL(obj)
- elif isinstance(obj,COMMANDE_COMM):
- return self.generCOMMANDE_COMM(obj)
- elif isinstance(obj,JDC):
- return self.generJDC(obj)
- elif isinstance(obj,MCNUPLET):
- return self.generMCNUPLET(obj)
- else:
- raise EficasException(tr("Format non implemente : %s", format))
-
-
- def generJDC(self,obj):
- """
- Cette methode convertit un objet JDC en une chaine de
- caracteres a la syntaxe aplat
- """
- text=''
- if obj.definition.l_niveaux == ():
- # Il n'y a pas de niveaux
- for etape in obj.etapes:
- text=text+self.generator(etape)+'\n'
- else:
- # Il y a des niveaux
- for etape_niveau in obj.etapes_niveaux:
- text=text+self.generator(etape_niveau)+'\n'
- return text
-
- def generCOMMANDE_COMM(self,obj):
- """
- Cette methode convertit un COMMANDE_COMM
- en une chaine de caracteres a la syntaxe aplat
- """
- l_lignes = obj.valeur.split('\n')
- txt=''
- for ligne in l_lignes:
- txt = txt + '##'+ligne+'\n'
- return txt
-
- def generEVAL(self,obj):
- """
- Cette methode convertit un EVAL
- en une chaine de caracteres a la syntaxe aplat
- """
- return 'EVAL("""'+ obj.valeur +'""")'
-
- def generCOMMENTAIRE(self,obj):
- """
- Cette methode convertit un COMMENTAIRE
- en une chaine de caracteres a la syntaxe aplat
- """
- l_lignes = obj.valeur.split('\n')
- txt=''
- for ligne in l_lignes:
- txt = txt + '#'+ligne+'\n'
- return txt
-
- def generPARAMETRE_EVAL(self,obj):
- """
- Cette methode convertit un PARAMETRE_EVAL
- en une chaine de caracteres a la syntaxe aplat
- """
- if obj.valeur == None:
- return obj.nom + ' = None ;\n'
- else:
- return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
-
- def generPARAMETRE(self,obj):
- """
- Cette methode convertit un PARAMETRE
- en une chaine de caracteres a la syntaxe aplat
- """
- if type(obj.valeur) == bytes or type(obj.valeur) == str:
- # PN pour corriger le bug a='3+4' au lieu de a= 3+4
- #return obj.nom + " = '" + obj.valeur + "';\n"
- return obj.nom + " = " + obj.valeur + ";\n"
- else:
- return obj.nom + ' = ' + str(obj.valeur) + ';\n'
-
- def generETAPE_NIVEAU(self,obj):
- """
- Cette methode convertit une etape niveau
- en une chaine de caracteres a la syntaxe aplat
- """
- text=''
- if obj.etapes_niveaux == []:
- for etape in obj.etapes:
- text=text+self.generator(etape)+'\n'
- else:
- for etape_niveau in obj.etapes_niveaux:
- text=text+self.generator(etape_niveau)+'\n'
- return text
-
- def gener_etape(self,obj):
- """
- Cette methode est utilise pour convertir les objets etape
- en une chaine de caracteres a la syntaxe aplat
- """
- text=''
- for v in obj.mcListe:
- text=text + self.generator(v)
- if text=='':
- return self.init+'\n'
- else:
- return text
-
- def generETAPE(self,obj):
- """
- Cette methode convertit une etape
- en une chaine de caracteres a la syntaxe aplat
- """
- try:
- sdname= self.generator(obj.sd)
- except:
- sdname='sansnom'
- self.init = sdname + self.sep + obj.nom
- return self.gener_etape(obj)
-
- def generMACRO_ETAPE(self,obj):
- """
- Cette methode convertit une macro-etape
- en une chaine de caracteres a la syntaxe aplat
- """
- try:
- if obj.sd == None:
- self.init = obj.nom
- else:
- sdname= self.generator(obj.sd)
- self.init = sdname + self.sep + obj.nom
- except:
- self.init = 'sansnom' + self.sep + obj.nom
-
- return self.gener_etape(obj)
-
- generPROC_ETAPE = generMACRO_ETAPE
-
- generFORM_ETAPE = generMACRO_ETAPE
-
- def generASSD(self,obj):
- """
- Convertit un objet derive d'ASSD en une chaine de caracteres a la
- syntaxe aplat
- """
- return obj.getName()
-
- def generMCList(self,obj):
- """
- Convertit un objet MCList en une chaine de caracteres a la
- syntaxe aplat
- """
- i=0
- text = ''
- init = self.init + self.sep + obj.nom
- old_init=self.init
- for data in obj.data :
- i=i+1
- self.init = init + self.sep + "occurrence n"+repr(i)
- text = text + self.generator(data)
- self.init=old_init
- return text
-
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en une chaine de caracteres a la
- syntaxe aplat
- """
- if type(obj.valeur) in (tuple,list) :
- # On est en presence d'une liste de valeur
- rep = '('
- for val in obj.valeur:
- #if type(val) == types.InstanceType :
- if isinstance(val,object):
- rep = rep + self.generator(val) +','
- else:
- rep = rep + repr(val)+','
- rep = rep + ')'
- #elif type(obj.valeur) == types.InstanceType :
- elif type(obj.valeur) == object :
- # On est en presence d'une valeur unique de type instance
- rep = self.generator(obj.valeur)
- else :
- # On est en presence d'une valeur unique
- rep = repr(obj.valeur)
- return self.init + self.sep + obj.nom + ' :' + rep + '\n'
-
- def generMCCOMPO(self,obj):
- """
- Convertit un objet MCCOMPO en une chaine de caracteres a la
- syntaxe aplat
- """
- text = ''
- old_init=self.init
- self.init = self.init + self.sep + obj.nom
- for mocle in obj.mcListe :
- text = text + self.generator(mocle)
- self.init=old_init
- return text
-
- generMCFACT=generMCCOMPO
-
- generMCBLOC=generMCCOMPO
-
- generMCNUPLET=generMCCOMPO
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un fichier au format aplat
+
+ L'acquisition et le parcours sont realises par la methode
+ generator.gener(objet_jdc,format)
+
+ L'ecriture du fichier au format ini par appel de la methode
+ generator.writefile(nom_fichier)
+ Ses caracteristiques principales sont exposees dans des attributs
+ de classe :
+ - extensions : qui donne une liste d'extensions de fichier preconisees
+ """
+ # Les extensions de fichier preconisees
+ extensions=('.*',)
+
+ def __init__(self,cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
+ if cr :
+ self.cr=cr
+ else:
+ self.cr=N_CR.CR(debut='CR generateur format aplat pour eficas',
+ fin='fin CR format aplat pour eficas')
+ self.init=''
+ # Le separateur utiise
+ self.sep='//'
+ # Le texte au format aplat est stocke dans l'attribut text
+ self.text=''
+
+ def writefile(self,filename):
+ fp=open(filename,'w')
+ fp.write(self.text)
+ fp.close()
+
+ def gener(self,obj,format='brut',config=None,appliEficas=None):
+ """
+ Retourne une representation du JDC obj sous une forme qui est parametree par format.
+ Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu de generator
+ """
+ liste= self.generator(obj)
+ if format == 'brut':
+ self.text=liste
+ elif format == 'standard':
+ self.text=liste
+ elif format == 'beautifie':
+ self.text=liste
+ else:
+ raise EficasException(tr("Format pas implemente : %s", format))
+ return self.text
+
+ def generator(self,obj):
+ """
+ Cette methode joue un role d'aiguillage en fonction du type de obj
+ On pourrait utiliser les methodes accept et visitxxx a la
+ place (depend des gouts !!!)
+ """
+ # ATTENTION a l'ordre des tests : il peut avoir de l'importance (heritage)
+ if isinstance(obj,PROC_ETAPE):
+ return self.generPROC_ETAPE(obj)
+ elif isinstance(obj,MACRO_ETAPE):
+ return self.generMACRO_ETAPE(obj)
+ elif isinstance(obj,FORM_ETAPE):
+ return self.generFORM_ETAPE(obj)
+ elif isinstance(obj,ETAPE):
+ return self.generETAPE(obj)
+ elif isinstance(obj,MCFACT):
+ return self.generMCFACT(obj)
+ elif isinstance(obj,MCList):
+ return self.generMCList(obj)
+ elif isinstance(obj,MCBLOC):
+ return self.generMCBLOC(obj)
+ elif isinstance(obj,MCSIMP):
+ return self.generMCSIMP(obj)
+ elif isinstance(obj,ASSD):
+ return self.generASSD(obj)
+ elif isinstance(obj,ETAPE_NIVEAU):
+ return self.generETAPE_NIVEAU(obj)
+ elif isinstance(obj,COMMENTAIRE):
+ return self.generCOMMENTAIRE(obj)
+ # Attention doit etre place avant PARAMETRE (raison : heritage)
+ elif isinstance(obj,PARAMETRE_EVAL):
+ return self.generPARAMETRE_EVAL(obj)
+ elif isinstance(obj,PARAMETRE):
+ return self.generPARAMETRE(obj)
+ elif isinstance(obj,EVAL):
+ return self.generEVAL(obj)
+ elif isinstance(obj,COMMANDE_COMM):
+ return self.generCOMMANDE_COMM(obj)
+ elif isinstance(obj,JDC):
+ return self.generJDC(obj)
+ elif isinstance(obj,MCNUPLET):
+ return self.generMCNUPLET(obj)
+ else:
+ raise EficasException(tr("Format non implemente : %s", format))
+
+
+ def generJDC(self,obj):
+ """
+ Cette methode convertit un objet JDC en une chaine de
+ caracteres a la syntaxe aplat
+ """
+ text=''
+ if obj.definition.l_niveaux == ():
+ # Il n'y a pas de niveaux
+ for etape in obj.etapes:
+ text=text+self.generator(etape)+'\n'
+ else:
+ # Il y a des niveaux
+ for etape_niveau in obj.etapes_niveaux:
+ text=text+self.generator(etape_niveau)+'\n'
+ return text
+
+ def generCOMMANDE_COMM(self,obj):
+ """
+ Cette methode convertit un COMMANDE_COMM
+ en une chaine de caracteres a la syntaxe aplat
+ """
+ l_lignes = obj.valeur.split('\n')
+ txt=''
+ for ligne in l_lignes:
+ txt = txt + '##'+ligne+'\n'
+ return txt
+
+ def generEVAL(self,obj):
+ """
+ Cette methode convertit un EVAL
+ en une chaine de caracteres a la syntaxe aplat
+ """
+ return 'EVAL("""'+ obj.valeur +'""")'
+
+ def generCOMMENTAIRE(self,obj):
+ """
+ Cette methode convertit un COMMENTAIRE
+ en une chaine de caracteres a la syntaxe aplat
+ """
+ l_lignes = obj.valeur.split('\n')
+ txt=''
+ for ligne in l_lignes:
+ txt = txt + '#'+ligne+'\n'
+ return txt
+
+ def generPARAMETRE_EVAL(self,obj):
+ """
+ Cette methode convertit un PARAMETRE_EVAL
+ en une chaine de caracteres a la syntaxe aplat
+ """
+ if obj.valeur == None:
+ return obj.nom + ' = None ;\n'
+ else:
+ return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
+
+ def generPARAMETRE(self,obj):
+ """
+ Cette methode convertit un PARAMETRE
+ en une chaine de caracteres a la syntaxe aplat
+ """
+ if type(obj.valeur) == bytes or type(obj.valeur) == str:
+ # PN pour corriger le bug a='3+4' au lieu de a= 3+4
+ #return obj.nom + " = '" + obj.valeur + "';\n"
+ return obj.nom + " = " + obj.valeur + ";\n"
+ else:
+ return obj.nom + ' = ' + str(obj.valeur) + ';\n'
+
+ def generETAPE_NIVEAU(self,obj):
+ """
+ Cette methode convertit une etape niveau
+ en une chaine de caracteres a la syntaxe aplat
+ """
+ text=''
+ if obj.etapes_niveaux == []:
+ for etape in obj.etapes:
+ text=text+self.generator(etape)+'\n'
+ else:
+ for etape_niveau in obj.etapes_niveaux:
+ text=text+self.generator(etape_niveau)+'\n'
+ return text
+
+ def gener_etape(self,obj):
+ """
+ Cette methode est utilise pour convertir les objets etape
+ en une chaine de caracteres a la syntaxe aplat
+ """
+ text=''
+ for v in obj.mcListe:
+ text=text + self.generator(v)
+ if text=='':
+ return self.init+'\n'
+ else:
+ return text
+
+ def generETAPE(self,obj):
+ """
+ Cette methode convertit une etape
+ en une chaine de caracteres a la syntaxe aplat
+ """
+ try:
+ sdname= self.generator(obj.sd)
+ except:
+ sdname='sansnom'
+ self.init = sdname + self.sep + obj.nom
+ return self.gener_etape(obj)
+
+ def generMACRO_ETAPE(self,obj):
+ """
+ Cette methode convertit une macro-etape
+ en une chaine de caracteres a la syntaxe aplat
+ """
+ try:
+ if obj.sd == None:
+ self.init = obj.nom
+ else:
+ sdname= self.generator(obj.sd)
+ self.init = sdname + self.sep + obj.nom
+ except:
+ self.init = 'sansnom' + self.sep + obj.nom
+
+ return self.gener_etape(obj)
+
+ generPROC_ETAPE = generMACRO_ETAPE
+
+ generFORM_ETAPE = generMACRO_ETAPE
+
+ def generASSD(self,obj):
+ """
+ Convertit un objet derive d'ASSD en une chaine de caracteres a la
+ syntaxe aplat
+ """
+ return obj.getName()
+
+ def generMCList(self,obj):
+ """
+ Convertit un objet MCList en une chaine de caracteres a la
+ syntaxe aplat
+ """
+ i=0
+ text = ''
+ init = self.init + self.sep + obj.nom
+ old_init=self.init
+ for data in obj.data :
+ i=i+1
+ self.init = init + self.sep + "occurrence n"+repr(i)
+ text = text + self.generator(data)
+ self.init=old_init
+ return text
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en une chaine de caracteres a la
+ syntaxe aplat
+ """
+ if type(obj.valeur) in (tuple,list) :
+ # On est en presence d'une liste de valeur
+ rep = '('
+ for val in obj.valeur:
+ #if type(val) == types.InstanceType :
+ if isinstance(val,object):
+ rep = rep + self.generator(val) +','
+ else:
+ rep = rep + repr(val)+','
+ rep = rep + ')'
+ #elif type(obj.valeur) == types.InstanceType :
+ elif type(obj.valeur) == object :
+ # On est en presence d'une valeur unique de type instance
+ rep = self.generator(obj.valeur)
+ else :
+ # On est en presence d'une valeur unique
+ rep = repr(obj.valeur)
+ return self.init + self.sep + obj.nom + ' :' + rep + '\n'
+
+ def generMCCOMPO(self,obj):
+ """
+ Convertit un objet MCCOMPO en une chaine de caracteres a la
+ syntaxe aplat
+ """
+ text = ''
+ old_init=self.init
+ self.init = self.init + self.sep + obj.nom
+ for mocle in obj.mcListe :
+ text = text + self.generator(mocle)
+ self.init=old_init
+ return text
+
+ generMCFACT=generMCCOMPO
+
+ generMCBLOC=generMCCOMPO
+
+ generMCNUPLET=generMCCOMPO
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
+ from builtins import str
except : pass
import traceback
from .generator_python import PythonGenerator
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'dico',
- # La factory pour creer une instance du plugin
- 'factory' : DicoGenerator,
- }
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'dico',
+ # La factory pour creer une instance du plugin
+ 'factory' : DicoGenerator,
+ }
class DicoGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format dictionnaire
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format dictionnaire
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None,appliEficas=None):
-
- self.initDico()
-
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
- return self.text
+ def gener(self,obj,format='brut',config=None,appliEficas=None):
+
+ self.initDico()
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+ return self.text
#----------------------------------------------------------------------------------------
# initialisations
#----------------------------------------------------------------------------------------
-
- def initDico(self) :
-
- self.Dico={}
- self.texteDico = ""
+
+ def initDico(self) :
+
+ self.Dico={}
+ self.texteDico = ""
#----------------------------------------------------------------------------------------
# ecriture
#----------------------------------------------------------------------------------------
- def writeDefault(self,fn) :
- fileDico = fn[:fn.rfind(".")] + '.py'
- f = open( str(fileDico), 'w')
- f.write('Dico = '+str(self.Dico))
- f.close()
+ def writeDefault(self,fn) :
+ fileDico = fn[:fn.rfind(".")] + '.py'
+ f = open( str(fileDico), 'w')
+ f.write('Dico = '+str(self.Dico))
+ f.close()
#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
+# analyse de chaque noeud de l'arbre
#----------------------------------------------------------------------------------------
- def generMCSIMP(self,obj) :
+ def generMCSIMP(self,obj) :
"""recuperation de l objet MCSIMP"""
s=PythonGenerator.generMCSIMP(self,obj)
courant=self.Dico
courant[obj.nom]=obj.val
self.texteDico+=obj.nom+ "=" + s[0:-1]+ "\n"
return s
-
from __future__ import absolute_import
try :
- from builtins import str
+ from builtins import str
except : pass
import traceback
from .generator_python import PythonGenerator
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'dicoImbrique',
- # La factory pour creer une instance du plugin
- 'factory' : DicoImbriqueGenerator,
- }
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'dicoImbrique',
+ # La factory pour creer une instance du plugin
+ 'factory' : DicoImbriqueGenerator,
+ }
class DicoImbriqueGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format dictionnaire
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format dictionnaire
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None, appliEficas=None):
-
- self.initDico()
-
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
- #print (self.text)
- print (self.Dico)
- return self.text
+ def gener(self,obj,format='brut',config=None, appliEficas=None):
+
+ self.initDico()
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+ #print (self.text)
+ print (self.Dico)
+ return self.text
#----------------------------------------------------------------------------------------
# initialisations
#----------------------------------------------------------------------------------------
-
- def initDico(self) :
-
- self.Dico={}
- self.DicoDejaLa={}
- self.Entete = ''
+
+ def initDico(self) :
+
+ self.Dico={}
+ self.DicoDejaLa={}
+ self.Entete = ''
#----------------------------------------------------------------------------------------
# ecriture
#----------------------------------------------------------------------------------------
- def writeDefault(self,fn) :
- fileDico = fn[:fn.rfind(".")] + '.py'
- f = open( str(fileDico), 'wb')
+ def writeDefault(self,fn) :
+ fileDico = fn[:fn.rfind(".")] + '.py'
+ f = open( str(fileDico), 'w')
- f.write( self.Entete + "Dico =" + str(self.Dico) )
- f.close()
+ f.write( "Dico =" + str(self.Dico) )
+ #f.write( self.Entete + "Dico =" + str(self.Dico) )
+ f.close()
#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
+# analyse de chaque noeud de l'arbre
#----------------------------------------------------------------------------------------
- def generMCSIMP(self,obj) :
+ def generMCSIMP(self,obj) :
"""recuperation de l objet MCSIMP"""
s=PythonGenerator.generMCSIMP(self,obj)
if obj.isInformation() : return s
- if not obj.isValid() : return s
+ if not obj.isValid() : return s
- liste=obj.getGenealogiePrecise()
+ liste=obj.getGenealogiePrecise()
if obj.etape.nom=='MODIFICATION_CATALOGUE' : return s
nom = obj.etape.nom
-
- if hasattr(obj.etape,'sdnom') and obj.etape.sdnom != None and obj.etape.sdnom != "" :
- nom = nom+ obj.etape.sdnom
+
+ if hasattr(obj.etape,'sdnom') and obj.etape.sdnom != None and obj.etape.sdnom != "" :
+ nom = nom+ obj.etape.sdnom
if not(nom in self.Dico) : dicoCourant={}
else : dicoCourant=self.Dico [nom]
nomFeuille=liste[-1]
if nomFeuille in dicoCourant or nomFeuille in self.DicoDejaLa:
- if nomFeuille in self.DicoDejaLa:
- nomTravail= nomFeuille +'_'+str(self.DicoDejaLa[nomFeuille])
- self.DicoDejaLa[nomFeuille]=self.DicoDejaLa[nomFeuille]+1
- nomFeuille=nomTravail
- else :
- self.DicoDejaLa[nomFeuille]=3
- nom1=nomFeuille +'_1'
- dicoCourant[nom1]= dicoCourant[nomFeuille]
- del dicoCourant[nomFeuille]
- nomFeuille=nomFeuille +'_2'
+ if nomFeuille in self.DicoDejaLa:
+ nomTravail= nomFeuille +'_'+str(self.DicoDejaLa[nomFeuille])
+ self.DicoDejaLa[nomFeuille]=self.DicoDejaLa[nomFeuille]+1
+ nomFeuille=nomTravail
+ else :
+ self.DicoDejaLa[nomFeuille]=3
+ nom1=nomFeuille +'_1'
+ dicoCourant[nom1]= dicoCourant[nomFeuille]
+ del dicoCourant[nomFeuille]
+ nomFeuille=nomFeuille +'_2'
if hasattr(obj.valeur,'nom'): dicoCourant[nomFeuille]=obj.valeur.nom
- else :
- if type(obj.valeur) in (list,tuple):
- try :
+ else :
+ if type(obj.valeur) in (list,tuple):
+ try :
#PNPNPN a remplacer par plus propre
- if obj.definition.validators.typeDesTuples[0] !='R' :
- val=[]
- elt=[]
- for tupleElt in obj.valeur :
- elt=(str(tupleElt[0]),tupleElt[1])
- val.append(elt)
- dicoCourant[nomFeuille]=val
- else :
- dicoCourant[nomFeuille]=obj.valeur
- except :
- dicoCourant[nomFeuille]=obj.valeurFormatee
- #else :dicoCourant[nomFeuille]=obj.valeurFormatee
- else :
- dicoCourant[nomFeuille]=obj.valeurFormatee
- #print nomFeuille, obj.valeurFormatee
+ if obj.definition.validators.typeDesTuples[0] !='R' :
+ val=[]
+ elt=[]
+ for tupleElt in obj.valeur :
+ elt=(str(tupleElt[0]),tupleElt[1])
+ val.append(elt)
+ dicoCourant[nomFeuille]=val
+ else :
+ dicoCourant[nomFeuille]=obj.valeur
+ except :
+ dicoCourant[nomFeuille]=obj.valeurFormatee
+ #else :dicoCourant[nomFeuille]=obj.valeurFormatee
+ else :
+ dicoCourant[nomFeuille]=obj.valeurFormatee
+ #print nomFeuille, obj.valeurFormatee
self.Dico[nom]=dicoCourant
return s
-
-
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient le plugin generateur de fichier au format
+ Ce module contient le plugin generateur de fichier au format
CARMEL3D pour EFICAS.
"""
from __future__ import print_function
from __future__ import absolute_import
try :
- from builtins import str
+ from builtins import str
except : pass
import traceback
from .generator_python import PythonGenerator
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'MAP',
- # La factory pour creer une instance du plugin
- 'factory' : MapGenerator,
- }
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'MAP',
+ # La factory pour creer une instance du plugin
+ 'factory' : MapGenerator,
+ }
class MapGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format py
-
- """
-
- def gener(self,obj,format='brut',config=None,appliEficas=None):
- self.initDico()
- self.text=PythonGenerator.gener(self,obj,format)
- if obj.isValid() :self.genereExeMap()
- return self.text
-
-
- def genereExeMap(self) :
- '''
- Prepare le contenu du fichier de parametres python
- peut ensuite etre obtenu au moyen de la fonction getTubePy().
- '''
- nomSpec="spec_"+self.schema
- self.texteEXE="from map.spec import %s;\n"%nomSpec
- self.texteEXE+="node=%s.new();\n"%nomSpec
- self.texteEXE+="node.getInputData();\n"
- self.texteEXE+="node.setInputData(%s);\n"%self.dictValeur
- self.texteEXE+="node.execute();\n"
- self.texteEXE+="res=node.getOutputData();\n"
-
-
- def initDico(self) :
- if not hasattr(self,'schema') : self.schema=""
- self.dictParam={}
- self.dictValeur={}
-
- def writeDefault(self, fn):
- fileEXE = fn[:fn.rfind(".")] + '.py'
- f = open( str(fileEXE), 'wb')
- f.write( self.texteEXE )
- f.close()
-
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en texte python
- Remplit le dictionnaire des MCSIMP
- """
-
- if obj.getGenealogie()[0][-6:-1]=="_PARA":
- self.dictParam[obj.nom]=obj.valeur
- else :
- self.dictValeur[obj.nom]=obj.valeur
- s=PythonGenerator.generMCSIMP(self,obj)
- return s
-
-
- def generRUN(self,obj,schema):
- if not(obj.isValid()) :
- print ("TODO TODO TODO")
- self.texteEXE=""
- self.schema=schema
- textComm=self.gener(obj)
- return self.texteEXE
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format py
+
+ """
+
+ def gener(self,obj,format='brut',config=None,appliEficas=None):
+ self.initDico()
+ self.text=PythonGenerator.gener(self,obj,format)
+ if obj.isValid() :self.genereExeMap()
+ return self.text
+
+
+ def genereExeMap(self) :
+ '''
+ Prepare le contenu du fichier de parametres python
+ peut ensuite etre obtenu au moyen de la fonction getTubePy().
+ '''
+ nomSpec="spec_"+self.schema
+ self.texteEXE="from map.spec import %s;\n"%nomSpec
+ self.texteEXE+="node=%s.new();\n"%nomSpec
+ self.texteEXE+="node.getInputData();\n"
+ self.texteEXE+="node.setInputData(%s);\n"%self.dictValeur
+ self.texteEXE+="node.execute();\n"
+ self.texteEXE+="res=node.getOutputData();\n"
+
+
+ def initDico(self) :
+ if not hasattr(self,'schema') : self.schema=""
+ self.dictParam={}
+ self.dictValeur={}
+
+ def writeDefault(self, fn):
+ fileEXE = fn[:fn.rfind(".")] + '.py'
+ f = open( str(fileEXE), 'wb')
+ f.write( self.texteEXE )
+ f.close()
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en texte python
+ Remplit le dictionnaire des MCSIMP
+ """
+
+ if obj.getGenealogie()[0][-6:-1]=="_PARA":
+ self.dictParam[obj.nom]=obj.valeur
+ else :
+ self.dictValeur[obj.nom]=obj.valeur
+ s=PythonGenerator.generMCSIMP(self,obj)
+ return s
+
+
+ def generRUN(self,obj,schema):
+ if not(obj.isValid()) :
+ print ("TODO TODO TODO")
+ self.texteEXE=""
+ self.schema=schema
+ textComm=self.gener(obj)
+ return self.texteEXE
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient le plugin generateur de fichier au format
+ Ce module contient le plugin generateur de fichier au format
CARMEL3D pour EFICAS.
"""
from __future__ import print_function
from __future__ import absolute_import
try :
- from builtins import str
+ from builtins import str
except : pass
import traceback
from .generator_python import PythonGenerator
listeCalParName = ('Time' , 'Temperature', 'DoseRate', 'Thickness') #'calculation_parameter_names'
-
-
+
+
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'MAPVp',
- # La factory pour creer une instance du plugin
- 'factory' : MapGenerator,
- }
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'MAPVp',
+ # La factory pour creer une instance du plugin
+ 'factory' : MapGenerator,
+ }
class MapGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format py
-
- """
-
- def gener(self,obj,format='brut',config=None,appliEficas=None):
- self.appliEficas=appliEficas
- self.cata=self.appliEficas.readercata.cata
- self.initDico()
- self.text=PythonGenerator.gener(self,obj,format)
- if obj.isValid() :self.genereTexte(obj)
- return self.text
-
- def initDico(self) :
- self.texteInput = ""
- self.dictParam={}
- self.dictValeur={}
- self.listeEquations=[]
- self.typeEtude = ""
-
-
- def genereTexte(self,obj) :
- print ('genereTexte', self.typeEtude)
- if self.typeEtude == "Calculation" : self.genereCalculation()
-
-
- def generPROC_ETAPE(self,obj):
- s=PythonGenerator.generPROC_ETAPE(self,obj)
- if obj.nom == "Calculation_for_Mechanistic" : print ('hjkhjkh');self.typeEtude="Calculation"
- return s
-
- def genereCalculation(self) :
- '''
- Prepare le contenu du fichier de parametres python
- '''
- self.texteInput = ""
- self.texteInput += self.genereCsv()
- self.texteInput += self.genereCalculationParams()
- self.texteInput += self.txtNomCst
- self.texteInput += self.txtVal
- self.texteInput += self.txtValAct
- self.texteInput += self.txtNomCstNA
- self.texteInput += self.txtValNA
- self.texteInput += self.txtInitName
- self.texteInput += self.txtInitVal
- self.texteInput += self.genereEquations()
- print (self.texteInput)
-
- def writeDefault(self, fn):
- # normalement c_solver_polymer_kinetics_myStudy.input ou myStudy est le nom de l etude
- fileInput = fn[:fn.rfind(".")] + '.input'
- f = open( str(fileInput), 'wb')
- f.write( self.texteInput )
- f.close()
-
-
- def genereCalculationParams(self) :
- txtNom = "calculation_parameter_names = [ "
- txtVal = "calculation_parameters = [ "
- for param in ('Time' , 'Temperature', 'DoseRate', 'Thickness') :
- if param in self.dictValeur.keys() :
- txtNom += "'"+param + "', "
- txtVal += str(self.dictValeur[param]) + ", "
- # on enleve les dernieres , et on ferme
- txtNom = txtNom[0:-2]
- txtNom += "]\n"
- txtVal = txtVal[0:-2]
- txtVal += "]\n"
- txt = txtNom + txtVal
- return txt
-
- def genereEquations(self) :
- txt="equation =["
- index=0
- TechnicalUse = self.dictValeur['TechnicalUse']
- ModelName = self.dictValeur['ModelName']
- for param in self.listInitialParameters:
- print ('*******************************************')
- print (' je traite ', param , 'index : ', index)
- trouveParam=False
-
- if index != 0 : txtParam = 'Dy[j*5 + '+str(index)+ '] = '
- else : txtParam = 'Dy[j*5] = '
-
- for equation in self.listeEquations :
- if param in (self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation].keys()):
- print ('____________ trouve : ', param , 'in ', equation, ' ', self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param])
- trouveParam = True
- if self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param][0] == '-' :
- txtParam += ' ' + self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param]
- else :
- if index != 0 :
- txtParam += ' + ' + self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param]
- else :
- txtParam += self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param]
- print (' txtParam intermediaire ', txtParam)
-
- if trouveParam :
- txtParam = txtParam + ", "
- txt += txtParam
- index = index+1
- print (txtParam)
- print ('fin param', param, 'trouve ', trouveParam, '___________________________')
- print ('*************************************************')
- print (' ')
- print ('_________________fin for')
- txt=txt[0:-3]
- txt+="]\n"
- return txt
-
- def genereCsv(self) :
- txt = 'study_name = ' +self.dictValeur['SimulationName'] + "\n"
- txt += 'csv_output_file_name = ' + self.dictValeur['OutPutFolder'] + '/c_solver_stiff_ode_1d_' + self.dictValeur['SimulationName']+ '.csv\n'
- return txt
-
-
- def generMCList(self,obj):
- s=PythonGenerator.generMCList(self,obj)
- if obj.nom == 'ConstantesArrhenius' :
- self.txtNomCst = "Arrhenius_Name = [ "
- self.txtVal = "Arrhenius_A = [ "
- self.txtValAct = "Arrhenius_Ea = [ "
- for objFils in obj.data:
- for mc in objFils.mcListe :
- self.txtNomCst += "'" + mc.nom + "', "
- self.txtVal += str(mc.valeur[0]) + ", "
- self.txtValAct += str(mc.valeur[1]) + ", "
- self.txtNomCst = self.txtNomCst[0:-2]
- self.txtVal = self.txtVal[0:-2]
- self.txtValAct = self.txtValAct [0:-2]
- self.txtNomCst += ']\n'
- self.txtVal += ']\n'
- self.txtValAct += ']\n'
-
- if obj.nom == 'ConstantesNonArrhenius' :
- self.txtNomCstNA = "non_Arrhenius_coefs_names = [ "
- self.txtValNA = "non_Arrhenius_coefs = [ "
- for objFils in obj.data:
- for mc in objFils.mcListe :
- self.txtNomCstNA += "'" + mc.nom + "', "
- self.txtValNA += str(mc.valeur) + ", "
- self.txtNomCstNA = self.txtNomCstNA[0:-2]
- self.txtValNA = self.txtValNA[0:-2]
- self.txtNomCstNA += ']\n'
- self.txtValNA += ']\n'
-
- if obj.nom == 'InitialParameters' :
- self.listInitialParameters =[]
- self.txtInitName = "initial_Value_names = [ "
- self.txtInitVal = "initial_Values = [ "
- for objFils in obj.data:
- for mc in objFils.mcListe :
- self.txtInitName += "'" + mc.nom + "', "
- self.txtInitVal += str(mc.valeur) + ", "
- self.listInitialParameters.append(mc.nom)
- self.txtInitName = self.txtInitName[0:-2]
- self.txtInitVal = self.txtInitVal[0:-2]
- self.txtInitName += ']\n'
- self.txtInitVal += ']\n'
-
- if obj.nom in( 'initiation','propagation','termination','stabilization') :
- for o in obj :
- for mc in o.mcListe :
- nom=mc.nom.replace (' ','').replace ('+','_').replace ('-','_').replace ('>','_').replace('(','').replace(')','').replace('*','').replace('[','').replace(']','')
- nom=obj.nom+'_'+nom
- self.listeEquations.append(nom )
- return s
-
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en texte python
- Remplit le dictionnaire des MCSIMP
- """
- s=PythonGenerator.generMCSIMP(self,obj)
- if obj.nom=='Consigne' : return s
-
- if obj.getGenealogie()[0][-6:-1]=="_PARA":
- self.dictParam[obj.nom]=obj.valeur
- else :
- self.dictValeur[obj.nom]=obj.valeur
- return s
-
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format py
+
+ """
+
+ def gener(self,obj,format='brut',config=None,appliEficas=None):
+ self.appliEficas=appliEficas
+ self.cata=self.appliEficas.readercata.cata
+ self.initDico()
+ self.text=PythonGenerator.gener(self,obj,format)
+ if obj.isValid() :self.genereTexte(obj)
+ return self.text
+
+ def initDico(self) :
+ self.texteInput = ""
+ self.dictParam={}
+ self.dictValeur={}
+ self.listeEquations=[]
+ self.typeEtude = ""
+
+
+ def genereTexte(self,obj) :
+ print ('genereTexte', self.typeEtude)
+ if self.typeEtude == "Calculation" : self.genereCalculation()
+
+
+ def generPROC_ETAPE(self,obj):
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ if obj.nom == "Calculation_for_Mechanistic" : print ('hjkhjkh');self.typeEtude="Calculation"
+ return s
+
+ def genereCalculation(self) :
+ '''
+ Prepare le contenu du fichier de parametres python
+ '''
+ self.texteInput = ""
+ self.texteInput += self.genereCsv()
+ self.texteInput += self.genereCalculationParams()
+ self.texteInput += self.txtNomCst
+ self.texteInput += self.txtVal
+ self.texteInput += self.txtValAct
+ self.texteInput += self.txtNomCstNA
+ self.texteInput += self.txtValNA
+ self.texteInput += self.txtInitName
+ self.texteInput += self.txtInitVal
+ self.texteInput += self.genereEquations()
+ print (self.texteInput)
+
+ def writeDefault(self, fn):
+ # normalement c_solver_polymer_kinetics_myStudy.input ou myStudy est le nom de l etude
+ fileInput = fn[:fn.rfind(".")] + '.input'
+ f = open( str(fileInput), 'wb')
+ f.write( self.texteInput )
+ f.close()
+
+
+ def genereCalculationParams(self) :
+ txtNom = "calculation_parameter_names = [ "
+ txtVal = "calculation_parameters = [ "
+ for param in ('Time' , 'Temperature', 'DoseRate', 'Thickness') :
+ if param in self.dictValeur.keys() :
+ txtNom += "'"+param + "', "
+ txtVal += str(self.dictValeur[param]) + ", "
+ # on enleve les dernieres , et on ferme
+ txtNom = txtNom[0:-2]
+ txtNom += "]\n"
+ txtVal = txtVal[0:-2]
+ txtVal += "]\n"
+ txt = txtNom + txtVal
+ return txt
+
+ def genereEquations(self) :
+ txt="equation =["
+ index=0
+ TechnicalUse = self.dictValeur['TechnicalUse']
+ ModelName = self.dictValeur['ModelName']
+ for param in self.listInitialParameters:
+ print ('*******************************************')
+ print (' je traite ', param , 'index : ', index)
+ trouveParam=False
+
+ if index != 0 : txtParam = 'Dy[j*5 + '+str(index)+ '] = '
+ else : txtParam = 'Dy[j*5] = '
+
+ for equation in self.listeEquations :
+ if param in (self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation].keys()):
+ print ('____________ trouve : ', param , 'in ', equation, ' ', self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param])
+ trouveParam = True
+ if self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param][0] == '-' :
+ txtParam += ' ' + self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param]
+ else :
+ if index != 0 :
+ txtParam += ' + ' + self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param]
+ else :
+ txtParam += self.cata.dicoEquations[TechnicalUse][ModelName]['equa_diff'][equation][param]
+ print (' txtParam intermediaire ', txtParam)
+
+ if trouveParam :
+ txtParam = txtParam + ", "
+ txt += txtParam
+ index = index+1
+ print (txtParam)
+ print ('fin param', param, 'trouve ', trouveParam, '___________________________')
+ print ('*************************************************')
+ print (' ')
+ print ('_________________fin for')
+ txt=txt[0:-3]
+ txt+="]\n"
+ return txt
+
+ def genereCsv(self) :
+ txt = 'study_name = ' +self.dictValeur['SimulationName'] + "\n"
+ txt += 'csv_output_file_name = ' + self.dictValeur['OutPutFolder'] + '/c_solver_stiff_ode_1d_' + self.dictValeur['SimulationName']+ '.csv\n'
+ return txt
+
+
+ def generMCList(self,obj):
+ s=PythonGenerator.generMCList(self,obj)
+ if obj.nom == 'ConstantesArrhenius' :
+ self.txtNomCst = "Arrhenius_Name = [ "
+ self.txtVal = "Arrhenius_A = [ "
+ self.txtValAct = "Arrhenius_Ea = [ "
+ for objFils in obj.data:
+ for mc in objFils.mcListe :
+ self.txtNomCst += "'" + mc.nom + "', "
+ self.txtVal += str(mc.valeur[0]) + ", "
+ self.txtValAct += str(mc.valeur[1]) + ", "
+ self.txtNomCst = self.txtNomCst[0:-2]
+ self.txtVal = self.txtVal[0:-2]
+ self.txtValAct = self.txtValAct [0:-2]
+ self.txtNomCst += ']\n'
+ self.txtVal += ']\n'
+ self.txtValAct += ']\n'
+
+ if obj.nom == 'ConstantesNonArrhenius' :
+ self.txtNomCstNA = "non_Arrhenius_coefs_names = [ "
+ self.txtValNA = "non_Arrhenius_coefs = [ "
+ for objFils in obj.data:
+ for mc in objFils.mcListe :
+ self.txtNomCstNA += "'" + mc.nom + "', "
+ self.txtValNA += str(mc.valeur) + ", "
+ self.txtNomCstNA = self.txtNomCstNA[0:-2]
+ self.txtValNA = self.txtValNA[0:-2]
+ self.txtNomCstNA += ']\n'
+ self.txtValNA += ']\n'
+
+ if obj.nom == 'InitialParameters' :
+ self.listInitialParameters =[]
+ self.txtInitName = "initial_Value_names = [ "
+ self.txtInitVal = "initial_Values = [ "
+ for objFils in obj.data:
+ for mc in objFils.mcListe :
+ self.txtInitName += "'" + mc.nom + "', "
+ self.txtInitVal += str(mc.valeur) + ", "
+ self.listInitialParameters.append(mc.nom)
+ self.txtInitName = self.txtInitName[0:-2]
+ self.txtInitVal = self.txtInitVal[0:-2]
+ self.txtInitName += ']\n'
+ self.txtInitVal += ']\n'
+
+ if obj.nom in( 'initiation','propagation','termination','stabilization') :
+ for o in obj :
+ for mc in o.mcListe :
+ nom=mc.nom.replace (' ','').replace ('+','_').replace ('-','_').replace ('>','_').replace('(','').replace(')','').replace('*','').replace('[','').replace(']','')
+ nom=obj.nom+'_'+nom
+ self.listeEquations.append(nom )
+ return s
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en texte python
+ Remplit le dictionnaire des MCSIMP
+ """
+ s=PythonGenerator.generMCSIMP(self,obj)
+ if obj.nom=='Consigne' : return s
+
+ if obj.getGenealogie()[0][-6:-1]=="_PARA":
+ self.dictParam[obj.nom]=obj.valeur
+ else :
+ self.dictValeur[obj.nom]=obj.valeur
+ return s
# Modules Python
from __future__ import absolute_import
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except : pass
import os, sys, types, re
class ModificationGenerator(object):
def generTexteModif(self,obj):
- texteModification=""
- for t in list(obj.editor.dicoNouveauxMC.keys()) :
- # 'ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args
- fonction,Etape,Genea,nomSIMP,typeSIMP,arguments = obj.editor.dicoNouveauxMC[t]
- texteModification += "MODIFICATION_CATALOGUE(Fonction = '" + str(fonction)+ "',\n"
- texteModification += " Etape = '" + str(Etape) + "',\n"
- texteModification += " Genea = " + str(Genea) + ",\n"
- texteModification += " NomSIMP = '" + str(nomSIMP) + "',\n"
- texteModification += " TypeSIMP = '" + str(typeSIMP)+ "',\n"
- texteModification += " PhraseArguments = " +'"' + str(arguments)+ '"'+ ",);\n"
-
+ texteModification=""
+ for t in list(obj.editor.dicoNouveauxMC.keys()) :
+ # 'ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args
+ fonction,Etape,Genea,nomSIMP,typeSIMP,arguments = obj.editor.dicoNouveauxMC[t]
+ texteModification += "MODIFICATION_CATALOGUE(Fonction = '" + str(fonction)+ "',\n"
+ texteModification += " Etape = '" + str(Etape) + "',\n"
+ texteModification += " Genea = " + str(Genea) + ",\n"
+ texteModification += " NomSIMP = '" + str(nomSIMP) + "',\n"
+ texteModification += " TypeSIMP = '" + str(typeSIMP)+ "',\n"
+ texteModification += " PhraseArguments = " +'"' + str(arguments)+ '"'+ ",);\n"
- return texteModification
+
+ return texteModification
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient le plugin generateur de fichier au format
+ Ce module contient le plugin generateur de fichier au format
python pour EFICAS.
"""
from __future__ import absolute_import
try :
- from builtins import str
- from builtins import object
- from builtins import range
+ from builtins import str
+ from builtins import object
+ from builtins import range
except : pass
import traceback
import Accas
import Extensions
from Extensions.parametre import ITEM_PARAMETRE
-from .Formatage import Formatage
+from .Formatage import Formatage
from .Formatage import FormatageLigne
from Extensions.param2 import Formula
from Extensions.eficas_exception import EficasException
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'python',
- # La factory pour creer une instance du plugin
- 'factory' : PythonGenerator,
- }
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'python',
+ # La factory pour creer une instance du plugin
+ 'factory' : PythonGenerator,
+ }
class PythonGenerator(object):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un fichier au format python
-
- L'acquisition et le parcours sont realises par la methode
- generator.gener(objet_jdc,format)
-
- L'ecriture du fichier au format ini par appel de la methode
- generator.writefile(nom_fichier)
-
- Ses caracteristiques principales sont exposees dans des attributs
- de classe :
- - extensions : qui donne une liste d'extensions de fichier preconisees
-
- """
- # Les extensions de fichier preconisees
- extensions=('.comm',)
-
- def __init__(self,cr=None):
- # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
- if cr :
- self.cr=cr
- else:
- self.cr=N_CR.CR(debut='CR generateur format python pour python',
- fin='fin CR format python pour python')
- # Le texte au format python est stocke dans l'attribut text
- self.text=''
- self.appliEficas=None
-
- def writefile(self,filename):
- fp=open(filename,'w')
- fp.write(self.text)
- fp.close()
-
- def gener(self,obj,format='brut',config=None,appliEficas=None):
- """
- Retourne une representation du JDC obj sous une
- forme qui est parametree par format.
- Si format vaut 'brut', retourne une liste de listes de ...
- Si format vaut 'standard', retourne un texte obtenu par concatenation de la liste
- Si format vaut 'beautifie', retourne le meme texte beautifie
- """
- import logging
- if obj == None :
- print ('appel a gener avec None')
- return
- self.appliEficas=appliEficas
- liste= self.generator(obj)
- #format='standard'
- if format == 'brut':
- self.text=liste
- elif format == 'standard':
- self.text=''.join(liste)
- elif format == 'beautifie':
- jdc_formate = Formatage(liste,mode='.py')
- #import cProfile, pstats, StringIO
- #pr = cProfile.Profile()
- #pr.enable()
- self.text=jdc_formate.formateJdc()
- #pr.disable()
- #s = StringIO.StringIO()
- #sortby = 'cumulative'
- #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
- #ps.print_stats()
- #print (s.getValue())
-
- elif format == 'Ligne':
- jdc_formate = FormatageLigne(liste,mode='.py')
- self.text=jdc_formate.formateJdc()
- else:
- raise EficasException(tr("Format non implemente ") +format)
- return self.text
-
- def generator(self,obj):
- """
- Cette methode joue un role d'aiguillage en fonction du type de obj
- On pourrait utiliser les methodes accept et visitxxx a la
- place (depend des gouts !!!)
- """
- # ATTENTION a l'ordre des tests : il peut avoir de l'importance (heritage)
- if isinstance(obj,Accas.PROC_ETAPE):
- return self.generPROC_ETAPE(obj)
- # Attention doit etre place avant MACRO (raison : heritage)
- elif isinstance(obj,Accas.FORM_ETAPE):
- return self.generFORM_ETAPE(obj)
- elif isinstance(obj,Accas.MACRO_ETAPE):
- return self.generMACRO_ETAPE(obj)
- elif isinstance(obj,Accas.ETAPE):
- return self.generETAPE(obj)
- elif isinstance(obj,Accas.MCFACT):
- return self.generMCFACT(obj)
- elif isinstance(obj,Accas.MCList):
- return self.generMCList(obj)
- elif isinstance(obj,Accas.MCBLOC):
- return self.generMCBLOC(obj)
- elif isinstance(obj,Accas.MCSIMP):
- return self.generMCSIMP(obj)
- elif isinstance(obj,Accas.ASSD):
- return self.generASSD(obj)
- elif isinstance(obj,Accas.ETAPE_NIVEAU):
- return self.generETAPE_NIVEAU(obj)
- elif isinstance(obj,Accas.COMMENTAIRE):
- return self.generCOMMENTAIRE(obj)
- # Attention doit etre place avant PARAMETRE (raison : heritage)
- elif isinstance(obj,Accas.PARAMETRE_EVAL):
- return self.generPARAMETRE_EVAL(obj)
- elif isinstance(obj,Accas.PARAMETRE):
- return self.generPARAMETRE(obj)
- elif isinstance(obj,Accas.EVAL):
- return self.generEVAL(obj)
- elif isinstance(obj,Accas.COMMANDE_COMM):
- return self.generCOMMANDE_COMM(obj)
- elif isinstance(obj,Accas.JDC):
- return self.generJDC(obj)
- elif isinstance(obj,Accas.MCNUPLET):
- return self.generMCNUPLET(obj)
- elif isinstance(obj,ITEM_PARAMETRE):
- return self.generITEM_PARAMETRE(obj)
- elif isinstance(obj,Formula):
- return self.generFormula(obj)
- else:
- raise EficasException(tr("Type d'objet non prevu") +obj)
-
- def generJDC(self,obj):
- """
- Cette methode convertit un objet JDC en une liste de chaines de
- caracteres a la syntaxe python
- """
- l=[]
-
- #print ('generJDC', obj.sdsDict)
- for objRef in obj.sdsDict :
- if (isinstance(obj.sdsDict[objRef],Accas.UserASSD)) or (isinstance(obj.sdsDict[objRef],Accas.UserASSDMultiple)):
- l.append(self.generUserASSD(obj.sdsDict[objRef]))
- if obj.definition.l_niveaux == ():
- # Il n'y a pas de niveaux
- for etape in obj.etapes:
- l.append(self.generator(etape))
- else:
- # Il y a des niveaux
- for etape_niveau in obj.etapes_niveaux:
- l.extend(self.generator(etape_niveau))
- if l != [] :
- # Si au moins une etape, on ajoute le retour chariot sur la derniere etape
- if type(l[-1])==list:
- l[-1][-1] = l[-1][-1]+'\n'
- elif type(l[-1])==bytes or type(l[-1])==str:
- l[-1] = l[-1]+'\n'
- return l
-
- def generUserASSD(self,obj):
- classeName = obj.__class__.__name__
- if obj.valeur == None :
- texte = obj.nom + '=' + classeName + '()'
- return texte
-
- def generMCNUPLET(self,obj):
- """
- Methode generant une representation de self permettant son ecriture
- dans le format python
- """
- l=[]
- l.append('(')
- for v in obj.mcListe:
- text = re.sub(".*=","",self.generator(v))
- l.append(text)
- l.append('),')
- return l
-
- def generCOMMANDE_COMM(self,obj):
- """
- Cette methode convertit un COMMANDE_COMM
- en une liste de chaines de caracteres a la syntaxe python
- """
- l_lignes = obj.valeur.split('\n')
- txt=''
- for ligne in l_lignes:
- txt = txt + '##'+ligne+'\n'
- return txt
-
- def generEVAL(self,obj):
- """
- Cette methode convertit un EVAL
- en une liste de chaines de caracteres a la syntaxe python
- """
- return 'EVAL("""'+ obj.valeur +'""")'
-
- def generCOMMENTAIRE(self,obj):
- """
- Cette methode convertit un COMMENTAIRE
- en une liste de chaines de caracteres a la syntaxe python
- """
- # modification pour repondre a la demande de C. Durand, d'eviter
- # l'ajout systematique d'un diese, a la suite du commentaire
- # Dans la chaine de caracteres obj.valeur, on supprime le dernier
- # saut de ligne
- sans_saut = re.sub("\n$","",obj.valeur)
- l_lignes = sans_saut.split('\n')
- txt=''
- i=1
- for ligne in l_lignes:
- txt = txt + '#'+ligne+'\n'
-
- # suppression du dernier saut de ligne
- #txt = re.sub("\n$","",txt)
- # on ajoute un saut de ligne avant
- pattern=re.compile(" ?\#")
- m=pattern.match(txt)
- if m:
- txt="\n"+txt
- return txt
-
- def generPARAMETRE_EVAL(self,obj):
- """
- Cette methode convertit un PARAMETRE_EVAL
- en une liste de chaines de caracteres a la syntaxe python
- """
- if obj.valeur == None:
- return obj.nom + ' = None ;\n'
- else:
- return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
-
- def generITEM_PARAMETRE(self,obj):
- return repr(obj)
-
- def generFormula(self,obj):
- #return repr(obj)
- return str(obj)
-
- def generPARAMETRE(self,obj):
- """
- Cette methode convertit un PARAMETRE
- en une liste de chaines de caracteres a la syntaxe python
- """
- return repr(obj) + ";\n"
-
- def generETAPE_NIVEAU(self,obj):
- """
- Cette methode convertit une etape niveau
- en une liste de chaines de caracteres a la syntaxe python
- """
- l=[]
- if obj.etapes_niveaux == []:
- for etape in obj.etapes:
- l.append(self.generator(etape))
- else:
- for etape_niveau in obj.etapes_niveaux:
- l.extend(self.generator(etape_niveau))
- return l
-
- def generETAPE(self,obj):
- """
- Cette methode convertit une etape
- en une liste de chaines de caracteres a la syntaxe python
- """
- try:
- sdname= self.generator(obj.sd)
- if sdname.find('SD_') != -1: sdname='sansnom'
- except:
- sdname='sansnom'
- l=[]
- label=sdname + '='+obj.definition.nom+'('
- l.append(label)
- if obj.reuse != None :
- str = 'reuse ='+ self.generator(obj.reuse) + ','
- l.append(str)
- for v in obj.mcListe:
- if isinstance(v,Accas.MCBLOC) :
- liste=self.generator(v)
- for mocle in liste :
- l.append(mocle)
- elif isinstance(v,Accas.MCSIMP) :
- text=self.generator(v)
- l.append(v.nom+'='+text)
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un fichier au format python
+
+ L'acquisition et le parcours sont realises par la methode
+ generator.gener(objet_jdc,format)
+
+ L'ecriture du fichier au format ini par appel de la methode
+ generator.writefile(nom_fichier)
+
+ Ses caracteristiques principales sont exposees dans des attributs
+ de classe :
+ - extensions : qui donne une liste d'extensions de fichier preconisees
+
+ """
+ # Les extensions de fichier preconisees
+ extensions=('.comm',)
+
+ def __init__(self,cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
+ if cr :
+ self.cr=cr
else:
- # MCFACT ou MCList
- liste=self.generator(v)
- liste[0]=v.nom+'='+liste[0]
- l.append(liste)
- if len(l) == 1:
- l[0]=label+');'
- else :
- l.append(');')
- return l
+ self.cr=N_CR.CR(debut='CR generateur format python pour python',
+ fin='fin CR format python pour python')
+ # Le texte au format python est stocke dans l'attribut text
+ self.text=''
+ self.appliEficas=None
+
+ def writefile(self,filename):
+ fp=open(filename,'w')
+ fp.write(self.text)
+ fp.close()
+
+ def gener(self,obj,format='brut',config=None,appliEficas=None):
+ """
+ Retourne une representation du JDC obj sous une
+ forme qui est parametree par format.
+ Si format vaut 'brut', retourne une liste de listes de ...
+ Si format vaut 'standard', retourne un texte obtenu par concatenation de la liste
+ Si format vaut 'beautifie', retourne le meme texte beautifie
+ """
+ import logging
+ if obj == None :
+ print ('appel a gener avec None')
+ return
+ self.appliEficas=appliEficas
+ liste= self.generator(obj)
+ #format='standard'
+ if format == 'brut':
+ self.text=liste
+ elif format == 'standard':
+ self.text=''.join(liste)
+ elif format == 'beautifie':
+ jdc_formate = Formatage(liste,mode='.py')
+ #import cProfile, pstats, StringIO
+ #pr = cProfile.Profile()
+ #pr.enable()
+ self.text=jdc_formate.formateJdc()
+ #pr.disable()
+ #s = StringIO.StringIO()
+ #sortby = 'cumulative'
+ #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
+ #ps.print_stats()
+ #print (s.getValue())
+
+ elif format == 'Ligne':
+ jdc_formate = FormatageLigne(liste,mode='.py')
+ self.text=jdc_formate.formateJdc()
+ else:
+ raise EficasException(tr("Format non implemente ") +format)
+ return self.text
+
+ def generator(self,obj):
+ """
+ Cette methode joue un role d'aiguillage en fonction du type de obj
+ On pourrait utiliser les methodes accept et visitxxx a la
+ place (depend des gouts !!!)
+ """
+ # ATTENTION a l'ordre des tests : il peut avoir de l'importance (heritage)
+ if isinstance(obj,Accas.PROC_ETAPE):
+ return self.generPROC_ETAPE(obj)
+ # Attention doit etre place avant MACRO (raison : heritage)
+ elif isinstance(obj,Accas.FORM_ETAPE):
+ return self.generFORM_ETAPE(obj)
+ elif isinstance(obj,Accas.MACRO_ETAPE):
+ return self.generMACRO_ETAPE(obj)
+ elif isinstance(obj,Accas.ETAPE):
+ return self.generETAPE(obj)
+ elif isinstance(obj,Accas.MCFACT):
+ return self.generMCFACT(obj)
+ elif isinstance(obj,Accas.MCList):
+ return self.generMCList(obj)
+ elif isinstance(obj,Accas.MCBLOC):
+ return self.generMCBLOC(obj)
+ elif isinstance(obj,Accas.MCSIMP):
+ return self.generMCSIMP(obj)
+ elif isinstance(obj,Accas.ASSD):
+ return self.generASSD(obj)
+ elif isinstance(obj,Accas.ETAPE_NIVEAU):
+ return self.generETAPE_NIVEAU(obj)
+ elif isinstance(obj,Accas.COMMENTAIRE):
+ return self.generCOMMENTAIRE(obj)
+ # Attention doit etre place avant PARAMETRE (raison : heritage)
+ elif isinstance(obj,Accas.PARAMETRE_EVAL):
+ return self.generPARAMETRE_EVAL(obj)
+ elif isinstance(obj,Accas.PARAMETRE):
+ return self.generPARAMETRE(obj)
+ elif isinstance(obj,Accas.EVAL):
+ return self.generEVAL(obj)
+ elif isinstance(obj,Accas.COMMANDE_COMM):
+ return self.generCOMMANDE_COMM(obj)
+ elif isinstance(obj,Accas.JDC):
+ return self.generJDC(obj)
+ elif isinstance(obj,Accas.MCNUPLET):
+ return self.generMCNUPLET(obj)
+ elif isinstance(obj,ITEM_PARAMETRE):
+ return self.generITEM_PARAMETRE(obj)
+ elif isinstance(obj,Formula):
+ return self.generFormula(obj)
+ else:
+ raise EficasException(tr("Type d'objet non prevu") +obj)
+
+ def generJDC(self,obj):
+ """
+ Cette methode convertit un objet JDC en une liste de chaines de
+ caracteres a la syntaxe python
+ """
+ l=[]
+
+ #print ('generJDC', obj.sdsDict)
+ for objRef in obj.sdsDict :
+ if (isinstance(obj.sdsDict[objRef],Accas.UserASSD)) or (isinstance(obj.sdsDict[objRef],Accas.UserASSDMultiple)):
+ l.append(self.generUserASSD(obj.sdsDict[objRef]))
+ if obj.definition.l_niveaux == ():
+ # Il n'y a pas de niveaux
+ for etape in obj.etapes:
+ l.append(self.generator(etape))
+ else:
+ # Il y a des niveaux
+ for etape_niveau in obj.etapes_niveaux:
+ l.extend(self.generator(etape_niveau))
+ if l != [] :
+ # Si au moins une etape, on ajoute le retour chariot sur la derniere etape
+ if type(l[-1])==list:
+ l[-1][-1] = l[-1][-1]+'\n'
+ elif type(l[-1])==bytes or type(l[-1])==str:
+ l[-1] = l[-1]+'\n'
+ return l
+
+ def generUserASSD(self,obj):
+ classeName = obj.__class__.__name__
+ if obj.valeur == None :
+ texte = obj.nom + '=' + classeName + '()'
+ return texte
+
+ def generMCNUPLET(self,obj):
+ """
+ Methode generant une representation de self permettant son ecriture
+ dans le format python
+ """
+ l=[]
+ l.append('(')
+ for v in obj.mcListe:
+ text = re.sub(".*=","",self.generator(v))
+ l.append(text)
+ l.append('),')
+ return l
+
+ def generCOMMANDE_COMM(self,obj):
+ """
+ Cette methode convertit un COMMANDE_COMM
+ en une liste de chaines de caracteres a la syntaxe python
+ """
+ l_lignes = obj.valeur.split('\n')
+ txt=''
+ for ligne in l_lignes:
+ txt = txt + '##'+ligne+'\n'
+ return txt
+
+ def generEVAL(self,obj):
+ """
+ Cette methode convertit un EVAL
+ en une liste de chaines de caracteres a la syntaxe python
+ """
+ return 'EVAL("""'+ obj.valeur +'""")'
+
+ def generCOMMENTAIRE(self,obj):
+ """
+ Cette methode convertit un COMMENTAIRE
+ en une liste de chaines de caracteres a la syntaxe python
+ """
+ # modification pour repondre a la demande de C. Durand, d'eviter
+ # l'ajout systematique d'un diese, a la suite du commentaire
+ # Dans la chaine de caracteres obj.valeur, on supprime le dernier
+ # saut de ligne
+ sans_saut = re.sub("\n$","",obj.valeur)
+ l_lignes = sans_saut.split('\n')
+ txt=''
+ i=1
+ for ligne in l_lignes:
+ txt = txt + '#'+ligne+'\n'
+
+ # suppression du dernier saut de ligne
+ #txt = re.sub("\n$","",txt)
+ # on ajoute un saut de ligne avant
+ pattern=re.compile(" ?\#")
+ m=pattern.match(txt)
+ if m:
+ txt="\n"+txt
+ return txt
+
+ def generPARAMETRE_EVAL(self,obj):
+ """
+ Cette methode convertit un PARAMETRE_EVAL
+ en une liste de chaines de caracteres a la syntaxe python
+ """
+ if obj.valeur == None:
+ return obj.nom + ' = None ;\n'
+ else:
+ return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
+
+ def generITEM_PARAMETRE(self,obj):
+ return repr(obj)
+
+ def generFormula(self,obj):
+ #return repr(obj)
+ return str(obj)
+
+ def generPARAMETRE(self,obj):
+ """
+ Cette methode convertit un PARAMETRE
+ en une liste de chaines de caracteres a la syntaxe python
+ """
+ return repr(obj) + ";\n"
+
+ def generETAPE_NIVEAU(self,obj):
+ """
+ Cette methode convertit une etape niveau
+ en une liste de chaines de caracteres a la syntaxe python
+ """
+ l=[]
+ if obj.etapes_niveaux == []:
+ for etape in obj.etapes:
+ l.append(self.generator(etape))
+ else:
+ for etape_niveau in obj.etapes_niveaux:
+ l.extend(self.generator(etape_niveau))
+ return l
+
+ def generETAPE(self,obj):
+ """
+ Cette methode convertit une etape
+ en une liste de chaines de caracteres a la syntaxe python
+ """
+ try:
+ sdname= self.generator(obj.sd)
+ if sdname.find('SD_') != -1: sdname='sansnom'
+ except:
+ sdname='sansnom'
+ l=[]
+ label=sdname + '='+obj.definition.nom+'('
+ l.append(label)
+ if obj.reuse != None :
+ str = 'reuse ='+ self.generator(obj.reuse) + ','
+ l.append(str)
+ for v in obj.mcListe:
+ if isinstance(v,Accas.MCBLOC) :
+ liste=self.generator(v)
+ for mocle in liste :
+ l.append(mocle)
+ elif isinstance(v,Accas.MCSIMP) :
+ text=self.generator(v)
+ l.append(v.nom+'='+text)
+ else:
+ # MCFACT ou MCList
+ liste=self.generator(v)
+ liste[0]=v.nom+'='+liste[0]
+ l.append(liste)
+ if len(l) == 1:
+ l[0]=label+');'
+ else :
+ l.append(');')
+ return l
- def generFORM_ETAPE(self,obj):
+ def generFORM_ETAPE(self,obj):
"""
Methode particuliere pour les objets de type FORMULE
"""
l.append(');')
return l
- def generMACRO_ETAPE(self,obj):
- """
- Cette methode convertit une macro-etape
- en une liste de chaines de caracteres a la syntaxe python
- """
- try:
- if obj.sd == None:
- sdname=''
- else:
- sdname= self.generator(obj.sd)+'='
- if sdname.find('SD_') != -1: sdname=''
- except:
- sdname='sansnom='
- l=[]
- label = sdname + obj.definition.nom+'('
- l.append(label)
- if obj.reuse != None:
- # XXX faut il la virgule ou pas ????
- str = "reuse =" + self.generator(obj.reuse) + ','
- l.append(str)
- for v in obj.mcListe:
- if isinstance(v,Accas.MCBLOC) :
- liste=self.generator(v)
- for mocle in liste :
- l.append(mocle)
- elif isinstance(v,Accas.MCSIMP) :
- text=self.generator(v)
- l.append(v.nom+'='+text)
- else:
- # MCFACT ou MCList
- liste=self.generator(v)
- liste[0]=v.nom+'='+liste[0]
- l.append(liste)
-
- if len(l) == 1:
- l[0]=label+');'
- else :
- l.append(');')
- return l
-
- def generPROC_ETAPE(self,obj):
- """
- Cette methode convertit une PROC etape
- en une liste de chaines de caracteres a la syntaxe python
- """
- l=[]
- label=obj.definition.nom+'('
- l.append(label)
- for v in obj.mcListe:
- if isinstance(v,Accas.MCBLOC) :
- liste=self.generator(v)
- for mocle in liste :
- l.append(mocle)
- elif isinstance(v,Accas.MCSIMP) :
- text=self.generator(v)
- if text==None : text= ""
- l.append(v.nom+'='+text)
- else:
- # MCFACT ou MCList
- liste=self.generator(v)
- liste[0]=v.nom+'='+liste[0]
- l.append(liste)
-
- if len(l) == 1:
- l[0]=label+');'
- else :
- l.append(');')
- return l
-
- def generASSD(self,obj):
- """
- Convertit un objet derive d'ASSD en une chaine de caracteres a la
- syntaxe python
- """
- return obj.getName()
-
-
- def generMCFACT(self,obj):
- """
- Convertit un objet MCFACT en une liste de chaines de caracteres a la
- syntaxe python
- """
- l=[]
- l.append('_F(')
- for v in obj.mcListe:
- if not isinstance(v,Accas.MCSIMP) and not isinstance (v,Accas.MCBLOC) :
- # on est en presence d'une entite composee : on recupere une liste
- liste=self.generator(v)
- liste[0]=v.nom+'='+liste[0]
- l.append(liste)
- elif isinstance(v,Accas.MCBLOC):
- liste=self.generator(v)
- for arg in liste :
- l.append(arg)
- else:
- # on est en presence d'un MCSIMP : on recupere une string
- text =self.generator(v)
- if text== None : text =""
- if v.nom != "Consigne" : l.append(v.nom+'='+text)
- # il faut etre plus subtil dans l'ajout de la virgule en differenciant
- # le cas ou elle est obligatoire (si self a des freres cadets
- # dans self.parent) ou non
- # (cas ou self est seul ou le benjamin de self.parent)
- l.append('),')
- return l
-
- def generMCList(self,obj):
- """
- Convertit un objet MCList en une liste de chaines de caracteres a la
- syntaxe python
- """
- if len(obj.data) > 1:
- l=['(']
- for mcfact in obj.data: l.append(self.generator(mcfact))
- l.append('),')
- else:
- l= self.generator(obj.data[0])
- return l
-
- def generMCBLOC(self,obj):
- """
- Convertit un objet MCBLOC en une liste de chaines de caracteres a la
- syntaxe python
- """
- l=[]
- for v in obj.mcListe:
- if isinstance(v,Accas.MCBLOC) :
- liste=self.generator(v)
- for mocle in liste :
- l.append(mocle)
- elif isinstance(v,Accas.MCFACT):
- liste=self.generator(v)
- elif isinstance(v,Accas.MCList):
- liste=self.generator(v)
- liste[0]=v.nom+'='+liste[0]
- # PN essai de correction bug identation
- if (hasattr(v,'data')) :
- if (isinstance(v.data[0],Accas.MCFACT) and (len(v.data) == 1)):
- l.append(liste)
+ def generMACRO_ETAPE(self,obj):
+ """
+ Cette methode convertit une macro-etape
+ en une liste de chaines de caracteres a la syntaxe python
+ """
+ try:
+ if obj.sd == None:
+ sdname=''
+ else:
+ sdname= self.generator(obj.sd)+'='
+ if sdname.find('SD_') != -1: sdname=''
+ except:
+ sdname='sansnom='
+ l=[]
+ label = sdname + obj.definition.nom+'('
+ l.append(label)
+ if obj.reuse != None:
+ # XXX faut il la virgule ou pas ????
+ str = "reuse =" + self.generator(obj.reuse) + ','
+ l.append(str)
+ for v in obj.mcListe:
+ if isinstance(v,Accas.MCBLOC) :
+ liste=self.generator(v)
+ for mocle in liste :
+ l.append(mocle)
+ elif isinstance(v,Accas.MCSIMP) :
+ text=self.generator(v)
+ l.append(v.nom+'='+text)
else:
- for mocle in liste :
- l.append(mocle)
- else :
- for mocle in liste :
- l.append(mocle)
+ # MCFACT ou MCList
+ liste=self.generator(v)
+ liste[0]=v.nom+'='+liste[0]
+ l.append(liste)
+
+ if len(l) == 1:
+ l[0]=label+');'
+ else :
+ l.append(');')
+ return l
+
+ def generPROC_ETAPE(self,obj):
+ """
+ Cette methode convertit une PROC etape
+ en une liste de chaines de caracteres a la syntaxe python
+ """
+ l=[]
+ label=obj.definition.nom+'('
+ l.append(label)
+ for v in obj.mcListe:
+ if isinstance(v,Accas.MCBLOC) :
+ liste=self.generator(v)
+ for mocle in liste :
+ l.append(mocle)
+ elif isinstance(v,Accas.MCSIMP) :
+ text=self.generator(v)
+ if text==None : text= ""
+ l.append(v.nom+'='+text)
+ else:
+ # MCFACT ou MCList
+ liste=self.generator(v)
+ liste[0]=v.nom+'='+liste[0]
+ l.append(liste)
+
+ if len(l) == 1:
+ l[0]=label+');'
+ else :
+ l.append(');')
+ return l
+
+ def generASSD(self,obj):
+ """
+ Convertit un objet derive d'ASSD en une chaine de caracteres a la
+ syntaxe python
+ """
+ return obj.getName()
+
+
+ def generMCFACT(self,obj):
+ """
+ Convertit un objet MCFACT en une liste de chaines de caracteres a la
+ syntaxe python
+ """
+ l=[]
+ l.append('_F(')
+ for v in obj.mcListe:
+ if not isinstance(v,Accas.MCSIMP) and not isinstance (v,Accas.MCBLOC) :
+ # on est en presence d'une entite composee : on recupere une liste
+ liste=self.generator(v)
+ liste[0]=v.nom+'='+liste[0]
+ l.append(liste)
+ elif isinstance(v,Accas.MCBLOC):
+ liste=self.generator(v)
+ for arg in liste :
+ l.append(arg)
+ else:
+ # on est en presence d'un MCSIMP : on recupere une string
+ text =self.generator(v)
+ if text== None : text =""
+ if v.nom != "Consigne" : l.append(v.nom+'='+text)
+ # il faut etre plus subtil dans l'ajout de la virgule en differenciant
+ # le cas ou elle est obligatoire (si self a des freres cadets
+ # dans self.parent) ou non
+ # (cas ou self est seul ou le benjamin de self.parent)
+ l.append('),')
+ return l
+
+ def generMCList(self,obj):
+ """
+ Convertit un objet MCList en une liste de chaines de caracteres a la
+ syntaxe python
+ """
+ if len(obj.data) > 1:
+ l=['(']
+ for mcfact in obj.data: l.append(self.generator(mcfact))
+ l.append('),')
else:
- data=self.generator(v)
- if data==None : data= ""
- if type(data) == list:
- data[0]=v.nom+'='+data[0]
- else:
- data=v.nom+'='+data
- l.append(data)
- return l
-
-
- 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
- # On ajoute un . si il n y en a pas dans la valeur
- s = str(valeur)
- if vientDeListe and repr(valeur) != str(valeur) : s=repr(valeur)
- if (s.find('.')== -1 and s.find('e')== -1 and s.find('E')==-1) : s=s+'.0'
- clefobj=etape.getSdname()
- if self.appliEficas and clefobj in self.appliEficas.dict_reels:
- if valeur in self.appliEficas.dict_reels[clefobj]:
- s=self.appliEficas.dict_reels[clefobj][valeur]
-
- elif type(valeur) == bytes or type(valeur) == str :
- if valeur.find('\n') == -1:
- # pas de retour chariot, on utilise repr
- s = repr(valeur)
- elif valeur.find('"""') == -1:
- # retour chariot mais pas de triple ", on formatte
- s='"""'+valeur+'"""'
- else:
- s = repr(valeur)
- elif isinstance(valeur,Accas.CO) or hasattr(etape,'sdprods') and valeur in etape.sdprods:
- s = "CO('"+ self.generator(valeur) +"')"
- elif isinstance(valeur,Accas.UserASSD):
- # ici on ne prend que la reference
- s = valeur.nom
- elif isinstance(valeur,Accas.ASSD):
- s = self.generator(valeur)
- elif isinstance(valeur,Accas.PARAMETRE):
- # il ne faut pas prendre la string que retourne gener
- # mais seulement le nom dans le cas d'un parametre
- s = valeur.nom
-
- #elif type(valeur) == types.InstanceType or isinstance(valeur,object):
- # if valeur.__class__.__name__ == 'CO' or hasattr(etape,'sdprods') and valeur in etape.sdprods :
- # s = "CO('"+ self.generator(valeur) +"')"
- # elif isinstance(valeur,Accas.PARAMETRE):
+ l= self.generator(obj.data[0])
+ return l
+
+ def generMCBLOC(self,obj):
+ """
+ Convertit un objet MCBLOC en une liste de chaines de caracteres a la
+ syntaxe python
+ """
+ l=[]
+ for v in obj.mcListe:
+ if isinstance(v,Accas.MCBLOC) :
+ liste=self.generator(v)
+ for mocle in liste :
+ l.append(mocle)
+ elif isinstance(v,Accas.MCFACT):
+ liste=self.generator(v)
+ elif isinstance(v,Accas.MCList):
+ liste=self.generator(v)
+ liste[0]=v.nom+'='+liste[0]
+ # PN essai de correction bug identation
+ if (hasattr(v,'data')) :
+ if (isinstance(v.data[0],Accas.MCFACT) and (len(v.data) == 1)):
+ l.append(liste)
+ else:
+ for mocle in liste :
+ l.append(mocle)
+ else :
+ for mocle in liste :
+ l.append(mocle)
+ else:
+ data=self.generator(v)
+ if data==None : data= ""
+ if type(data) == list:
+ data[0]=v.nom+'='+data[0]
+ else:
+ data=v.nom+'='+data
+ l.append(data)
+ return l
+
+
+ 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
+ # On ajoute un . si il n y en a pas dans la valeur
+ s = str(valeur)
+ if vientDeListe and repr(valeur) != str(valeur) : s=repr(valeur)
+ if (s.find('.')== -1 and s.find('e')== -1 and s.find('E')==-1) : s=s+'.0'
+ clefobj=etape.getSdname()
+ if self.appliEficas and clefobj in self.appliEficas.dict_reels:
+ if valeur in self.appliEficas.dict_reels[clefobj]:
+ s=self.appliEficas.dict_reels[clefobj][valeur]
+
+ elif type(valeur) == bytes or type(valeur) == str :
+ if valeur.find('\n') == -1:
+ # pas de retour chariot, on utilise repr
+ s = repr(valeur)
+ elif valeur.find('"""') == -1:
+ # retour chariot mais pas de triple ", on formatte
+ s='"""'+valeur+'"""'
+ else:
+ s = repr(valeur)
+ elif isinstance(valeur,Accas.CO) or hasattr(etape,'sdprods') and valeur in etape.sdprods:
+ s = "CO('"+ self.generator(valeur) +"')"
+ elif isinstance(valeur,Accas.UserASSD):
+ # ici on ne prend que la reference
+ s = valeur.nom
+ elif isinstance(valeur,Accas.ASSD):
+ s = self.generator(valeur)
+ elif isinstance(valeur,Accas.PARAMETRE):
# il ne faut pas prendre la string que retourne gener
# mais seulement le nom dans le cas d'un parametre
- # s = valeur.nom
- # else:
- # s = self.generator(valeur)
-
- else :
- # Pour les autres types on utilise repr
- s = repr(valeur)
- return s
-
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en une liste de chaines de caracteres a la
- syntaxe python
- """
- waitTuple=0
- if type(obj.valeur) in (tuple,list) :
- s = ''
- for ss_type in obj.definition.type:
- if repr(ss_type).find('Tuple') != -1 :
- waitTuple=1
- break
-
- if waitTuple :
- #s = str(obj.valeur) +','
- #obj.valeurFormatee=obj.valeur
- s = obj.getText() +','
- obj.valeurFormatee=obj.getText()
- else :
- obj.valeurFormatee=[]
- for val in obj.valeur :
- s =s +self.formatItem(val,obj.etape,obj,1) + ','
- if obj.waitTxm() :
- obj.valeurFormatee.append(val)
- else :
- obj.valeurFormatee.append(self.formatItem(val,obj.etape,obj))
- if len(obj.valeur) >= 1:
- s = '(' + s + '),'
- if obj.valeur==[] or obj.valeur==() : s="(),"
- if obj.nbrColonnes() :
- s=self.formatColonnes(obj.nbrColonnes(),obj.valeur,obj)
- else :
- obj.valeurFormatee=obj.valeur
- s=self.formatItem(obj.valeur,obj.etape,obj) + ','
- return s
-
-
- def formatColonnes(self,nbrColonnes,listeValeurs,obj):
- try :
- #if 1 == 1 :
- indice=0
- textformat="("
- while ( indice < len(listeValeurs) ) :
- try :
- #if 1 :
- for l in range(nbrColonnes) :
- texteVariable=self.formatItem(listeValeurs[indice],obj.etape,obj)
- textformat=textformat+texteVariable+" ,"
- indice=indice+1
- textformat=textformat+"\n"
- except :
- #else :
+ s = valeur.nom
+
+ #elif type(valeur) == types.InstanceType or isinstance(valeur,object):
+ # if valeur.__class__.__name__ == 'CO' or hasattr(etape,'sdprods') and valeur in etape.sdprods :
+ # s = "CO('"+ self.generator(valeur) +"')"
+ # elif isinstance(valeur,Accas.PARAMETRE):
+ # il ne faut pas prendre la string que retourne gener
+ # mais seulement le nom dans le cas d'un parametre
+ # s = valeur.nom
+ # else:
+ # s = self.generator(valeur)
+
+ else :
+ # Pour les autres types on utilise repr
+ s = repr(valeur)
+ return s
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en une liste de chaines de caracteres a la
+ syntaxe python
+ """
+ waitTuple=0
+ if type(obj.valeur) in (tuple,list) :
+ s = ''
+ for ss_type in obj.definition.type:
+ if repr(ss_type).find('Tuple') != -1 :
+ waitTuple=1
+ break
+
+ if waitTuple :
+ #s = str(obj.valeur) +','
+ #obj.valeurFormatee=obj.valeur
+ s = obj.getText() +','
+ obj.valeurFormatee=obj.getText()
+ else :
+ obj.valeurFormatee=[]
+ for val in obj.valeur :
+ s =s +self.formatItem(val,obj.etape,obj,1) + ','
+ if obj.waitTxm() :
+ obj.valeurFormatee.append(val)
+ else :
+ obj.valeurFormatee.append(self.formatItem(val,obj.etape,obj))
+ if len(obj.valeur) >= 1:
+ s = '(' + s + '),'
+ if obj.valeur==[] or obj.valeur==() : s="(),"
+ if obj.nbrColonnes() :
+ s=self.formatColonnes(obj.nbrColonnes(),obj.valeur,obj)
+ else :
+ obj.valeurFormatee=obj.valeur
+ s=self.formatItem(obj.valeur,obj.etape,obj) + ','
+ return s
+
+
+ def formatColonnes(self,nbrColonnes,listeValeurs,obj):
+ try :
+ #if 1 == 1 :
+ indice=0
+ textformat="("
while ( indice < len(listeValeurs) ) :
- texteVariable=self.formatItem(listeValeurs[indice],obj.etape,obj)
- textformat=textformat+texteVariable+", "
- indice=indice+1
- textformat=textformat+"\n"
- textformat=textformat[0:-1]+"),\n"
- except :
- #else :
- textformat=str(obj.valeur)
- return textformat
+ try :
+ #if 1 :
+ for l in range(nbrColonnes) :
+ 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.formatItem(listeValeurs[indice],obj.etape,obj)
+ textformat=textformat+texteVariable+", "
+ indice=indice+1
+ textformat=textformat+"\n"
+ textformat=textformat[0:-1]+"),\n"
+ except :
+ #else :
+ textformat=str(obj.valeur)
+ return textformat
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient le plugin generateur de fichier au format
+ Ce module contient le plugin generateur de fichier au format
python pour EFICAS.
PN
from __future__ import print_function
from __future__ import division
try :
- from builtins import range
+ from builtins import range
except :
- pass
+ pass
import traceback
import types,re
import math
#from Editeur.widgets import showerror
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'vers3DSalome',
- # La factory pour creer une instance du plugin
- 'factory' : vers3DSalomeGenerator,
- }
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'vers3DSalome',
+ # La factory pour creer une instance du plugin
+ 'factory' : vers3DSalomeGenerator,
+ }
class vers3DSalomeGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet AFFE-CARA_ELEM
- et produit un fichier au format texte contenant
- les instructions idl pour PAL
- """
-
- def __init__(self,cr=None):
- self.list_commandes=[];
- self.jdc=None
- self.node=None
- self.clefs=None
- self.liste_motetat = ("AFFE_CARA_ELEM", "ORIG_AXE", "AXE" ,
- "BARRE", "CABLE", "CARA", "COQUE", "EPAIS",
- "EXCENTREMENT", "GROUP_MA", "ORIENTATION",
- "POUTRE", "SECTION", "VALE", "VARI_SECT",
- "GRILLE", "ANGL_REP", "VECTEUR",
- "b_constant", "b_homothetique",
- "b_rectangle", "b_affine", "b_cercle", "b_generale" )
- self.dict_deb_com={"POUTRE":"VisuPoutre", "CABLE" : "VisuCable",
- "COQUE" : "VisuCoque", "GRILLE" : "VisuGrille",
- "ORIENTATION" : "Orientation", "BARRE" : "VisuBarre"}
-
- self.dict_suite_com={"RECTANGLE":"Rectangle","GENERALE":"Generale",
- "CERCLE":"Cercle"}
-
- self.dict_traduit={"VARI_SECT":"extrusion","EXCENTREMENT":"Excentre","EPAIS":"Epais","VECTEUR":"Vecteur"}
-
- self.initLigne ()
-
- def initJdc(self,jdc) :
- self.jdc=jdc
-
- def initLigne (self) :
- self.boolGpMa = 0
- self.commande = ""
- self.dict_attributs = {}
-
- def gener(self,node,config=None,appliEficas=None):
- """
- """
- self.node=node
- self.list_commandes=[];
- self.generator(self.node.object)
- return self.list_commandes
-
- def generator(self,obj):
- if (obj.nom in self.liste_motetat) and (self.calculeOuiNon(obj)):
- PythonGenerator.generator(self,obj)
- """
- f1=PythonGenerator.generator(self,obj)
- else :
- return ""
- """
-
- def calculeOuiNon(self,obj):
- ouinon=1
- for l in obj.getGenealogie() :
- if not l in self.liste_motetat :
- ouinon=0
- break
- return ouinon
-
-
- def generETAPE(self,obj):
- """
- """
- if obj.isValid() == 0 :
- #showerror("Element non valide","Salome ne sait pas traiter les elements non valides")
- return
- for v in obj.mcListe:
- liste=self.generator(v)
-
- def generMACRO_ETAPE(self,obj):
- """
- """
- if obj.isValid() == 0 :
- #showerror("Element non valide","Salome ne sait pas traiter les elements non valides")
- return
- for v in obj.mcListe:
- liste=self.generator(v)
-
-
- def generMCSIMP(self,obj) :
- """
- """
- if obj.nom in dir(self) :
- suite = self.__class__.__dict__[obj.nom](self,obj)
- else :
- clef=self.dict_traduit[obj.nom]
- # traitement des parametres
- try :
- self.dict_attributs[clef]=obj.val.eval()
- except :
- self.dict_attributs[clef]=obj.val
-
-
- def generMCFACT(self,obj):
- """
- Convertit un objet MCFACT en une liste de chaines de caracteres a la
- syntaxe python
- """
- self.initLigne ()
- self.commande=self.dict_deb_com[obj.nom]
- for v in obj.mcListe:
- self.generator(v)
- if self.boolGpMa == 1:
- self.list_commandes.append((self.commande,self.dict_attributs))
- else :
- #showerror("Elements ne portant pas sur un Groupe de Maille","Salome ne sait pas montrer ce type d' element")
- print(("Elements ne portant pas sur un Groupe de Maille","Salome ne sait pas montrer ce type d' element"))
- pass
-
- def generMCList(self,obj):
- """
- """
- for mcfact in obj.data:
- self.generator(mcfact)
-
- def generMCBLOC(self,obj):
- """
- """
- for v in obj.mcListe:
- self.generator(v)
-
- def GROUP_MA(self,obj):
- self.boolGpMa = 1
- self.dict_attributs["Group_Maille"]=obj.val
-
- def SECTION(self,obj):
- assert (self.commande != "" )
- if self.commande == "VisuCable" :
- self.dict_attributs["R"]= math.sqrt(obj.val/math.pi).eval()
- elif (self.commande !="VisuGrille") :
- self.commande=self.commande+self.dict_suite_com[obj.valeur]
-
- def CARA(self,obj) :
- self.clefs=obj.val
- if type(self.clefs) == bytes or type(self.clefs) == str:
- self.clefs=(obj.val,)
-
- def VALE(self,obj) :
- atraiter=obj.val
- if len(self.clefs) > 1 :
- assert (len(atraiter) == len(self.clefs))
- else :
- atraiter=(atraiter,)
- for k in range(len(atraiter)) :
- clef=self.clefs[k]
- val =atraiter[k]
- if isinstance(val, (tuple, list)) and len(val) == 1:
- val = val[0]
- if isinstance (val, Extensions.parametre.PARAMETRE):
- val=val.valeur
- print(( val.__class))
- context={}
- if type(val) == type("aaa") :
- for p in self.jdc.params:
- context[p.nom]=eval(p.val,self.jdc.const_context, context)
- print((context[p.nom]))
- res=eval(val,self.jdc.const_context, context)
- val=res
- self.dict_attributs[clef]=val
-
- def ANGL_REP(self,obj) :
- assert (len(obj.val) == 2)
- alpha,beta=obj.val
- self.dict_attributs["angleAlpha"]=alpha
- self.dict_attributs["angleBeta"]=beta
-
- def ORIG_AXE(self,obj) :
- assert (len(obj.val) == 3)
- alpha,beta,gamma=obj.val
- self.dict_attributs["origAxeX"]=alpha
- self.dict_attributs["origAxeY"]=beta
- self.dict_attributs["origAxeZ"]=gamma
-
- def AXE(self,obj) :
- assert (len(obj.val) == 3)
- alpha,beta,gamma=obj.val
- self.dict_attributs["axeX"]=alpha
- self.dict_attributs["axeY"]=beta
- self.dict_attributs["axeZ"]=gamma
+ """
+ Ce generateur parcourt un objet AFFE-CARA_ELEM
+ et produit un fichier au format texte contenant
+ les instructions idl pour PAL
+ """
+
+ def __init__(self,cr=None):
+ self.list_commandes=[];
+ self.jdc=None
+ self.node=None
+ self.clefs=None
+ self.liste_motetat = ("AFFE_CARA_ELEM", "ORIG_AXE", "AXE" ,
+ "BARRE", "CABLE", "CARA", "COQUE", "EPAIS",
+ "EXCENTREMENT", "GROUP_MA", "ORIENTATION",
+ "POUTRE", "SECTION", "VALE", "VARI_SECT",
+ "GRILLE", "ANGL_REP", "VECTEUR",
+ "b_constant", "b_homothetique",
+ "b_rectangle", "b_affine", "b_cercle", "b_generale" )
+ self.dict_deb_com={"POUTRE":"VisuPoutre", "CABLE" : "VisuCable",
+ "COQUE" : "VisuCoque", "GRILLE" : "VisuGrille",
+ "ORIENTATION" : "Orientation", "BARRE" : "VisuBarre"}
+
+ self.dict_suite_com={"RECTANGLE":"Rectangle","GENERALE":"Generale",
+ "CERCLE":"Cercle"}
+
+ self.dict_traduit={"VARI_SECT":"extrusion","EXCENTREMENT":"Excentre","EPAIS":"Epais","VECTEUR":"Vecteur"}
+
+ self.initLigne ()
+
+ def initJdc(self,jdc) :
+ self.jdc=jdc
+
+ def initLigne (self) :
+ self.boolGpMa = 0
+ self.commande = ""
+ self.dict_attributs = {}
+
+ def gener(self,node,config=None,appliEficas=None):
+ """
+ """
+ self.node=node
+ self.list_commandes=[];
+ self.generator(self.node.object)
+ return self.list_commandes
+
+ def generator(self,obj):
+ if (obj.nom in self.liste_motetat) and (self.calculeOuiNon(obj)):
+ PythonGenerator.generator(self,obj)
+ """
+ f1=PythonGenerator.generator(self,obj)
+ else :
+ return ""
+ """
+
+ def calculeOuiNon(self,obj):
+ ouinon=1
+ for l in obj.getGenealogie() :
+ if not l in self.liste_motetat :
+ ouinon=0
+ break
+ return ouinon
+
+
+ def generETAPE(self,obj):
+ """
+ """
+ if obj.isValid() == 0 :
+ #showerror("Element non valide","Salome ne sait pas traiter les elements non valides")
+ return
+ for v in obj.mcListe:
+ liste=self.generator(v)
+
+ def generMACRO_ETAPE(self,obj):
+ """
+ """
+ if obj.isValid() == 0 :
+ #showerror("Element non valide","Salome ne sait pas traiter les elements non valides")
+ return
+ for v in obj.mcListe:
+ liste=self.generator(v)
+
+
+ def generMCSIMP(self,obj) :
+ """
+ """
+ if obj.nom in dir(self) :
+ suite = self.__class__.__dict__[obj.nom](self,obj)
+ else :
+ clef=self.dict_traduit[obj.nom]
+ # traitement des parametres
+ try :
+ self.dict_attributs[clef]=obj.val.eval()
+ except :
+ self.dict_attributs[clef]=obj.val
+
+
+ def generMCFACT(self,obj):
+ """
+ Convertit un objet MCFACT en une liste de chaines de caracteres a la
+ syntaxe python
+ """
+ self.initLigne ()
+ self.commande=self.dict_deb_com[obj.nom]
+ for v in obj.mcListe:
+ self.generator(v)
+ if self.boolGpMa == 1:
+ self.list_commandes.append((self.commande,self.dict_attributs))
+ else :
+ #showerror("Elements ne portant pas sur un Groupe de Maille","Salome ne sait pas montrer ce type d' element")
+ print(("Elements ne portant pas sur un Groupe de Maille","Salome ne sait pas montrer ce type d' element"))
+ pass
+
+ def generMCList(self,obj):
+ """
+ """
+ for mcfact in obj.data:
+ self.generator(mcfact)
+
+ def generMCBLOC(self,obj):
+ """
+ """
+ for v in obj.mcListe:
+ self.generator(v)
+
+ def GROUP_MA(self,obj):
+ self.boolGpMa = 1
+ self.dict_attributs["Group_Maille"]=obj.val
+
+ def SECTION(self,obj):
+ assert (self.commande != "" )
+ if self.commande == "VisuCable" :
+ self.dict_attributs["R"]= math.sqrt(obj.val/math.pi).eval()
+ elif (self.commande !="VisuGrille") :
+ self.commande=self.commande+self.dict_suite_com[obj.valeur]
+
+ def CARA(self,obj) :
+ self.clefs=obj.val
+ if type(self.clefs) == bytes or type(self.clefs) == str:
+ self.clefs=(obj.val,)
+
+ def VALE(self,obj) :
+ atraiter=obj.val
+ if len(self.clefs) > 1 :
+ assert (len(atraiter) == len(self.clefs))
+ else :
+ atraiter=(atraiter,)
+ for k in range(len(atraiter)) :
+ clef=self.clefs[k]
+ val =atraiter[k]
+ if isinstance(val, (tuple, list)) and len(val) == 1:
+ val = val[0]
+ if isinstance (val, Extensions.parametre.PARAMETRE):
+ val=val.valeur
+ print(( val.__class))
+ context={}
+ if type(val) == type("aaa") :
+ for p in self.jdc.params:
+ context[p.nom]=eval(p.val,self.jdc.const_context, context)
+ print((context[p.nom]))
+ res=eval(val,self.jdc.const_context, context)
+ val=res
+ self.dict_attributs[clef]=val
+
+ def ANGL_REP(self,obj) :
+ assert (len(obj.val) == 2)
+ alpha,beta=obj.val
+ self.dict_attributs["angleAlpha"]=alpha
+ self.dict_attributs["angleBeta"]=beta
+
+ def ORIG_AXE(self,obj) :
+ assert (len(obj.val) == 3)
+ alpha,beta,gamma=obj.val
+ self.dict_attributs["origAxeX"]=alpha
+ self.dict_attributs["origAxeY"]=beta
+ self.dict_attributs["origAxeZ"]=gamma
+
+ def AXE(self,obj) :
+ assert (len(obj.val) == 3)
+ alpha,beta,gamma=obj.val
+ self.dict_attributs["axeX"]=alpha
+ self.dict_attributs["axeY"]=beta
+ self.dict_attributs["axeZ"]=gamma
