From 5b21b0f079b43a879a2b29c703230978eefca09a Mon Sep 17 00:00:00 2001 From: "pascale.noyret" Date: Mon, 29 Mar 2021 10:34:49 +0200 Subject: [PATCH] reiindent sur generator --- generator/Formatage.py | 558 ++++++------ generator/__init__.py | 1 - generator/a.py | 5 - generator/generator_GroupMA.py | 88 +- generator/generator_PSEN.py | 108 +-- generator/generator_ProcessOutputs.py | 48 +- generator/generator_TELEMAC.py | 456 +++++----- generator/generator_XML.py | 131 +-- generator/generator_aplat.py | 602 +++++++------ generator/generator_dico.py | 75 +- generator/generator_dicoImbrique.py | 149 ++-- generator/generator_map.py | 144 ++-- generator/generator_mapVP.py | 395 +++++---- generator/generator_modification.py | 28 +- generator/generator_python.py | 1122 ++++++++++++------------- generator/generator_vers3DSalome.py | 390 ++++----- 16 files changed, 2143 insertions(+), 2157 deletions(-) delete mode 100644 generator/a.py diff --git a/generator/Formatage.py b/generator/Formatage.py index eb57e461..c7900854 100644 --- a/generator/Formatage.py +++ b/generator/Formatage.py @@ -25,7 +25,7 @@ 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 @@ -33,295 +33,293 @@ filePattern="'[^\(\)]([^\(\)]*\([^\(\)]*\))*[^\(\)]*'" 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 diff --git a/generator/__init__.py b/generator/__init__.py index 9d4cb7f0..fe419055 100644 --- a/generator/__init__.py +++ b/generator/__init__.py @@ -30,4 +30,3 @@ from Extensions import pluginloader import generator plugins=pluginloader.PluginLoader(generator) - diff --git a/generator/a.py b/generator/a.py deleted file mode 100644 index db583c47..00000000 --- a/generator/a.py +++ /dev/null @@ -1,5 +0,0 @@ -Title = 'toto' -txt='' -txt += "Title" + "= " + str(Title) + "\n" -print txt - diff --git a/generator/generator_GroupMA.py b/generator/generator_GroupMA.py index f10704fe..1fdbc709 100644 --- a/generator/generator_GroupMA.py +++ b/generator/generator_GroupMA.py @@ -26,55 +26,55 @@ import types,re 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 diff --git a/generator/generator_PSEN.py b/generator/generator_PSEN.py index 93ee4bc5..1c089352 100755 --- a/generator/generator_PSEN.py +++ b/generator/generator_PSEN.py @@ -22,7 +22,7 @@ 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" @@ -33,78 +33,78 @@ from Extensions.i18n import tr 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) : @@ -122,5 +122,5 @@ class PSENGenerator(DicoImbriqueGenerator): ## self.dicoTemp={} ## return s - + # si repertoire on change tous les noms de fichier diff --git a/generator/generator_ProcessOutputs.py b/generator/generator_ProcessOutputs.py index efce52f0..e7603c82 100755 --- a/generator/generator_ProcessOutputs.py +++ b/generator/generator_ProcessOutputs.py @@ -27,38 +27,38 @@ from .generator_python import PythonGenerator 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 diff --git a/generator/generator_TELEMAC.py b/generator/generator_TELEMAC.py index 6935d537..6a20e250 100644 --- a/generator/generator_TELEMAC.py +++ b/generator/generator_TELEMAC.py @@ -23,7 +23,7 @@ from __future__ import absolute_import from __future__ import print_function try : - from builtins import str + from builtins import str except : pass import traceback @@ -37,95 +37,95 @@ extensions=('.comm',) 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 = "" @@ -134,30 +134,30 @@ class TELEMACGenerator(PythonGenerator): # 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' @@ -169,7 +169,7 @@ class TELEMACGenerator(PythonGenerator): return s - def generMCSIMP(self,obj) : + def generMCSIMP(self,obj) : """recuperation de l objet MCSIMP""" s=PythonGenerator.generMCSIMP(self,obj) @@ -178,60 +178,60 @@ class TELEMACGenerator(PythonGenerator): # 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 @@ -240,119 +240,117 @@ class TELEMACGenerator(PythonGenerator): # 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) diff --git a/generator/generator_XML.py b/generator/generator_XML.py index 1bb13d66..99fe95c7 100644 --- a/generator/generator_XML.py +++ b/generator/generator_XML.py @@ -23,7 +23,7 @@ from __future__ import absolute_import from __future__ import print_function try : - from builtins import str + from builtins import str except : pass import traceback @@ -32,81 +32,82 @@ from Extensions.i18n import tr 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 diff --git a/generator/generator_aplat.py b/generator/generator_aplat.py index 6eaff182..32a976b0 100644 --- a/generator/generator_aplat.py +++ b/generator/generator_aplat.py @@ -18,13 +18,13 @@ # 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 @@ -40,308 +40,306 @@ from Accas import GEOM,ASSD,MCNUPLET 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 diff --git a/generator/generator_dico.py b/generator/generator_dico.py index 91c69c23..afe2a826 100644 --- a/generator/generator_dico.py +++ b/generator/generator_dico.py @@ -23,7 +23,7 @@ from __future__ import absolute_import from __future__ import print_function try : - from builtins import str + from builtins import str except : pass import traceback @@ -32,63 +32,63 @@ from Extensions.i18n import tr 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 @@ -98,4 +98,3 @@ class DicoGenerator(PythonGenerator): courant[obj.nom]=obj.val self.texteDico+=obj.nom+ "=" + s[0:-1]+ "\n" return s - diff --git a/generator/generator_dicoImbrique.py b/generator/generator_dicoImbrique.py index d5d845cf..e8c76729 100644 --- a/generator/generator_dicoImbrique.py +++ b/generator/generator_dicoImbrique.py @@ -22,7 +22,7 @@ from __future__ import absolute_import try : - from builtins import str + from builtins import str except : pass import traceback @@ -31,121 +31,120 @@ from Extensions.i18n import tr 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 - - diff --git a/generator/generator_map.py b/generator/generator_map.py index 97e7edd0..673132c2 100644 --- a/generator/generator_map.py +++ b/generator/generator_map.py @@ -18,14 +18,14 @@ # 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 @@ -35,77 +35,77 @@ import Accas 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 diff --git a/generator/generator_mapVP.py b/generator/generator_mapVP.py index a6c766a5..9763f28b 100644 --- a/generator/generator_mapVP.py +++ b/generator/generator_mapVP.py @@ -18,14 +18,14 @@ # 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 @@ -35,204 +35,203 @@ import Accas 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 diff --git a/generator/generator_modification.py b/generator/generator_modification.py index d309d52a..20d1ab50 100644 --- a/generator/generator_modification.py +++ b/generator/generator_modification.py @@ -23,8 +23,8 @@ # 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 @@ -32,16 +32,16 @@ from Extensions.i18n import tr 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 diff --git a/generator/generator_python.py b/generator/generator_python.py index cbf95ee3..9fd162a1 100644 --- a/generator/generator_python.py +++ b/generator/generator_python.py @@ -18,15 +18,15 @@ # 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 @@ -37,7 +37,7 @@ from Noyau.N_utils import repr_float 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 @@ -45,306 +45,306 @@ from Extensions.i18n import tr 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 """ @@ -358,270 +358,270 @@ class PythonGenerator(object): 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 diff --git a/generator/generator_vers3DSalome.py b/generator/generator_vers3DSalome.py index 9f405a45..f57c1217 100644 --- a/generator/generator_vers3DSalome.py +++ b/generator/generator_vers3DSalome.py @@ -18,7 +18,7 @@ # 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 @@ -27,9 +27,9 @@ from __future__ import absolute_import 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 @@ -45,199 +45,199 @@ from six.moves import range #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 -- 2.39.2