--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+install ( FILES __init__.py parseur_python.py convert_python.py convert_TELEMAC.py
+ convert_map.py
+ DESTINATION ${CMAKE_INSTALL_PREFIX}/convert
+ )
+
+
+
+
+### Local Variables:
+### mode: cmake
+### End:
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ This package contains all input format converters
+ into objects understandable by EFICAS.
+
+ These converters are implemented in the form of plugins
+"""
+import os
+from Accas.IO import pluginloader
+currentDir = os.path.abspath(os.path.dirname(__file__))
+plugins = pluginloader.PluginLoader(currentDir)
--- /dev/null
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+import re
+from Accas.extensions.eficas_translation import tr
+
+# import traceback
+# traceback.print_stack()
+
+"""
+this module contains the parser to read .cas files
+convert them in python
+"""
+
+from Accas.IO.convert.convert_python import Pythonparser
+
+pattern_comment_slash = re.compile(r"^\s*/")
+pattern_comment_slash_vide = re.compile(r"^\s*/\s*$")
+pattern_comment_tiret = re.compile(r"^\s*/-*/*$")
+pattern_eta = re.compile(r".*&ETA.*")
+pattern_fin = re.compile(r".*&FIN.*")
+pattern_oui = re.compile(r"^\s*(oui|OUI|YES|yes|TRUE|true|vrai|VRAI)\s*$")
+pattern_non = re.compile(r"^\s*(non|NON|NO|no|FALSE|false|faux|FAUX)\s*$")
+pattern_blanc = re.compile(r"^\s*$")
+pattern_listeVide = re.compile(r"^\s*'\s*'\s*$")
+pattern_commence_par_quote = re.compile(r'^\s*[\'"].*')
+pattern_finit_par_virgule_ou_affect = re.compile(r"^.*(,|;|=|:)\s*$")
+
+pattern_ligne = re.compile(r"^\s*(?P<ident>[^=:]*)\s*[:=]\s*(?P<reste>.*)$")
+
+pattern_variables = re.compile(
+ r"^\s*(?P<ident>C_VSM_PRINTOUT_SELECTION|COUPLAGE AVEC|COUPLING WITH|VARIABLES FOR GRAPHIC PRINTOUTS|VARIABLES POUR LES SORTIES GRAPHIQUES|VARIABLES TO BE PRINTED|VARIABLES A IMPRIMER|VARIABLES FOR 3D GRAPHIC PRINTOUTS|VARIABLES POUR LES SORTIES GRAPHIQUES 3D|VARIABLES POUR LES SORTIES GRAPHIQUES 2D|VARIABLES FOR 2D GRAPHIC PRINTOUTS)\s*[:=]\s*(?P<quote>[']?)(?P<valeur>[A-Za-z]+(\d*|\*)([,;][A-Za-z]+(\d*|\*))*)\s*(?P=quote)(?P<reste>.*)$"
+)
+
+# Attention aux listes de flottants
+pattern_liste = re.compile(
+ r"^\s*(?P<valeur>[+-.\w]+(\s*;\s*[+-.\w]+)+)\s*(?P<reste>.*)$"
+)
+pattern_liste_texte = re.compile(
+ r"^\s*(?P<valeur>('.*(';\s*))+('.*'\s*)?)(?P<reste>.*)$"
+)
+pattern_flottant = re.compile(
+ r"^\s*(?P<valeur>[+-]?((\d+(\.\d*)?)|(\.\d+))([dDeE][+-]?\d+)?)\s*(?P<reste>.*)$"
+)
+pattern_texteQuote = re.compile(r"^\s*(?P<valeur>'[^']+(''[^']+)*')\s*(?P<reste>.*)$")
+pattern_texteSimple = re.compile(r"(?P<valeur>(^|\s)\s*[\w\.-]+)\s*(?P<reste>.*)$")
+pattern_texteVide = re.compile(r"^\s*(?P<valeur>'')\s*(?P<reste>.*)$")
+
+pattern_ContientDouble = re.compile(r"^.*''.*$")
+
+# le pattern texte reconnait
+# nom1 nom 2 : ou = chaine entre '
+# avec eventuellement des quotes au milieu par exemple
+# TITRE = 'TELEMAC 2D : GOUTTE D''EAU DANS UN BASSIN$'
+# m.group("texte") va rendre 'TELEMAC 2D : GOUTTE D''EAU DANS UN BASSIN$'
+
+
+# Si le code n est pas Telemac
+# try :
+# from enum_Telemac2d_auto import self.TelemacdicoEn
+# except :
+# pass
+
+from Accas.extensions import localisation
+
+
+def entryPoint():
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {"name": "TELEMAC", "factory": TELEMACparser}
+
+
+class TELEMACparser(Pythonparser):
+ """
+ This converter works like Pythonparser, except that it also initializes all
+ model variables to None in order to avoid Python syntax errors when loading
+ a file with a different or inexistent definition of variables.
+ """
+
+ def convert(self, outformat, appliEficas=None):
+ from Accas import A_BLOC, A_FACT, A_SIMP
+
+ try:
+ self.dicoCasToCata = appliEficas.readercata.dicoCasToCata
+ except:
+ self.dicoCasToCata = {}
+ print("pas de dicoCasToCata")
+ self.dicoInverse = appliEficas.readercata.dicoInverse
+ self.dicoMC = appliEficas.readercata.dicoMC
+ self.ordreDesCommandes = appliEficas.readercata.ordreDesCommandes
+ try:
+ self.TelemacdicoEn = appliEficas.readercata.TelemacdicoEn
+ except:
+ self.TelemacdicoEn = {}
+ print("pas de TelemacdicoEn")
+ try:
+ self.DicoEnumCasFrToEnumCasEn = (
+ appliEficas.readercata.DicoEnumCasFrToEnumCasEn
+ )
+ except:
+ self.DicoEnumCasFrToEnumCasEn = {}
+ print("pas de DicoEnumCasFrToEnumCasEn")
+
+ if appliEficas.langue == "fr":
+ # from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
+ for k in self.DicoEnumCasFrToEnumCasEn:
+ self.TelemacdicoEn[k] = self.DicoEnumCasFrToEnumCasEn[k]
+
+ text = ""
+ self.dictSimp = {}
+
+ l_lignes_texte_all = self.text.split("\n")
+ l_lignes_texte = []
+ listeComment = []
+ dicoComment = {}
+ dicoCommentSimp = {}
+ dicoCommentMC = {}
+ texteComment = ""
+ debut = True
+ trouveComment = 0
+ for l in l_lignes_texte_all:
+ if pattern_eta.match(l):
+ continue
+ if pattern_fin.match(l):
+ continue
+ if pattern_blanc.match(l):
+ continue
+
+ if not (pattern_comment_slash.match(l)):
+ l_lignes_texte.append(l)
+ if trouveComment:
+ if debut:
+ dicoComment["debut"] = texteComment
+ else:
+ dicoComment[l] = texteComment
+ trouveComment = 0
+ texteComment = ""
+ if debut:
+ debut = False
+
+ if pattern_comment_slash.match(l):
+ # if pattern_comment_slash_vide.match(l) : continue
+ if pattern_comment_tiret.match(l):
+ continue
+ texteComment += l.replace("/", "", 1)
+ texteComment += "\n"
+ trouveComment = 1
+
+ if texteComment != "":
+ dicoComment["fin"] = texteComment
+
+ l_lignes = []
+ i = 0
+ while i < len(l_lignes_texte):
+ ligne = l_lignes_texte[i]
+ i = i + 1
+ if not (pattern_finit_par_virgule_ou_affect.match(ligne)):
+ l_lignes.append(ligne)
+ continue
+ nouvelle_ligne = ligne
+ while i < len(l_lignes_texte):
+ ligne_traitee = l_lignes_texte[i]
+ i = i + 1
+ nouvelle_ligne += ligne_traitee
+ if not (pattern_finit_par_virgule_ou_affect.match(ligne_traitee)):
+ l_lignes.append(nouvelle_ligne)
+ break
+
+ for ligne in l_lignes:
+ if pattern_comment_slash.match(ligne):
+ continue
+ # PN : deja teste
+ # if pattern_eta.match(ligne) : continue
+ # if pattern_fin.match(ligne) : continue
+ # if pattern_blanc.match(ligne) : continue
+
+ finLigne = ligne
+ while finLigne != "":
+ if pattern_comment_slash.match(finLigne):
+ finLigne = ""
+ continue
+ valeur = ""
+ if pattern_variables.match(finLigne):
+ m = pattern_variables.match(finLigne)
+ simpCas = self.traiteIdent(m.group("ident"))
+ if simpCas in ["COUPLING WITH", "COUPLAGE AVEC"]:
+ if "," in m.group("valeur"):
+ valeur = m.group("valeur").split(",")
+ else:
+ valeur = m.group("valeur").split(";")
+ else:
+ valeur = m.group("valeur")
+ finLigne = m.group("reste")
+ self.dictSimp[simpCas] = valeur
+ continue
+
+ m = pattern_ligne.match(finLigne)
+ if m == None:
+ # print( "________________________________________________")
+ print("pb avec ****", finLigne, "**** dans ", ligne)
+ # print( "________________________________________________")
+ break
+
+ simpCas = self.traiteIdent(m.group("ident"))
+ if not simpCas:
+ finLigne = m.group("reste")
+ continue
+
+ finLigne = m.group("reste")
+ # attention, l ordre des if est important
+ if pattern_liste.match(finLigne):
+ m = pattern_liste.match(finLigne)
+ elif pattern_liste_texte.match(finLigne):
+ m = pattern_liste_texte.match(finLigne)
+ elif pattern_texteQuote.match(finLigne):
+ m = pattern_texteQuote.match(finLigne)
+ elif pattern_flottant.match(finLigne):
+ m = pattern_flottant.match(finLigne)
+ elif pattern_texteVide.match(finLigne):
+ m = pattern_texteVide.match(finLigne)
+ elif pattern_texteSimple.match(finLigne):
+ m = pattern_texteSimple.match(finLigne)
+ else:
+ # print ("________________________________________________")
+ print("pb avec ****", finLigne, "**** dans ", ligne)
+ print("non match")
+ # print ("________________________________________________")
+ break
+
+ valeur = m.group("valeur")
+ if pattern_blanc.match(valeur):
+ valeur = None
+
+ if pattern_flottant.match(finLigne):
+ valeur = re.sub("d", "e", valeur)
+ valeur = re.sub("D", "E", valeur)
+
+ if pattern_liste.match(finLigne) or pattern_liste_texte.match(finLigne):
+ valeur = valeur.split(";")
+
+ finLigne = m.group("reste")
+ self.dictSimp[simpCas] = valeur
+
+ if ligne in dicoComment.keys():
+ dicoCommentSimp[simpCas] = dicoComment[ligne]
+
+ if "TITLE" not in self.dictSimp:
+ import os
+
+ # self.dictSimp['TITLE']=os.path.basename(self.filename)
+
+ dicoParMC = {}
+ for simp in self.dictSimp:
+ if simp in TELEMACparser.__dict__:
+ TELEMACparser.__dict__[simp](
+ self,
+ )
+
+ for simp in self.dictSimp:
+ if simp not in self.dicoInverse:
+ # print ( "************")
+ print("pb avec dans dicoInverse", simp, "------")
+ print("dicoInverse", sorted(self.dicoInverse.keys()))
+ # print ("************")
+ continue
+ listeGenea = self.dicoInverse[simp]
+ listeGeneaReverse = []
+ for u, v in listeGenea:
+ if isinstance(v, A_BLOC.BLOC):
+ continue
+ listeGeneaReverse.append(u)
+ listeGeneaReverse.reverse()
+ dicoTravail = dicoParMC
+ i = 0
+ if simp in dicoCommentSimp:
+ MC = listeGeneaReverse[0]
+ if MC in dicoCommentMC:
+ dicoCommentMC[MC] + dicoCommentSimp[simp]
+ else:
+ dicoCommentMC[MC] = dicoCommentSimp[simp]
+ while i < len(listeGeneaReverse[0:-1]):
+ mot = listeGeneaReverse[i]
+ i = i + 1
+ if mot not in dicoTravail:
+ dicoTravail[mot] = {}
+ dicoTravail = dicoTravail[mot]
+ dicoTravail[simp] = self.dictSimp[simp]
+
+ self.textePy = ""
+ listeMC = self.tri(list(dicoParMC.keys()))
+ for k in listeMC:
+ if k in dicoCommentMC:
+ commentaire = "COMMENTAIRE(" + repr(dicoCommentMC[k]) + ")\n"
+ self.textePy += commentaire
+ self.textePy += str(k) + "("
+ self.traiteMC(dicoParMC[k])
+ self.textePy += ");\n"
+
+ # ne sert plus
+ # appliEficas.listeTelemac=self.dictSimp
+ appliEficas.listeTelemac = {}
+ if "debut" in dicoComment:
+ commentaire = "COMMENTAIRE(" + repr(dicoComment["debut"]) + ")\n"
+ self.textePy = commentaire + self.textePy
+ if "fin" in dicoComment:
+ commentaire = "COMMENTAIRE(" + repr(dicoComment["fin"]) + ")\n"
+ self.textePy = self.textePy + commentaire
+
+ # print (self.textePy)
+ return self.textePy
+
+ # ----------------------------------------
+ def traiteIdent(self, ident):
+ # enleve les espaces de part et autre
+ # traduit du langage Telemac vers le langage Catalogue
+ # ----------------------------------------
+ while ident[-1] == " " or ident[-1] == "\t":
+ ident = ident[0:-1]
+ while ident[0] == " " or ident[0] == "\t":
+ ident = ident[1:]
+ try:
+ identCata = self.dicoCasToCata[ident]
+ except:
+ print("---> ", "pb mot clef pour", ident)
+ identCata = None
+ return identCata
+
+ def traiteMC(self, dico):
+ from Accas import A_BLOC, A_FACT, A_SIMP
+
+ for k in dico:
+ valeur = dico[k]
+ if k not in self.dicoMC:
+ kA = self.dicoFrancaisAnglais[k]
+ else:
+ kA = k
+ obj = self.dicoMC[kA]
+ if isinstance(obj, A_FACT.FACT):
+ self.convertFACT(obj, kA, valeur)
+ elif isinstance(obj, A_BLOC.BLOC):
+ self.convertBLOC(obj, kA, valeur)
+ elif isinstance(obj, A_SIMP.SIMP):
+ self.convertSIMP(obj, kA, valeur)
+ else:
+ print(
+ "%%%%%%%%%%%\n", "pb conversion type pour", k, obj, "\n%%%%%%%%%%%"
+ )
+
+ def convertFACT(self, obj, nom, valeur):
+ # traitement LIQUID_BOUNDARIES
+ if nom in TELEMACparser.__dict__:
+ TELEMACparser.__dict__[nom](
+ self,
+ )
+ return
+ self.textePy += nom + "=_F( "
+ self.traiteMC(valeur)
+ self.textePy += "),\n"
+
+ def convertBLOC(self, obj, nom, valeur):
+ print("ANOMALIE _________ BLOC ")
+ print(nom)
+
+ def convertSIMP(self, obj, nom, valeur):
+ # print ('in convertSIMP', nom,valeur)
+ # if nom in ("PRESCRIBED_FLOWRATES", "PRESCRIBED_VELOCITIES", "PRESCRIBED_ELEVATIONS" ): return
+ if obj.max == 1:
+ if hasattr(obj.type[0], "ntuple"):
+ lval = []
+ for v in valeur:
+ try:
+ v = eval(v, {})
+ except:
+ pass
+ lval.append(v)
+ self.textePy += nom + "=" + str(lval) + ","
+ return
+ if "TXM" in obj.type:
+ if pattern_ContientDouble.match(str(valeur)):
+ valeur = re.sub("''", "''", str(valeur))
+ self.textePy += nom + "=" + str(valeur) + ","
+ return
+ valeur = str(valeur)
+
+ # ceinture et bretelle si les re sont correctes -)
+ while valeur[-1] == " " or valeur[-1] == "\t":
+ valeur = valeur[0:-1]
+ while valeur[0] == " " or valeur[0] == "\t":
+ valeur = valeur[1:]
+
+ # Pour les enum
+ try:
+ valeur = eval(valeur, {})
+ except:
+ pass
+
+ if nom in self.TelemacdicoEn:
+ try:
+ valeur = self.TelemacdicoEn[nom][valeur]
+ self.textePy += nom + "= '" + str(valeur) + "',"
+ return
+ except:
+ pass
+
+ if (
+ obj.into != []
+ and obj.into != None
+ and not ("R" in obj.type)
+ and not ("I" in obj.type)
+ ):
+ for possible in obj.into:
+ try:
+ if possible.upper() == valeur.upper():
+ valeur = possible
+ break
+ v = valeur[0].upper() + valeur[1:].lower()
+ v2 = tr(v)
+ if possible.upper() == v2.upper():
+ valeur = possible
+ break
+ except:
+ if valeur != None:
+ print(
+ "pb avec le type de ",
+ obj.nom,
+ obj.type,
+ "et la valeur ",
+ valeur,
+ )
+
+ if (
+ "Fichier" in obj.type
+ or "TXM" in obj.type
+ or "Repertoire" in obj.type
+ or "FichierOuRepertoire" in obj.type
+ ):
+ valeur = str(valeur)
+ if valeur == "" or valeur == " ":
+ self.textePy += nom + "= '" + str(valeur) + "' ,"
+ return
+ while valeur[-1] == " ":
+ valeur = valeur[0:-1]
+ while valeur[0] == " ":
+ valeur = valeur[1:]
+ self.textePy += nom + "= '" + str(valeur) + "' ,"
+ return
+
+ if bool in obj.type:
+ if valeur == True:
+ self.textePy += nom + "= True,"
+ elif valeur == False:
+ self.textePy += nom + "= False,"
+ elif pattern_oui.match(valeur):
+ self.textePy += nom + "= True,"
+ elif pattern_non.match(valeur):
+ self.textePy += nom + "= False,"
+ else:
+ self.textePy += nom + "= None,"
+ return
+ self.textePy += nom + "=" + str(valeur) + ","
+
+ else:
+ if valeur == () or valeur == [] or pattern_listeVide.match(str(valeur)):
+ self.textePy += nom + "= None,"
+ return
+
+ # les 4 lignes suivantes sont probablement inutiles
+ while valeur[-1] == " " or valeur[-1] == "'":
+ valeur = valeur[0:-1]
+ while valeur[0] == " " or valeur[-0] == "'":
+ valeur = valeur[1:]
+ oldValeur = valeur
+ if isinstance(valeur, str):
+ if ";" in valeur:
+ valeur = valeur.split(";")
+ else:
+ valeur = valeur.split(",")
+
+ if len(valeur) < 2 and pattern_flottant.match(oldValeur):
+ # Attention : on attend une liste mais on a une seule valeur!
+ try:
+ oldValeur = eval(oldValeur, {})
+ except:
+ pass
+ if nom in self.TelemacdicoEn:
+ v = self.TelemacdicoEn[nom][oldValeur]
+ self.textePy += nom + "= ('" + str(v) + "',),"
+ else:
+ self.textePy += nom + "= (" + str(oldValeur) + ",),"
+ return
+
+ # Cas des liste de booléen
+ if bool in obj.type:
+ values = []
+ for val in valeur:
+ if val == True or pattern_oui.match(val) or val == "True":
+ values.append("True")
+ elif val == False or pattern_non.match(val) or val == "False":
+ values.append("False")
+ else:
+ values.append("None")
+ self.textePy += nom + "= [" + ",".join(values) + "],"
+ return
+
+ if valeur == None:
+ return
+ newVal = []
+ for v in valeur:
+ try:
+ v = eval(v, {})
+ except:
+ pass
+ if nom in self.TelemacdicoEn:
+ try:
+ v = self.TelemacdicoEn[nom][v]
+ except:
+ pass
+ newVal.append(v)
+ self.textePy += nom + "=" + str(newVal) + ","
+
+ def tri(self, listeIn):
+ if len(listeIn) == 1:
+ return listeIn
+ if self.ordreDesCommandes == None:
+ return listeIn
+ listeOut = [
+ listeIn[0],
+ ]
+ for k in listeIn[1:]:
+ # k=str(self.dicoFrancaisAnglais[kF])
+ ordreK = self.ordreDesCommandes.index(k)
+ i = 0
+ while i < len(listeOut):
+ # ordreI=self.ordreDesCommandes.index(self.dicoFrancaisAnglais[listeOut[i]])
+ ordreI = self.ordreDesCommandes.index(listeOut[i])
+ if ordreK < ordreI:
+ break
+ i = i + 1
+ # listeOut.insert(i,kF)
+ listeOut.insert(i, k)
+ return listeOut
--- /dev/null
+# Copyright (C) 2007-2022 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from Accas.extensions.eficas_translation import tr
+
+# import traceback
+# traceback.print_stack()
+
+from Accas.IO.convert.convert_python import Pythonparser
+
+
+def entryPoint():
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {"name": "pythonUQ", "factory": pythonUQParser}
+
+
+class pythonUQParser(Pythonparser):
+ """
+ This converter works like Pythonparser, except that it also initializes all
+ links between deterministic and probabilistic variables
+ """
+
+ def convert(self, outformat, appliEficas=None):
+ text = Pythonparser.convert(self, outformat, appliEficas)
+ return text
+
+ def traitementApresLoad(self, jdc):
+ debug = 0
+ if debug:
+ print("traitementApresLoad")
+ etapeIncertitude = jdc.getEtapesByName("ExpressionIncertitude")
+ if etapeIncertitude == []:
+ return
+
+ incertitudeInput = etapeIncertitude[0].getChildOrChildInBloc("Input")
+ self.lesVariablesInput = incertitudeInput[0].getChildOrChildInBloc(
+ "VariableProbabiliste"
+ )
+ for mc in self.lesVariablesInput:
+ # if debug : print (mc,'mc')
+ mcVDPath = mc.getChild("MCPath").valeur
+ if debug:
+ print(mcVDPath)
+ # a modifier lorsque le MCPath comprendra le nom des OPERs
+ if not (mcVDPath):
+ mc.parent.suppentite(mc)
+ break # on admet ici que le . comm n est pas valide
+ mcModelVariable = mc.getChild("ModelVariable")
+ mcModelVariable.definition.addInto(mcModelVariable.valeur)
+ # try :
+ # mcObjectName=mc.getChild('ObjectName')
+ # mcObjectName.changeStatut('f')
+ # except :
+ # pass
+ mcCherche = jdc.getObjetByMCPath(mcVDPath)
+ if not (mcCherche):
+ mc.parent.suppentite(mc)
+ break # on admet ici que le . comm n est pas valide
+ if debug:
+ print(mcCherche)
+ if mc.nature == "MCFACT":
+ mc[0].variableDeterministe = mcCherche
+ mcCherche.variableProbabiliste = mc[0]
+ else:
+ mc.variableDeterministe = mcCherche
+ mcCherche.variableProbabiliste = mc[0]
+ mcCherche.definition.siValide = mcCherche.changeValeursRefUQ
+ mcCherche.associeVariableUQ = True
+ itemConsigne = mc.getChild("Consigne")
+ itemConsigne.setValeur(
+ "la valeur entrée pour {} est {}".format(
+ mcCherche.nom, mcCherche.valeur
+ )
+ )
--- /dev/null
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import re
+from Accas.extensions.eficas_translation import tr
+
+# import traceback
+# traceback.print_stack()
+
+from Accas.extensions import localisation
+from Accas.processing import P_CR
+from Accas.IO.convert.convert_UQPython import pythonUQParser
+
+
+def entryPoint():
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {"name": "xml", "factory": XMLparser}
+
+
+class XMLparser:
+ """
+ This converter works like Pythonparser, except that it reads XML file
+ """
+
+ def __init__(self, cr=None):
+ # print("dans XML convert")
+ self.text = ""
+ if cr:
+ self.cr = cr
+ else:
+ self.cr = P_CR.CR(
+ debut="CR convertisseur format XML", fin="fin CR format XML"
+ )
+
+ def readfile(self, filename):
+ self.filename = filename
+ try:
+ with open(filename) as fd:
+ self.text = fd.read()
+ except:
+ self.cr.exception(tr("Impossible d'ouvrir le fichier %s", str(filename)))
+ self.cr.fatal(tr("Impossible d'ouvrir le fichier %s", str(filename)))
+ return
+
+ def convert(self, outformat, appliEficas=None):
+ # ici on ne fait rien
+ # on le fera a la creation du JDC
+ try:
+ return self.text
+ except Exception as e:
+ # Erreur lors de la conversion
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ self.cr.exception(
+ tr("Impossible de convertir le fichier XML\n %s", "".join(l))
+ )
+ return ""
--- /dev/null
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from Accas.IO.convert.convert_python import Pythonparser
+from Accas.processing import P_CR
+
+
+def entryPoint():
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {"name": "dico", "factory": Dicoparser}
+
+
+class Dicoparser(Pythonparser):
+ """
+ This converter initializes model variable from a python dictionnary
+ """
+
+ def __init__(self, cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le
+ # compte-rendu standard
+ self.text = ""
+ self.textePy = ""
+ if cr:
+ self.cr = cr
+ else:
+ self.cr = P_CR.CR(
+ debut="CR convertisseur format dico", fin="fin CR format dico"
+ )
+
+ def readfile(self, filename):
+ self.filename = filename
+ try:
+ with open(filename) as fd:
+ self.text = fd.read()
+ except:
+ self.cr.exception(tr("Impossible d'ouvrir le fichier %s", str(filename)))
+ self.cr.fatal(tr("Impossible d'ouvrir le fichier %s", str(filename)))
+ return
+
+ def convert(self, outformat, appli=None):
+ monTexteDico = {}
+ exec(self.text, globals(), monTexteDico)
+ if len(monTexteDico.keys()) != 1:
+ self.cr.exception(tr("Impossible de traiter le fichier %s", str(filename)))
+ self.cr.fatal(tr("Impossible de traiter le fichier %s", str(filename)))
+ return
+ self.textePy = ""
+ monDico = monTexteDico[monTexteDico.keys()[0]]
+ for commande in monDico:
+ valeurs = monDico[commande]
+ if valeurs.has_key("NomDeLaSdCommande"):
+ # cas d un oper
+ self.textePy += valeurs["NomDeLaSdCommande"] + " = " + commande + "("
+ del valeurs["NomDeLaSdCommande"]
+ else:
+ self.textePy += commande + "("
+ for mot in valeurs:
+ if isinstance(valeurs[mot], dict):
+ self.traiteMCFact(mot, valeurs[mot])
+ else:
+ self.textePy += mot + " = " + str(valeurs[mot]) + ","
+ self.textePy += ");\n" # fin de la commande
+ return self.textePy
+
+ def traiteMCFact(self, mot, valeurs):
+ self.textePy += mot + "=_F("
+ for mot in valeurs:
+ if isinstance(valeurs[mot], dict):
+ self.traiteMCFact(mot, valeurs[mot])
+ else:
+ self.textePy += mot + " = " + str(valeurs[mot]) + ","
+ self.textePy += "),"
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin convertisseur de fichier
+ au format python pour EFICAS.
+
+ Un plugin convertisseur doit fournir deux attributs de classe :
+ extensions et formats et deux methodes : readfile,convert.
+
+ L'attribut de classe extensions est une liste d'extensions
+ de fichiers preconisees pour ce type de format. Cette information
+ est seulement indicative.
+
+ L'attribut de classe formats est une liste de formats de sortie
+ supportes par le convertisseur. Les formats possibles sont :
+ eval, dict ou exec.
+ Le format eval est un texte source Python qui peut etre evalue. Le
+ resultat de l'evaluation est un objet Python quelconque.
+ Le format dict est un dictionnaire Python.
+ Le format exec est un texte source Python qui peut etre execute.
+
+ La methode readfile a pour fonction de lire un fichier dont le
+ nom est passe en argument de la fonction.
+ - convertisseur.readfile(nom_fichier)
+
+ La methode convert a pour fonction de convertir le fichier
+ prealablement lu dans un objet du format passe en argument.
+ - objet=convertisseur.convert(outformat)
+
+ Ce convertisseur supporte le format de sortie exec
+
+"""
+
+import sys, traceback
+from builtins import str
+from builtins import object
+
+from .parseur_python import PARSEUR_PYTHON
+from Accas.processing import P_CR
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+
+def entryPoint():
+ """
+ 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": Pythonparser,
+ }
+
+
+class Pythonparser(object):
+ """
+ Ce convertisseur lit un fichier au format python avec la
+ methode readfile : convertisseur.readfile(nom_fichier)
+ et retourne le texte au format outformat avec la
+ methode convertisseur.convert(outformat)
+
+ Ses caracteristiques principales sont exposees dans 2 attributs
+ de classe :
+ - extensions : qui donne une liste d'extensions de fichier preconisees
+ - formats : qui donne une liste de formats de sortie supportes
+ """
+
+ # Les extensions de fichier preconisees
+ extensions = (".py",)
+ # Les formats de sortie supportes (eval dict ou exec)
+ # Le format exec est du python executable (commande exec) converti avec PARSEUR_PYTHON
+ # Le format execnoparseur est du python executable (commande exec) non converti
+ formats = ("exec", "execnoparseur")
+
+ def __init__(self, cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le
+ # compte-rendu standard
+ self.text = ""
+ if cr:
+ self.cr = cr
+ else:
+ self.cr = P_CR.CR(
+ debut="CR convertisseur format python", fin="fin CR format python"
+ )
+
+ def readfile(self, filename):
+ self.filename = filename
+ try:
+ with open(filename) as fd:
+ self.text = fd.read()
+ except:
+ self.cr.exception(tr("Impossible d'ouvrir le fichier %s", str(filename)))
+ self.cr.fatal(tr("Impossible d'ouvrir le fichier %s", str(filename)))
+ return
+
+ def convert(self, outformat, appliEficas=None):
+ if outformat == "exec":
+ try:
+ # import cProfile, pstats, StringIO
+ # pr = cProfile.Profile()
+ # pr.enable()
+ l = PARSEUR_PYTHON(self.text).getTexte(appliEficas)
+
+ # pr.disable()
+ # s = StringIO.StringIO()
+ # sortby = 'cumulative'
+ # ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
+ # ps.print_stats()
+ # print (s.getValue())
+
+ return l
+ except EficasException:
+ # Erreur lors de la conversion
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ self.cr.exception(
+ tr(
+ "Impossible de convertir le fichier Python qui doit contenir des erreurs.\n\
+ On retourne le fichier non converti. Prevenir la maintenance.\n\n %s",
+ "".join(l),
+ )
+ )
+ # On retourne neanmoins le source initial non converti (au cas ou)
+ return self.text
+ elif outformat == "execnoparseur":
+ return self.text
+ else:
+ raise EficasException(tr("Format de sortie : %s, non supporte", outformat))
+ return None
--- /dev/null
+tables.py:tables.tag
+ python Translate.py -force tables.tag
--- /dev/null
+Pour mettre à jour le parser de fichier au format Asterv5, il faut
+recompiler le fichier tables.tag en faisant :
+ make
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+#!/bin/env python -d
+#!/tools/net/app/Python-1.5.2/bin/python1.5
+
+"""Translate - a first attempt at parsing my little language
+
+Usage: Translate [switches] <infile> [<outfile>]
+
+ -stdout -- write to standard output instead of a file
+ -force -- write to the <outfile> even if it already
+ exists (overwrite any existing file)
+
+ -import -- import tag table from Translate_tags.py,
+ instead of using the internal table
+
+ -compare -- compare the imported and internal tag tables
+ (development option!)
+
+ -test -- use our internal test data and write to stdout
+ -pytag -- use the interpreted tagging engine
+ -debug -- if -pytag, enable its debugger
+ -diag -- enable general debugging
+ Beware that this currently also writes line
+ numbers to the start of each line in the output,
+ so it doesn't emit legal Python...
+
+ -help -- show this text
+ -history -- show the module history
+ -version -- show the module version
+
+If <outfile> is not specified, <infile> will be used with its extension
+replaced by ".py".
+"""
+
+__author__ = """Tibs (Tony J Ibbs)
+tony@lsl.co.uk or tibs@tibsnjoan.demon.co.uk or tibs@bigfoot.com
+http://www.tibsnjoan.demon.co.uk/
+"""
+__version__ = "0.3 (tiepin) of 1999-11-15"
+__history__ = """\
+Originally created 1999-08-13
+
+First released version is 0.2 (bootstrap)/1999-09-09, which gave
+an idea of how the thing would work, and nearly did.
+
+Second released version is 0.3 (tiepin)/1999-11-15, which is sufficient
+to allow the parser used within this utility to be written in the little
+language, translated and then used as such.
+"""
+
+import sys
+import os
+import string
+
+# ............................................................
+# How we want to work things - this is fudge for me in initial development
+if os.name == "posix":
+ # Unix at work
+ DEFAULT_DEBUG = 0
+ DEFAULT_PYTAG = 0
+else:
+ # Windows 95 at home
+ TEXTTOOLS_PATH = "C:\\Program Files\\Python"
+ PYTAG_PATH = "C:\\Program Files\\Python\\TextTools\\Examples"
+ DEFAULT_DEBUG = 0
+ DEFAULT_PYTAG = 0
+
+ if TEXTTOOLS_PATH not in sys.path:
+ print "Adding",TEXTTOOLS_PATH
+ sys.path.append(TEXTTOOLS_PATH)
+
+ if PYTAG_PATH not in sys.path:
+ print "Adding",PYTAG_PATH
+ sys.path.append(PYTAG_PATH)
+# ............................................................
+
+# Import the TextTools themselves
+# - I'm not personally too keen on import *, but it seems to be
+# the recommended thing, so I'll leave it for now...
+try:
+ from TextTools import *
+except:
+ from mx.TextTools import *
+ #from TextTools.Constants.TagTables import *
+ #from TextTools.Constants.Sets import *
+
+\f
+# ------------------------------------------------------------
+# Useful little constants for unpicking the parsed tuples
+OBJECT = 0
+LEFT = 1
+RIGHT = 2
+SUBLIST = 3
+
+# We want to align inline comments when possible - so this is
+# the column at which we will try to place their "#" marks...
+COMMENT_COLUMN = 40
+
+# Are we (generally) debugging?
+DEBUGGING = 0
+
+# Do we want a comma after the last tuple (or item) in a table?
+WANT_LAST_COMMA = 1
+
+\f
+# ------------------------------------------------------------
+def define_tagtable():
+ """Returns our tag table, if we're not importing it."""
+
+ # We are not, initially, going to try for anything very sophisticated
+ # - just something that will get us bootstrapped, so that I can use the
+ # "little language" to write more sophisticated stuff (without having
+ # to worry about dropped commas between tuples, and so on!)
+
+
+ # Whitespace is always useful
+ t_whitespace = (None,AllIn,' \t')
+ t_opt_whitespace = t_whitespace + (+1,)
+
+ # Comments are fairly simple
+ t_comment = ('comment',Table,
+ ((None,Is,'#'),
+ (None,AllNotIn,'\n\r',MatchOk))
+ )
+
+ # We care about the "content" of the indentation at the start of a line,
+ # but note that it is optional
+ t_indent = ('indent',AllIn,' \t')
+ t_indentation = t_indent + (+1,) # zero indentation doesn't show
+
+ # A string is text within single or double quotes
+ # (of course, this is an oversimplification, because we should also
+ # deal with things like "This is a \"substring\"", and it would be
+ # nice to be able to cope with triple-quoted strings too, but it
+ # will do for a start)
+
+ # Major bug - doesn't recognised zero length strings...
+ # (since "AllNotIn" must match at least one character)
+ t_string = ('str',Table,
+ ((None,Is,"'",+3,+1),
+ ('text',AllNotIn,"'"),
+ (None,Is,"'",MatchFail,MatchOk),
+ (None,Is,'"'),
+ ('text',AllNotIn,'"'),
+ (None,Is,'"'),
+ ))
+
+ # An integer is a series of digits...
+ t_integer = ('int',AllIn,number)
+
+ t_signed_integer = ('signed_int',Table,
+ (('sign',Is,"+",+1,+2),
+ ('sign',Is,"-",+1,+1),
+ t_integer
+ ))
+
+ # Remember to be careful to specify the LONGEST possible match first,
+ # so that we try for "IsIn" before we try for "Is" (because "IsIn"
+ # would *match* "Is", leaving us with a spurious "In" hanging around...)
+ t_operation = ('op',Table,
+ (('op',Word,"AllInSet", +1,MatchOk),
+ ('op',Word,"AllIn", +1,MatchOk),
+ ('op',Word,"AllNotIn", +1,MatchOk),
+ ('op',Word,"CallArg", +1,MatchOk),
+ ('op',Word,"Call", +1,MatchOk),
+ ('op',Word,"EOF", +1,MatchOk),
+ ('op',Word,"Fail", +1,MatchOk),
+ ('op',Word,"IsInSet", +1,MatchOk),
+ ('op',Word,"IsIn", +1,MatchOk),
+ ('op',Word,"IsNotIn", +1,MatchOk),
+ ('op',Word,"IsNot", +1,MatchOk),
+ ('op',Word,"Is", +1,MatchOk),
+ ('op',Word,"Jump", +1,MatchOk),
+ ('op',Word,"LoopControl",+1,MatchOk),
+ ('op',Word,"Loop", +1,MatchOk),
+ ('op',Word,"Move", +1,MatchOk),
+ ('op',Word,"NoWord", +1,MatchOk), # alias for WordStart
+ ('op',Word,"Skip", +1,MatchOk),
+ ('op',Word,"SubTableInList",+1,MatchOk),
+ ('op',Word,"SubTable", +1,MatchOk),
+ ('op',Word,"sFindWord", +1,MatchOk),
+ ('op',Word,"sWordStart", +1,MatchOk),
+ ('op',Word,"sWordEnd", +1,MatchOk),
+ ('op',Word,"TableInList",+1,MatchOk),
+ ('op',Word,"Table", +1,MatchOk),
+ ('op',Word,"WordStart", +1,MatchOk),
+ ('op',Word,"WordEnd", +1,MatchOk),
+ ('op',Word,"Word", MatchFail,MatchOk),
+ ))
+
+ # Python keywords
+ t_keyword = ('keyword',Table,
+ ((None,Word,"and", +1,+28),
+ (None,Word,"assert", +1,+27),
+ (None,Word,"break", +1,+26),
+ (None,Word,"class", +1,+25),
+ (None,Word,"continue",+1,+24),
+ (None,Word,"def", +1,+23),
+ (None,Word,"del", +1,+22),
+ (None,Word,"elif", +1,+21),
+ (None,Word,"else", +1,+20),
+ (None,Word,"except", +1,+19),
+ (None,Word,"exec", +1,+18),
+ (None,Word,"finally", +1,+17),
+ (None,Word,"for", +1,+16),
+ (None,Word,"from", +1,+15),
+ (None,Word,"global", +1,+14),
+ (None,Word,"if", +1,+13),
+ (None,Word,"import", +1,+12),
+ (None,Word,"in", +1,+11),
+ (None,Word,"is", +1,+10),
+ (None,Word,"lambda", +1,+9),
+ (None,Word,"not", +1,+8),
+ (None,Word,"or", +1,+7),
+ (None,Word,"pass", +1,+6),
+ (None,Word,"print", +1,+5),
+ (None,Word,"raise", +1,+4),
+ (None,Word,"return", +1,+3),
+ (None,Word,"try", +1,+2),
+ (None,Word,"while", MatchFail,+1),
+ # In order to not recognise things like "in_THIS_CASE"
+ # we must check that the next character is not legitimate
+ # within an identifier
+ (None,IsIn,alpha+'_'+number,+1,MatchFail),
+ # If it wasn't another identifier character, we need to
+ # unread it so that it can be recognised as something else
+ # (so that, for instance, "else:" is seen as "else" followed
+ # by ":")
+ (None,Skip,-1)
+ ))
+
+ # Do the same for mxText commands
+ t_mxkeyword = ('mxKeyword',Table,
+ (t_operation,
+ (None,IsIn,alpha+'_'+number,+1,MatchFail),
+ (None,Skip,-1)
+ ))
+
+ # Traditional identifiers
+ t_identifier = ('identifier',Table,
+ (t_keyword + (+1,MatchFail), # don't allow Python keywords
+ t_mxkeyword + (+1,MatchFail), # don't allow mxText commands
+ (None,IsIn,alpha+'_'), # can't start with a digit
+ (None,AllIn,alpha+'_'+number,MatchOk))
+ )
+
+ # We don't yet deal with the following with anything in parentheses,
+ # which means we can't handle functions or command lists, or other
+ # things which "look like" a tuple
+ t_argument = ('arg',Table,
+ (('arg',Word,"Here", +1,MatchOk), # EOF Here, Fail Here
+ ('arg',Word,"ToEOF", +1,MatchOk), # Move ToEOF
+ ('arg',Word,"To", +1,MatchOk), # Jump To
+ ('arg',Word,"ThisTable",+1,MatchOk), # [Sub]Table ThisTable
+ ('arg',Word,"back", +1,MatchOk), # Skip back
+ ('arg',Word,"Break", +1,MatchOk), # LoopControl Break
+ ('arg',Word,"Reset", +1,MatchOk), # LoopControl Reset
+ t_string + (+1,MatchOk), # e.g., Word "Fred"
+ t_signed_integer + (+1,MatchOk), # e.g., Skip -4, Move 3
+ t_identifier # e.g., Table Fred
+ ))
+
+ t_plus = ('plus',Table,
+ (t_opt_whitespace,
+ (None,Is,"+"),
+ t_opt_whitespace
+ ))
+
+ # Arguments can contain "+"
+ t_plus_arg = ('plusarg',Table,
+ (t_argument, # start with a single argument
+ t_plus + (MatchOk,), # if we have a "+"
+ t_argument, # then we expect another argument
+ (None,Jump,To,-2), # then look for another "+"
+ ))
+
+ # Match, for example:
+ # <fred>
+ t_label = ('label',Table,
+ ((None,Is,"<"),
+ t_identifier,
+ (None,Is,">")
+ ))
+
+ # Targets for Jump and F:/T:
+ t_target = ('target',Table,
+ (('tgt',Word,"next", +1,MatchOk),
+ ('tgt',Word,"previous", +1,MatchOk),
+ ('tgt',Word,"repeat", +1,MatchOk),
+ ('tgt',Word,"MatchOk", +1,MatchOk),
+ ('tgt',Word,"MatchOK", +1,MatchOk), # For kindness sake
+ ('tgt',Word,"MatchFail",+1,MatchOk),
+ t_label
+ ))
+
+ # A value is either an identifier, or a string, or an integer
+ t_value = ('val',Table,
+ (t_identifier +(+1,MatchOk),
+ t_string +(+1,MatchOk),
+ t_integer
+ ))
+
+ # An assignment is (optionally) used in Tuple and Table definitions...
+ t_assignment = ('assignment',Table,
+ (t_value,
+ t_opt_whitespace,
+ (None,Is,'='),
+ ))
+
+ # A common error when writing tuples is to miss off the "=" sign
+ # - the following is used in diagnosing that (see t_bad_tuple below)
+ # (it's useful to have something with identical structure to the
+ # "real thing")
+ t_bad_tagobj = ('tagobj',Table,
+ (t_string,
+ ))
+
+ t_bad_assignment = ('assignment',Table,
+ (t_value,
+ ))
+
+ # This is the line that starts the definition of a single tuple.
+ # For the moment, restrict what it gets assigned to to a simple identifier.
+ # Match, for example:
+ # Fred is:
+ t_tupleblock = ('tupleblock',Table,
+ (t_identifier,
+ t_whitespace,
+ (None,Word,"is:")
+ ))
+
+ # This is the line that starts a new table or sub-table.
+ # For the moment, we only cope with full Tables.
+ # NOTE that this is used for the "outer" declaration of a tag table,
+ # and also for the "inner" declaration of an inner table or sub-table.
+ # The discrimination between these is done after initial parsing.
+ # Match, for example:
+ # 'keyword' = Table is: (inner)
+ # tagtable = Table is: (outer)
+ t_tableblock = ('tableblock',Table,
+ (t_assignment + (+2,+1), # left hand side is optional
+ t_opt_whitespace,
+ ('type',Word,"Table",+1,+2), # Either "Table"
+ ('type',Word,"SubTable"), # or "SubTable" is required
+ t_whitespace, # whitespace is required
+ (None,Word,"is:") # "is:" is required
+ ))
+
+ # This is the line that starts an "if" block
+ # Match, for example:
+ # Is "Fred":
+ # controlsymbol:
+ t_ifblock = ('ifblock',Table,
+ (t_assignment + (+2,+1), # left hand side is optional
+ t_opt_whitespace,
+ t_operation + (+4,+1),
+ t_whitespace,
+ t_plus_arg,
+ (None,Is,":",MatchFail,MatchOk),
+ t_identifier,
+ (None,Is,":")
+ ))
+
+ # Note that we don't allow spaces WITHIN our false and true thingies
+
+ t_onfalse = ('onfalse',Table,
+ (t_whitespace,
+ (None,Word,"F:"),
+ t_target
+ ))
+
+ t_ontrue = ('ontrue',Table,
+ (t_whitespace,
+ (None,Word,"T:"),
+ t_target
+ ))
+
+ # Valid examples are things like:
+ # 'fred' = Is "xxx" F:<wow> T:MatchOk
+ # AllIn jim T:<foundJim>
+ #
+ # For the moment, we're not trying to recognise things in any detail
+ t_tuple = ('tuple',Table,
+ (t_assignment + (+2,+1), # left hand side is optional
+ t_opt_whitespace,
+ t_operation, # operation is required
+ t_whitespace, # for the moment, we always require space here
+ t_plus_arg, # argument is required
+ t_onfalse + (+1,+1), # F:target is optional
+ t_ontrue + (MatchOk,MatchOk) # T:target is also optional
+ ))
+
+ # If the user has defined a "partial" tuple, they might use something
+ # of the form:
+ # match_fred F:MatchFalse T:MatchOk
+ t_tupleplus = ('tupleplus',Table,
+ (t_identifier,
+ t_onfalse + (+1,+1), # F:target is optional
+ t_ontrue + (MatchOk,MatchOk) # T:target is also optional
+ ))
+
+ # Treat Jump To specially - for example:
+ # Jump To <top>
+ # so that they don't have to do the less obvious "Jump To F:<label>"
+ # (although that will still be recognised, of course, for people who
+ # are used to the tag tuple format itself)
+ t_jumpto = ('jumpto',Table,
+ ((None,Word,"Jump"),
+ t_whitespace,
+ (None,Word,"To"),
+ t_whitespace,
+ t_target
+ ))
+
+ # Is it worth coping with these?
+ t_bad_jumpto = ('jumpto',Table,
+ ((None,Word,"Jump",+2), # cope with Jump to
+ (None,Word,"to",MatchFail,+2),
+ (None,Word,"JumpTo"), # and with JumpTo
+ t_target
+ ))
+
+ # The "content" of a line is the bit after any indentation, and before
+ # any comment...
+ # For the moment, we won't try to maintain ANY context, so it is up to the
+ # user of the tuples produced to see if they make sense...
+ t_content = ('content',Table,
+ (t_label + (+1,MatchOk),
+ t_tableblock + (+1,MatchOk), # [<value> =] [Sub]Table is:
+ t_tupleblock + (+1,MatchOk), # <identifier> is:
+ t_ifblock + (+1,MatchOk), # <cmd> <arg>: OR <identifier>:
+ t_jumpto + (+1,MatchOk), # Jump To <target>
+ t_tuple + (+1,MatchOk),
+ t_tupleplus + (+1,MatchOk), # name [F:<label> [T:<label>]]
+ ))
+
+ t_contentline = ('contentline',Table,
+ (t_content, # something that we care about
+ t_opt_whitespace,
+ t_comment +(+1,+1), # always allow a comment
+ (None,IsIn,newline) # the end of the line
+ ))
+
+ # Sometimes, the user (e.g., me) writes:
+ # 'fred' = Table:
+ # instead of:
+ # 'fred' = Table is:
+ # Unfortunately, without the "is", it would get too confusing whether
+ # we actually wanted an if block...
+ t_bad_tableblock = ('tableblock',Table,
+ (t_assignment + (+2,+1), # left hand side is optional
+ t_opt_whitespace,
+ (None,Word,"Table"), # "Table" is required
+ (None,Is,":") # "is" is needed before the ":"
+ ))
+
+ # Sometimes, the use (e.g., me again) write:
+ # 'fred' IsIn jim
+ # instead of:
+ # 'fred' = IsIn jim
+ # Whilst I'm not entirely convinced that "=" is the best character
+ # to use here, I think we do need something!
+ t_bad_tuple = ('tuple',Table,
+ (t_bad_assignment, # obviously we have to have this!
+ t_whitespace, # in which case the whitespace IS needed
+ t_operation, # operation is required
+ t_whitespace, # for the moment, we must have space here
+ t_plus_arg, # argument is required
+ t_onfalse + (+1,+1), # F:target is optional
+ t_ontrue + (MatchOk,MatchOk) # T:target is also optional
+ ))
+
+ # Make some attempt to recognise common errors...
+ t_badcontent = ('badcontent',Table,
+ (t_bad_tableblock +(+1,MatchOk),
+ t_bad_tuple
+ ))
+
+ t_badline = ('badline',Table,
+ (t_badcontent, # something that we sort of care about
+ t_opt_whitespace,
+ t_comment +(+1,+1), # always allow a comment
+ (None,IsIn,newline) # the end of the line
+ ))
+
+ t_emptyline = ('emptyline',Table,
+ (t_opt_whitespace,
+ (None,IsIn,newline) # the end of the line
+ ))
+
+ t_commentline = ('commentline',Table,
+ (t_comment,
+ (None,IsIn,newline) # the end of the line
+ ))
+
+ t_passthruline = ('passthruline',Table,
+ (('passthru',AllNotIn,newline,+1), # owt else on the line
+ (None,IsIn,newline) # the end of the line
+ ))
+
+ # Basically, a file is a series of lines
+ t_line = ('line',Table,
+ (t_emptyline +(+1,MatchOk), # empty lines are simple enough
+ t_indent +(+1,+1), # optional indentation
+ t_commentline +(+1,MatchOk), # always allow a comment
+ t_contentline +(+1,MatchOk), # a line we care about
+ t_badline +(+1,MatchOk), # a line we think is wrong
+ t_passthruline # a line we don't care about
+ ))
+
+ t_file = (t_line,
+ (None,EOF,Here,-1)
+ )
+
+ return t_file
+
+\f
+# ------------------------------------------------------------
+# We'll define some moderately interesting test data
+
+test_data = """\
+# This example isn't *meant* to make any sense!
+# It's just an accumulation of things that got checked for various reasons
+from TextTools import *
+# Some Python code
+a = b;
+fred = 3;
+if a == 1:
+ print "a == 1"
+else:
+ print "a != 1"
+
+# And the rest is our business...
+t_integer is:
+ 'int' = AllIn '0123456789'
+t_integer is:
+ 'int' = AllIn number
+t_indent is:
+ # A comment here is OK
+ <label> # Strangely enough, so is a label
+ 'indent' = AllIn ' \t'
+t_buggy = Table is:
+ 'int' AllIn number # BUGGY LINE (missing "=")
+ (None,"AllIn",number) # BUGGY LINE (an actual tuple)
+ fred = jim # BUGGY LINE (not our business)
+ tagobj F:<op> T:next # label <op> is undefined
+ # The next line is totally empty
+
+ # The next line contains just indentation
+
+ # This line is just a comment
+# And this comment should be JUST after the preceding block...
+t_indentation is: # This should be "= Table is:"
+ t_indent
+ t_indent F:previous
+ t_indent T:previous
+ t_indent F:previous T:previous
+t_deep = Table is:
+ 'a' = SubTable is:
+ SubTable is:
+ 'this' = Table ThisTable
+ t_integer
+t_fred = Table is:
+ <top>
+ AllIn 'a'
+ 'a' = AllIn 'a'
+ 'a' = AllIn 'a' F:previous
+ 'a' = AllIn 'a' T:previous
+ 'a' = AllIn 'a' F:previous T:previous
+ AllIn 'abcd':
+ AllIn 'xyz' F:<later> T:<top>
+ 'a' = AllIn 'abcd':
+ AllIn 'xyz'
+ <later>
+ t_indent:
+ AllIn 'xyz'
+ AllIn number + '_'
+ AllIn number+"_"+alpha
+ Jump To <top>
+"""
+
+\f
+# ------------------------------------------------------------
+# Our own exceptions
+
+class OutsideError(Exception):
+ """The entity is not permitted outside a block."""
+ pass
+
+class IndentError(Exception):
+ """An indentation error has been detected."""
+ pass
+
+class NoIdentifier(Exception):
+ """We're missing an identifier (to assign to)."""
+ pass
+
+\f
+# ------------------------------------------------------------
+def LineFactory(lineno,tagtuple,text):
+ """Take some tagged data and return an appropriate line class.
+
+ lineno -- the line number in the "file". Note that the first line
+ in the file is line 1
+ tagtuple -- a tag tuple for a single line of data
+ text -- the text for the "file". All the "left" and "right" offsets
+ are relative to this text (i.e., it is the entire content
+ of the file)
+
+ The tag tuples we get back from the parser will be of the form:
+
+ ('line',left,right,[
+ ('indent',left,right,None), -- this is optional
+ ('content',left,right,[<data>])
+ ])
+
+ Looking at <type> should enable us to decide what to do with
+ the <data>.
+ """
+
+ # Extract the list of tuples from this 'line'
+ tuples = tagtuple[SUBLIST]
+
+ # First off, do we have any indentation?
+ tup = tuples[0]
+ if tup[OBJECT] == "indent":
+ # This is inefficient, because it actually copies strings
+ # around - better would be to duplicate the calculation
+ # that string.expandtabs does internally...
+ indent_str = string.expandtabs(text[tup[LEFT]:tup[RIGHT]])
+ tuples = tuples[1:]
+ else:
+ indent_str = ""
+ tuples = tuples
+
+ # Now, work out which class we want an instance of
+ # (this is the 'fun' bit)
+
+ type = tuples[0][OBJECT]
+ if type == 'emptyline':
+ return EmptyLine(lineno,indent_str,tuples[0],text)
+ elif type == 'commentline':
+ return CommentLine(lineno,indent_str,tuples[0],text)
+ elif type == 'passthruline':
+ return PassThruLine(lineno,indent_str,tuples[0],text)
+ elif type == 'contentline':
+ # OK - we need to go down another level
+ sublist = tuples[0][SUBLIST]
+
+ # Do we also have an in-line comment?
+ if len(sublist) > 1:
+ comment = sublist[1]
+ else:
+ comment = None
+
+ # And the actual DATA for our line is down yet another level...
+ sublist = sublist[0][SUBLIST]
+ type = sublist[0][OBJECT]
+ if type == 'label':
+ return LabelLine(lineno,indent_str,sublist[0],comment,text)
+ elif type == 'tableblock':
+ return TableBlockLine(lineno,indent_str,sublist[0],comment,text)
+ elif type == 'tupleblock':
+ return TupleBlockLine(lineno,indent_str,sublist[0],comment,text)
+ elif type == 'ifblock':
+ return IfBlockLine(lineno,indent_str,sublist[0],comment,text)
+ elif type == 'tuple':
+ return TupleLine(lineno,indent_str,sublist[0],comment,text)
+ elif type == 'tupleplus':
+ return TuplePlusLine(lineno,indent_str,sublist[0],comment,text)
+ elif type == 'jumpto':
+ return JumpToLine(lineno,indent_str,sublist[0],comment,text)
+ else:
+ raise ValueError,\
+ "Line %d is of unexpected type 'contentline/%s'"%(lineno,
+ type)
+ elif type == 'badline':
+ # OK - we need to go down another level
+ sublist = tuples[0][SUBLIST]
+
+ # Do we also have an in-line comment?
+ if len(sublist) > 1:
+ comment = sublist[1]
+ else:
+ comment = None
+
+ # And the actual DATA for our line is down yet another level...
+ sublist = sublist[0][SUBLIST]
+ type = sublist[0][OBJECT]
+ if type == 'tableblock':
+ return BadTableBlockLine(lineno,indent_str,sublist[0],comment,text)
+ if type == 'tuple':
+ return BadTupleLine(lineno,indent_str,sublist[0],comment,text)
+ else:
+ raise ValueError,\
+ "Line %d is of unexpected type 'badline/%s'"%(lineno,type)
+ else:
+ raise ValueError,"Line %d is of unexpected type '%s'"%(lineno,type)
+
+
+\f
+# ------------------------------------------------------------
+class BaseLine:
+ """The base class on which the various line types depend
+
+ Contains:
+
+ tagtuple -- the tagtuple we (our subclass instance) represent(s)
+ lineno -- the line number in the file (first line is line 1)
+ indent -- our indentation (integer)
+ indent_str -- our indentation (a string of spaces)
+ text -- the text of the "file" we're within
+ class_name -- the name of the actual class this instance belongs to
+ (i.e., the name of the subclass, suitable for printing)
+
+ Some things only get useful values after we've been instantiated
+
+ next_indent -- the indentation of the next line
+ index -- for a line in a block, its index therein
+ """
+
+ def __init__(self,lineno,indent_str,tagtuple,text):
+ """Instantiate a BaseLine.
+
+ lineno -- the line number in the "file". Note that the first line
+ in the file is line 1
+ indent_str -- the indentation of the line (a string of spaces)
+ tagtuple -- the tag tuple for this line of data
+ text -- the text for the "file". All the "left" and "right"
+ offsets are relative to this text (i.e., it is the
+ entire content of the file)
+
+ The content of the tagtuple depends on which of our subclasses
+ is being used. Refer to the relevant doc string.
+ """
+
+ self.tagtuple = tagtuple
+ self.lineno = lineno
+ self.text = text
+
+ self.class_name = self._class_name()
+ self.indent_str = indent_str
+ self.indent = len(indent_str)
+
+ # OK - we don't really know! (but this will do for "EOF")
+ self.next_indent = 0
+
+ # We don't always HAVE a sensible value for this
+ self.index = None
+
+ #if DEBUGGING:
+ # print "Line %3d: %s%s"%(lineno,indent_str,self.class_name)
+
+ def change_indent(self,count=None,spaces=""):
+ """Change our indentation.
+
+ Specify either "count" or "spaces" (if both are given,
+ "count" will be used, if neither is given, then the
+ indentation will be set to zero)
+
+ count -- the number of spaces we're indented by
+ spaces -- a string of spaces
+ """
+ if count:
+ self.indent = count
+ self.indent_str = count * " "
+ else:
+ self.indent_str = spaces
+ self.indent = len(spaces)
+
+ def _class_name(self):
+ """Return a representation of the class name."""
+
+ full_name = "%s"%self.__class__
+ bits = string.split(full_name,".")
+ return bits[-1]
+
+ def starts_block(self):
+ """Return true if we start a new block."""
+ return 0
+
+ def only_in_block(self):
+ """Return true if we can only occur inside a block."""
+ return 0
+
+ def our_business(self):
+ """Return true if we are a line we understand."""
+ return 1
+
+ def __str__(self):
+ return "%3d %s%-10s"%(self.lineno,self.indent_str,self.class_name)
+
+ def _intro(self):
+ """Returns a useful 'introductory' string."""
+ return "%3d %-10s %s"%(self.lineno,self.class_name,self.indent_str)
+
+ def _trunc(self):
+ """Returns a "truncated" representation of our text."""
+
+ text = "%s %s"%(self._intro(),
+ `self.text[self.tagtuple[LEFT]:self.tagtuple[RIGHT]]`)
+
+ if len(text) > 60:
+ return text[:60]+"..."
+ else:
+ return text
+
+ def resolve_labels(self,block):
+ """Called to resolve any labels use in this line.
+
+ block -- the block that contains us
+ """
+ # The default is to do nothing as we don't HAVE any labels...
+ return
+
+ def expand(self,stream,block=None):
+ """Write out the expanded equivalent of ourselves.
+
+ stream -- an object with a "write" method, e.g., a file
+ newline -- true if we should output a terminating newline
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+ """
+
+ if DEBUGGING:
+ stream.write("Line %3d: "%self.lineno)
+
+ stream.write(self.indent_str)
+ stream.write(self.text[self.tagtuple[LEFT]:self.tagtuple[RIGHT]])
+ stream.write(",\n")
+
+ def warning(self,text):
+ """Report a warning message.
+
+ text -- the text to report
+ """
+
+ lines = string.split(text,"\n")
+ print "###WARNING: line %d (%s)"%(self.lineno,self.class_name)
+ for line in lines:
+ print "### %s"%line
+
+ def error(self,text):
+ """Report an error.
+
+ text -- the error text to report
+ """
+
+ lines = string.split(text,"\n")
+ print "###ERROR: line %d (%s)"%(self.lineno,self.class_name)
+ for line in lines:
+ print "### %s"%line
+
+\f
+# ------------------------------------------------------------
+class EmptyLine(BaseLine):
+ """An empty line.
+
+ Note that the indentation of an empty line is taken to be the
+ same as that of the next (non-empty) line. This is because it
+ seems to me that (a) an empty line should not per-se close a
+ block (which it would do if it had indentation 0) and (b) we
+ don't remember any whitespace in an empty line, so the user
+ can't assign an indentation themselves (which is a Good Thing!)
+ """
+
+ def __init__(self,lineno,indent_str,tagtuple,text):
+ """Instantiate an EmptyLine.
+
+ The content of the tagtuple is:
+ None
+ """
+
+ BaseLine.__init__(self,lineno,indent_str,tagtuple,text)
+
+ def expand(self,stream,block=None):
+ """Write out the expanded equivalent of ourselves.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+ """
+
+ if DEBUGGING:
+ stream.write("Line %3d: "%self.lineno)
+
+ # um - there's nothing to do, folks
+ stream.write("\n")
+
+ def our_business(self):
+ """Return true if we are a line we understand."""
+ return 0
+
+ def _trunc(self):
+ """Returns a "truncated" representation of our text."""
+
+ return self._intro()
+
+\f
+# ------------------------------------------------------------
+class CommentLine(BaseLine):
+ """A comment line."""
+
+ def __init__(self,lineno,indent_str,tagtuple,text):
+ """Instantiate a CommentLine.
+
+ The content of the tagtuple is:
+ ('comment',left,right,None)
+ and the demarcated text includes the initial '#' character
+ """
+
+ BaseLine.__init__(self,lineno,indent_str,tagtuple,text)
+
+ # We actually want the next tuple down (so to speak) so that
+ # we lose the trailing newline...
+ tup = self.tagtuple[SUBLIST][0]
+ self.data = self.text[tup[LEFT]:tup[RIGHT]]
+
+ def our_business(self):
+ """Return true if we are a line we understand."""
+ return 0
+
+ def expand(self,stream,block=None):
+ """Write out the expanded equivalent of ourselves.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+ """
+
+ if DEBUGGING:
+ stream.write("Line %3d: "%self.lineno)
+
+ stream.write(self.indent_str)
+ stream.write("%s\n"%self.data)
+
+\f
+# ------------------------------------------------------------
+class PassThruLine(BaseLine):
+ """A line we just pass throught without interpretation."""
+
+ def __init__(self,lineno,indent_str,tagtuple,text):
+ """Instantiate a PassThruLine.
+
+ The content of the tagtuple is:
+ ('passthru',left,right,None)
+ """
+
+ BaseLine.__init__(self,lineno,indent_str,tagtuple,text)
+
+ # We actually want the next tuple down (so to speak) so that
+ # we lose the trailing newline...
+ tup = self.tagtuple[SUBLIST][0]
+ self.data = self.text[tup[LEFT]:tup[RIGHT]]
+
+ def our_business(self):
+ """Return true if we are a line we understand."""
+ return 0
+
+ def expand(self,stream,block=None):
+ """Write out the expanded equivalent of ourselves.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+ """
+
+ if DEBUGGING:
+ stream.write("Line %3d: "%self.lineno)
+
+ if block:
+ err_str = "Unparsed line inside a block"\
+ " - it has been commented out"
+ # Hmm - the following advice is less often useful than I
+ # had hoped - leave it out for now...
+ #if string.find(self.data,",") != -1:
+ # err_str = err_str + "\nCheck for a trailing comma?"
+
+ self.error(err_str)
+
+ # Always output the indentation, 'cos otherwise it looks silly
+ stream.write(self.indent_str)
+
+ if block:
+ stream.write("#[ignored]#")
+
+ stream.write("%s\n"%self.data)
+
+\f
+# ------------------------------------------------------------
+class ContentLine(BaseLine):
+ """A line we have to interpret - another base class.
+
+ Adds the following variables:
+
+ comment -- any in-line comment on this line
+ """
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate a ContentLine.
+
+ comment -- either a comment tuple or None
+
+ The content of the tagtuple is:
+ ('contentline',left,right,
+ [('content',left,right,[<data>]),
+ ('comment',left,right,None) -- optional
+ ])
+ where <data> is used in the internals of one of our subclasses
+ (i.e., it is what is passed down in the "tagtuple" argument)
+ """
+
+ BaseLine.__init__(self,lineno,indent_str,tagtuple,text)
+ self.comment = comment
+
+ # Assume we're not the last "our business" line in a block...
+ self.is_last = 0
+
+ def _write_comment(self,stream,sofar):
+ """Write out the in-line comment string.
+
+ Since we're the only people to call this, we can safely
+ rely on it only being called when there IS a comment tuple
+ to output...
+
+ stream -- an object with a "write" method, e.g., a file
+ sofar -- the number of characters written to the line
+ so far
+ """
+ if sofar < COMMENT_COLUMN:
+ stream.write(" "*(COMMENT_COLUMN - sofar))
+ else:
+ # always write at least one space...
+ stream.write(" ")
+ stream.write(self.text[self.comment[LEFT]:self.comment[RIGHT]])
+
+ def _write_text(self,stream,block):
+ """Write out the main tuple text.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+
+ This should generally be the method that subclasses override.
+ It returns the number of characters written, or -1 if we had
+ an error.
+ """
+ stream.write(self.text[self.tagtuple[LEFT]:self.tagtuple[RIGHT]])
+ return self.tagtuple[RIGHT] - self.tagtuple[LEFT]
+
+ def expand(self,stream,block=None):
+ """Write out the expanded equivalent of ourselves.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+ """
+
+ if DEBUGGING:
+ stream.write("Line %3d: "%self.lineno)
+
+ stream.write(self.indent_str)
+ nchars = self._write_text(stream,block)
+ # Don't write any in-line comment out if we had an error,
+ # as the layout won't work!
+ if nchars > -1 and self.comment:
+ self._write_comment(stream,sofar=nchars+self.indent)
+ stream.write("\n")
+
+\f
+# ------------------------------------------------------------
+class LabelLine(ContentLine):
+ """A line containing a label.
+
+ Contains:
+ label -- our label string
+ """
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate a LabelLine.
+
+ For instance:
+
+ <fred>
+
+ The content of the tagtuple is:
+
+ ('label',left,right,[
+ ('identifier',left,right,None)
+ ])
+ """
+
+ ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
+
+ self.label = self.text[self.tagtuple[LEFT]:self.tagtuple[RIGHT]]
+
+ def _write_text(self,stream,block):
+ """Write out the main tuple text.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+ """
+ # Enough difficult length calculation - let's do this one
+ # the easy way...
+ if DEBUGGING:
+ text = "# Label %s at index %d"%(self.label,self.index)
+ else:
+ text = "# %s"%(self.label) # surely enough for most people...
+ stream.write(text)
+ return len(text)
+
+ def translate(self,index,block):
+ """Return the translation of a use of this label as a target.
+
+ index -- the index of the line which uses the label as a target
+ block -- the Block we are within
+ """
+
+ # Hmm - I don't think this CAN go wrong at this point...
+ return block.translate_label(self.label,self)
+
+ def only_in_block(self):
+ """Return true if we can only occur inside a block."""
+ return 1
+
+\f
+# ------------------------------------------------------------
+class TableBlockLine(ContentLine):
+ """A line starting a table block."""
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate a TableBlockLine.
+
+ For instance:
+
+ "fred" = Table is:
+ Table is:
+
+ This is used for two purposes:
+ 1. To define the actual tag table itself (i.e., at the outer
+ level). Only "Table" is allowed in this instance, but since
+ that is all we recognised for now, we shan't worry about it...
+ 2. To define an inner table (i.e., at an inner level)
+
+ The content of the tagtuple is:
+
+ ('tableblock',left,right,[
+ ('assignment',left,right,[ -- optional if inner
+ ('val',left,right,[
+
+ ('identifier',left,right,[])
+ OR
+ ('str',left,right,[
+ ('text',left,right,None)
+ ])
+ OR
+ ('int',left,right,[])
+
+ ])
+ ])
+ ('type',left,right,[]) -- either "Table" or "SubTable"
+ ])
+
+ NOTE: as an "emergency" measure (so we can `pretend' that a
+ TupleBlock was actually a TableBlock as part of attempted
+ error correction), if tagtuple == ("error",tagobj) then we
+ short-circuit some of the initialisation...
+ """
+
+ ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
+
+ if tagtuple[0] == "error":
+ # We're "bluffing" at the creation of a TableBlock
+ self.tagobj = tagtuple[1]
+ self.is_subtable = 0
+ elif len(self.tagtuple[SUBLIST]) == 1:
+ self.tagobj = "None"
+ tup = self.tagtuple[SUBLIST][0]
+ self.is_subtable = (self.text[tup[LEFT]:tup[RIGHT]] == "SubTable")
+ else:
+ # The first tuple down gives us the "<value> = " string
+ tup = self.tagtuple[SUBLIST][0]
+ # The next tuple down gives us "<value>" which is what we want
+ tup = tup[SUBLIST][0]
+ self.tagobj = self.text[tup[LEFT]:tup[RIGHT]]
+ # Then we have the type of table
+ tup = self.tagtuple[SUBLIST][1]
+ self.is_subtable = (self.text[tup[LEFT]:tup[RIGHT]] == "SubTable")
+
+ def got_tagobj(self):
+ return (self.tagobj != "None")
+
+ def starts_block(self):
+ """Return true if we start a new block."""
+ return 1
+
+ def _write_text(self,stream,block):
+ """Write out the main tuple text.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+
+ It returns the number of characters written, or -1 if we had
+ an error.
+ """
+
+ if block:
+ if self.is_subtable:
+ stream.write("(%s,SubTable,("%self.tagobj)
+ return len(self.tagobj) + 11
+ else:
+ stream.write("(%s,Table,("%self.tagobj)
+ return len(self.tagobj) + 8
+ else:
+ stream.write("%s = ("%self.tagobj)
+ return len(self.tagobj) + 4
+
+\f
+# ------------------------------------------------------------
+class TupleBlockLine(ContentLine):
+ """A line starting a tuple block (i.e., defining a single tuple)
+
+ Contains:
+
+ name -- the "name" of this tuple (i.e., what comes
+ before the "is:")
+ """
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate a TupleBlockLine.
+
+ For instance:
+
+ Fred is:
+
+ The content of the tagtuple is:
+
+ ('tupleblock',left,right,[
+ ('identifier',left,right,None)
+ ])
+ """
+
+ ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
+
+ tup = self.tagtuple[SUBLIST][0]
+ self.name = self.text[tup[LEFT]:tup[RIGHT]]
+
+ def starts_block(self):
+ """Return true if we start a new block."""
+ return 1
+
+ def only_in_block(self):
+ """Return true if we can only occur inside a block."""
+ return 0
+
+ def _write_text(self,stream,block):
+ """Write out the main tuple text.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+
+ It returns the number of characters written, or -1 if we had
+ an error.
+ """
+ # The "\" at the end is somewhat clumsy looking, but the
+ # only obvious way of preserving layout...
+ stream.write("%s = \\"%self.name)
+ return len(self.name) + 5
+
+\f
+# ------------------------------------------------------------
+class IfBlockLine(ContentLine):
+ """A line starting an if block.
+
+ Contains:
+ cmd -- the command within this if block
+ arg -- the argument for said command
+ or:
+ name -- the name within this if block
+ """
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate an IfBlockLine.
+
+ For instance:
+
+ 'jim' = Is "Fred":
+ Is "Fred":
+ fred:
+
+ The content of the tagtuple is:
+
+ ('ifblock',left,right,[
+ ('assignment',left,right,[
+ ('val',left,right,[
+
+ ('identifier',left,right,[])
+ OR
+ ('str',left,right,[
+ ('text',left,right,None)
+ ])
+ OR
+ ('int',left,right,[])
+
+ ])
+ ])
+ ('op',left,right,None),
+ ('arg',left,right,None),
+ ])
+ or:
+ ('ifblock',left,right,[
+ ('op',left,right,None),
+ ('arg',left,right,None),
+ ])
+ or:
+ ('ifblock',left,right,[
+ ('identifier',left,right,None)
+ ])
+ """
+
+ ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
+
+ tuples = self.tagtuple[SUBLIST]
+ if tuples[0][OBJECT] == 'op':
+ tup1 = tuples[0]
+ tup2 = tuples[1]
+ self.tagobj = "None"
+ self.cmd = self.text[tup1[LEFT]:tup1[RIGHT]]
+ self.arg = self.text[tup2[LEFT]:tup2[RIGHT]]
+ self.name = None
+ elif tuples[0][OBJECT] == 'assignment':
+ # The "<value>" in the "<value> = " string is down
+ # one level more than the others
+ tup0 = tuples[0][SUBLIST][0]
+ self.tagobj = self.text[tup0[LEFT]:tup0[RIGHT]]
+ tup1 = tuples[1]
+ tup2 = tuples[2]
+ self.cmd = self.text[tup1[LEFT]:tup1[RIGHT]]
+ self.arg = self.text[tup2[LEFT]:tup2[RIGHT]]
+ self.name = None
+ elif tuples[0][OBJECT] == 'identifier':
+ tup = tuples[0]
+ self.name = self.text[tup[LEFT]:tup[RIGHT]]
+ self.cmd = None
+ self.arg = None
+ self.tagobj = None
+ else:
+ # Hmm - try to continue with anything unexpected
+ tup = tuples[0]
+ self.error("Unexpected IfBlock subtype %s"%tup[OBJECT])
+ self.name = self.text[tup[LEFT]:tup[RIGHT]]
+ self.cmd = None
+ self.arg = None
+ self.tagobj = None
+
+ # Currently, we have one 'special' argument
+ if self.arg == "back": self.arg = "-1"
+
+ # We don't yet know the offset of the "virtual label" at the
+ # end of this if block...
+ self.end_label = None
+
+ def starts_block(self):
+ """Return true if we start a new block."""
+ return 1
+
+ def only_in_block(self):
+ """Return true if we can only occur inside a block."""
+ return 1
+
+ def resolve_labels(self,block):
+ """Called to resolve any labels used in this line.
+
+ block -- the block that contains us
+
+ Note that this only does something the first time it
+ is called - this will be when the IF block's startline
+ is asked to resolve its labels. If it is called again,
+ as a 'normal' line, it will do nothing...
+ """
+ if not self.end_label:
+ self.end_label = "%+d"%(len(block.business)+1)
+
+ def _write_text(self,stream,block):
+ """Write out the main tuple text.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+
+ It returns the number of characters written, or -1 if we had
+ an error.
+ """
+ if not self.end_label:
+ # This should never happen, but just in case, warn the user!
+ self.error("Unable to determine 'onFalse' destination in IF")
+
+ if self.name:
+ stream.write("%s + (%s,+1),"%(self.name,
+ self.end_label or "<undefined>"))
+ return len(self.name) + 20
+ else:
+ stream.write("(%s,%s,%s,%s,+1),"%(self.tagobj,self.cmd,self.arg,
+ self.end_label or "<undefined>"))
+ return len(self.tagobj) + len(self.cmd) + len(self.arg) + \
+ len(self.end_label) + 20
+
+\f
+# ------------------------------------------------------------
+class TupleLine(ContentLine):
+ """A line containing a basic tuple.
+
+
+ Contains:
+ tagobj -- optional
+ cmd -- the command
+ arg -- the argument
+ ontrue -- what to do if true
+ onfalse -- ditto false
+ """
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate a TupleLine.
+
+ The content of the tagtuple is:
+
+ ('tuple',left,right,[
+ ('tagobj',left,right,[ -- optional
+ ('str',left,right,[
+ ('text',left,right,None)
+ ])
+ ])
+ ('op',left,right,None),
+ ('arg',left,right,None),
+ ('onfalse',left,right,[ -- optional
+ ('target',left,right,[
+ ('tgt',left,right,None)
+ ]),
+ ('ontrue',left,right,[ -- optional
+ ('target',left,right,[
+ ('tgt',left,right,None)
+ ])
+ ])
+ ])
+ """
+
+ ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
+
+ self.unpack()
+
+
+ def unpack(self):
+ """Unpack our contents from our tagtuple."""
+
+ # This is doubtless not the most efficient way of doing this,
+ # but it IS relatively simple...
+ dict = {}
+ #for key in ("assignment","op","arg","onfalse","ontrue"):
+ for key in ("assignment","op","plusarg","onfalse","ontrue"):
+ dict[key] = None
+
+ tuples = self.tagtuple[SUBLIST]
+ for item in tuples:
+ name = item[OBJECT]
+ if name == "onfalse" or name == "ontrue" or name == "assignment":
+ # For these, we need to go "down one level" for our data
+ tup = item[SUBLIST][0]
+ dict[name] = (tup[LEFT],tup[RIGHT])
+ else:
+ dict[name] = (item[LEFT],item[RIGHT])
+
+ # The tag object is optional
+ if dict["assignment"]:
+ left,right = dict["assignment"]
+ self.tagobj = self.text[left:right]
+ else:
+ self.tagobj = "None"
+
+ # The operation (command) and argument are required
+ left,right = dict["op"]
+ self.cmd = self.text[left:right]
+
+ #left,right = dict["arg"]
+ left,right = dict["plusarg"]
+ self.arg = self.text[left:right]
+
+ # Currently, we have one 'special' argument
+ if self.arg == "back": self.arg = "-1"
+
+ # Actually, we don't want the F and T jumps explicit if not
+ # given, since we mustn't output them for a single tuple if
+ # they're not given (so they can be "added in" later on)
+ if dict["onfalse"]:
+ left,right = dict["onfalse"]
+ self.onfalse = self.text[left:right]
+ else:
+ self.onfalse = None # "MatchFail"
+ if dict["ontrue"]:
+ left,right = dict["ontrue"]
+ self.ontrue = self.text[left:right]
+ else:
+ self.ontrue = None # "next"
+
+ def only_in_block(self):
+ """Return true if we can only occur inside a block."""
+ return 1
+
+ def resolve_labels(self,block):
+ """Called to resolve any labels use in this line.
+
+ block -- the block that contains us
+ """
+ if self.onfalse:
+ self.onfalse = block.translate_label(self.onfalse,self)
+ if self.ontrue:
+ self.ontrue = block.translate_label(self.ontrue,self)
+
+ def _write_text(self,stream,block):
+ """Write out the main tuple text.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+
+ It returns the number of characters written, or -1 if we had
+ an error.
+ """
+
+ # Start with the stuff we must have...
+ stream.write("(%s,%s,%s"%(self.tagobj,self.cmd,self.arg))
+ length = len(self.tagobj) + len(self.cmd) + len(self.arg) + 3
+
+ if self.ontrue:
+ if not self.onfalse:
+ # OK, we didn't get an explicit F, but because it comes
+ # before the T jump in the tuple, we need to fake it
+ # anyway...
+ stream.write(",%s,%s)"%("MatchFail",self.ontrue))
+ length = length + len("MatchFail") + len(self.ontrue) + 3
+ else:
+ # We had both F and T
+ stream.write(",%s,%s)"%(self.onfalse,self.ontrue))
+ length = length + len(self.onfalse) + len(self.ontrue) + 3
+ elif self.onfalse:
+ # We only had F. We shan't "fake" the T jump, *just* in case
+ # the user is defining a single tuple that they'll add the
+ # T jump to later on (although that *is* a bit dodgy, I think)
+ # [[The option would be to "fake" it if we're IN a block - I may
+ # go for that approach later on]]
+ stream.write(",%s)"%self.onfalse)
+ length = length + len(self.onfalse) + 2
+ else:
+ # Neither F nor T - so don't write the defaults for either,
+ # in case this is a top level tuple they're going to add to
+ # later on...
+ # [[Comments as for the case above, I think]]
+ stream.write(")")
+ length = length + 1
+
+ if block and not self.is_last:
+ stream.write(",")
+ length = length + 1
+
+ return length
+\f
+# ------------------------------------------------------------
+class TuplePlusLine(ContentLine):
+ """A line containing a tuple "plus" (e.g., "fred + (+1,+1)").
+
+ Contains:
+
+ name -- the name/identifier
+ ontrue -- what to do if true
+ onfalse -- ditto false
+ """
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate a TuplePlusLine.
+
+ <identifier> + (onF,onT)
+
+ The content of the tagtuple is:
+
+ ('tupleplus',left,right,[
+ ('identifier',left,right,None)
+ ('onfalse',left,right,[ -- optional
+ ('target',left,right,[
+ ('tgt',left,right,None)
+ ]),
+ ('ontrue',left,right,[ -- optional
+ ('target',left,right,[
+ ('tgt',left,right,None)
+ ])
+ ])
+ ])
+ """
+
+ ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
+
+ self.unpack()
+
+
+ def unpack(self):
+ """Unpack our contents from our tagtuple."""
+
+ # This is doubtless not the most efficient way of doing this,
+ # but it IS relatively simple...
+ dict = {}
+ for key in ("identifier","onfalse","ontrue"):
+ dict[key] = None
+
+ tuples = self.tagtuple[SUBLIST]
+ for item in tuples:
+ name = item[OBJECT]
+ if name == "onfalse" or name == "ontrue":
+ # For these, we need to go "down one level" for our data
+ tup = item[SUBLIST][0]
+ dict[name] = (tup[LEFT],tup[RIGHT])
+ else:
+ dict[name] = (item[LEFT],item[RIGHT])
+
+ # Start with the identifier
+ left,right = dict["identifier"]
+ self.name = self.text[left:right]
+
+ # Actually, we don't want the F and T jumps explicit if not
+ # given, since we mustn't output them for a single tuple if
+ # they're not given (so they can be "added in" later on)
+ if dict["onfalse"]:
+ left,right = dict["onfalse"]
+ self.onfalse = self.text[left:right]
+ else:
+ self.onfalse = None # "MatchFail"
+ if dict["ontrue"]:
+ left,right = dict["ontrue"]
+ self.ontrue = self.text[left:right]
+ else:
+ self.ontrue = None # "next"
+
+ def only_in_block(self):
+ """Return true if we can only occur inside a block."""
+ return 1
+
+ def resolve_labels(self,block):
+ """Called to resolve any labels use in this line.
+
+ block -- the block that contains us
+ """
+ if self.onfalse:
+ self.onfalse = block.translate_label(self.onfalse,self)
+ if self.ontrue:
+ self.ontrue = block.translate_label(self.ontrue,self)
+
+ def _write_text(self,stream,block):
+ """Write out the main tuple text.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+
+ It returns the number of characters written, or -1 if we had
+ an error.
+ """
+
+ if not self.onfalse and not self.ontrue:
+ stream.write("%s"%self.name)
+ length = len(self.name)
+ else:
+ # Make a feeble attempt to cause successive such lines to
+ # look neater, by aligning the "+" signs (if we output them)
+ stream.write("%-15s + ("%(self.name))
+ length = max(len(self.name),15) + 4
+ if self.ontrue and self.onfalse:
+ stream.write("%s,%s)"%(self.onfalse,self.ontrue))
+ length = length + len(self.onfalse) + len(self.ontrue) + 2
+ elif self.ontrue:
+ stream.write("MatchFail,%s)"%(self.ontrue))
+ length = length + len(self.ontrue) + 11
+ else:
+ # Don't forget that comma to make this a tuple!
+ stream.write("%s,)"%(self.onfalse))
+ length = length + len(self.onfalse) + 1
+
+ if not self.is_last:
+ stream.write(",")
+ length = length + 1
+
+ return length
+
+\f
+# ------------------------------------------------------------
+class JumpToLine(ContentLine):
+ """A line containing "Jump To <label>"
+
+ Contains:
+
+ name -- the name/identifier
+ onfalse -- the target (which is technically an "on false" jump)
+ """
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate a JumpLine.
+
+ Jump To <label>
+
+ The content of the tagtuple is:
+
+ ('jumpto',left,right,[
+ ('target',left,right,[
+ ('tgt',left,right,None)
+ ]),
+ ])
+ """
+
+ ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
+
+ tup = self.tagtuple[SUBLIST][0]
+ self.onfalse = self.text[tup[LEFT]:tup[RIGHT]]
+
+ def only_in_block(self):
+ """Return true if we can only occur inside a block."""
+ return 1
+
+ def resolve_labels(self,block):
+ """Called to resolve any labels use in this line.
+
+ block -- the block that contains us
+ """
+ self.onfalse = block.translate_label(self.onfalse,self)
+
+ def _write_text(self,stream,block):
+ """Write out the main tuple text.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- used to pass the containing Block down to lines
+ within a block, or None if we're not in a block
+
+ It returns the number of characters written, or -1 if we had
+ an error.
+ """
+
+ stream.write("(None,Jump,To,%s)"%(self.onfalse))
+ length = len(self.onfalse) + 15
+
+ if not self.is_last:
+ stream.write(",")
+ length = length + 1
+
+ return length
+
+\f
+# ------------------------------------------------------------
+class BadTableBlockLine(TableBlockLine):
+ """We think they MEANT this to be a table block line."""
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate a BadTableBlockLine.
+
+ For instance:
+
+ "fred" = Table:
+ Table:
+ """
+ TableBlockLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
+ self.error("Suspected missing 'is' before the colon\n"
+ "pretending it's there")
+
+\f
+# ------------------------------------------------------------
+class BadTupleLine(TupleLine):
+ """We think they MEANT this to be a tuple line."""
+
+ def __init__(self,lineno,indent_str,tagtuple,comment,text):
+ """Instantiate a BadTupleLine.
+
+ For instance:
+
+ "fred" = IsIn "abc"
+ """
+ TupleLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
+ self.error("Suspected missing '=' between tag object and command\n"
+ "pretending it's there")
+
+\f
+# ------------------------------------------------------------
+class Block(ContentLine):
+ """This class represents a "block".
+
+ A "block" is a section of code which starts with a line ending in
+ a colon (":"), with the next line and subsequent lines ("in" the
+ block) having an extra indent. The block ends when a dedent is
+ encountered.
+
+ Each instance "eats" lines from the input until (if) it finds the first
+ "sub" block. That then "eats" lines until it finds its own end, and
+ then hands control back to the first instance, which does the same thing
+ again, and so on.
+
+ Note that we "pretend" to be a content line - it is convenient to
+ look like a line class, so that line processing can cope with us,
+ and indeed what we do is "pretend" to be a clone of our start line
+ with some extra information...
+
+ Contains:
+ startline -- the line that "introduces" this block
+ items -- a list of the lines and blocks within this block
+ label_dict -- a dictionary of {label name : line index}
+ inner_indent -- the indentation of our "inner" lines
+ outer -- true if we are an "outer" block
+ (i.e., not contained within another block)
+ """
+
+ def __init__(self,startline=None,outer=0,file=None):
+ """Instantiate a new block.
+
+ startline -- the line that introduces this block
+ outer -- true if we are an outer block
+ file -- the "file" we're reading lines from
+ """
+
+ # Pretend to be our own startline (as a generic)
+ ContentLine.__init__(self,
+ startline.lineno,startline.indent_str,
+ startline.tagtuple,startline.comment,
+ startline.text)
+
+ # But also remember the specifics of the startline
+ self.startline = startline
+
+ # We "fudge" our class name
+ self.class_name = self._block_class_name(startline)
+
+ self.outer = outer
+ self.file = file
+
+ # If we're an outer table block, do we have a tagobj?
+ if self.startline.class_name == "TableBlockLine" and outer:
+ if not self.startline.got_tagobj():
+ raise NoIdentifier,\
+ "Tag table at line %d is not assigned to a variable"%\
+ (self.lineno)
+ elif self.startline.is_subtable:
+ raise OutsideError,\
+ "SubTable is not allowed outside a block at line %d"%\
+ (self.lineno)
+
+ self.items = [] # all lines within this block
+ self.business = [] # just those that are "our business"
+ self.label_dict = {} # remember our labels and their locations
+ self.next_index = 0 # 'business' line indices
+ self.inner_indent = None
+
+ # Eat lines until we reach the end of our block...
+ if DEBUGGING: print "%sStart %s"%(self.indent_str,self.class_name)
+ self._eat_lines()
+ self._end_block()
+
+ def _block_class_name(self,startline):
+ """Return a representation of the class name."""
+
+ full_name = "%s"%self.__class__
+ bits = string.split(full_name,".")
+ return "%s/%s"%(bits[-1],startline.class_name)
+
+ def _eat_lines(self):
+ """Eat lines until we run out of block..."""
+
+ while 1:
+ try:
+ nextline = self.file.next()
+ except EOFError:
+ return
+
+ # Check the indentation makes sense...
+ if self.inner_indent:
+ # We already know how much our block is indented
+ # - is this line part of the block?
+ if nextline.indent < self.inner_indent:
+ # Apparently a dedent - is it what we expect?
+ if nextline.indent <= self.indent:
+ # Unread that line - it isn't one of ours!
+ self.file.unget()
+ return
+ else:
+ raise IndentError,\
+ "Line %d (%s) is indented less than the previous "\
+ "line, but its indentation doesn't match the "\
+ "start of the block at line %d"%\
+ (nextline.lineno,nextline.class_name,self.lineno)
+ elif nextline.indent > self.inner_indent:
+ # A spurious indent
+ # (note that doing this stops us from coping with,
+ # for instance, things in (..), but then we also don't
+ # cope with any form of continued line, or lots of other
+ # things, so let's not worry too much for now!)
+ raise IndentError,\
+ "Line %d (%s) is indented more than the previous line"%\
+ (nextline.lineno,nextline.class_name)
+ else:
+ # This is the first line of the (inside of) the block
+ # - check its indentation makes sense...
+ self.inner_indent = nextline.indent
+ if self.inner_indent <= self.indent:
+ raise IndentError,\
+ "Line %d (%s) should be indented more than line %d (%s)"%\
+ (nextline.lineno,nextline.class_name,
+ self.lineno,self.startline.class_name)
+
+ # Is it a line or the start of another block?
+ if nextline.starts_block():
+ # Heh - it's the start of an inner block - add it
+ # (remember that instantiating it causes it to
+ # "eat" the lines that belong to it)
+ self.items.append(Block(startline=nextline,
+ outer=0,file=self.file))
+ else:
+ self.items.append(nextline)
+
+ def _end_block(self):
+ """End our block"""
+
+ if DEBUGGING: print "%sEnd %s"%(self.indent_str,self.class_name)
+
+ # If we're a tuple block, we should only have one line...
+ # (that is, one "business" line)
+ if self.startline.class_name == "TupleBlockLine" and \
+ len(self.items) > 1:
+ # Are all but one of them not "our business"?
+ count = 0
+ for item in self.items:
+ if item.our_business():
+ count = count + 1
+ if count > 1: break
+ if count > 1:
+ self.error("Tuple declaration can only contain one 'business'"
+ " line, not %d\n"
+ "Assuming it's a table instead (i.e.,"
+ "'Table is:' instead of 'is:')"%len(self.items))
+ # Can we correct this by "pretending" its a table?
+ temp = TableBlockLine(self.startline.lineno,
+ self.startline.indent_str,
+ ("error",self.startline.name),
+ self.startline.comment,
+ self.text)
+ self.startline = temp
+
+ # We've now got all of our lines, and so we can go back over
+ # them, expanding out any IF blocks (whose content is actually
+ # within this block's scope, so who need to have their labels
+ # (come from or go to) in that scope), working out the label
+ # indices, and so on...
+ # This uses "next_index" to calculate the indices of business
+ # lines (needed for label calculation), and also populates the
+ # "business" list with just the items that are "our_business()"
+ if DEBUGGING:
+ print "Expanding IF blocks, sorting out labels, etc."
+
+ temp = self.items
+ self.items = []
+ for item in temp:
+ if item.class_name == "Block/IfBlockLine":
+ self._add(item.startline)
+ for thing in item.items:
+ self._add(thing)
+ else:
+ self._add(item)
+
+ # Go back through our contents and resolve any labels
+ if DEBUGGING:
+ print "%s...processing labels (next_index=%d)"%(self.indent_str,
+ self.next_index)
+ self.startline.resolve_labels(self)
+ # If we're an IF block, we mustn't try to resolve our component
+ # lines' labels, as they're actually in our parent block's scope...
+ if self.startline.class_name != "IfBlockLine":
+ for item in self.items:
+ item.resolve_labels(self)
+
+ # If we're in a block that wants to suppress the comma at the
+ # end of the last item in that block, tell the last item so...
+ # (this is debatable for [Bad]TableBlockLine - it might be
+ # better to leave the last comma there - so we have an option
+ # to determine it...
+ if self.startline.class_name == "TupleBlockLine" or \
+ (not WANT_LAST_COMMA and \
+ (self.startline.class_name == "TableBlockLine" or \
+ self.startline.class_name == "BadTableBlockLine")):
+ if len(self.business) > 0:
+ self.business[-1].is_last = 1
+
+ def _add(self,item):
+ """Add a line or block to our list of items.
+
+ item -- the Line or Block instance to add
+
+ NB: Also adds it to our "business" list if it is our business
+ (and not a label)
+ """
+
+ if item.class_name == "LabelLine":
+ self.label_dict[item.label] = self.next_index
+ if DEBUGGING:
+ print "%sadd [%2d] %s"%(item.indent_str,self.next_index,item)
+ # Might as well give it the index it is labelling
+ item.index = self.next_index
+ self.items.append(item)
+ elif item.our_business():
+ item.index = self.next_index
+ self.items.append(item)
+ self.business.append(item)
+ if DEBUGGING:
+ print "%sadd %2d %s"%(item.indent_str,
+ self.next_index,item)
+ self.next_index = self.next_index + 1
+ else:
+ # It's not something we can assign a sensible index to, so don't
+ if DEBUGGING:
+ print "%sadd xx %s"%(item.indent_str,item)
+ self.items.append(item)
+
+ def translate_label(self,label,line):
+ """Given a label, return its translation.
+
+ label -- either a string of the form "<...>" to look up in
+ this block's label dictionary, or one of the special
+ targets (e.g., next, MatchOk, etc.)
+ line -- the line using this label
+
+ Reports an error and just returns the original "label" if it
+ can't translate it.
+ """
+ if self.label_dict.has_key(label):
+ # How far do we have to jump?
+ offset = self.label_dict[label] - line.index
+ return "%+d"%offset
+ elif label == "MatchOk":
+ return "MatchOk"
+ elif label == "MatchOK":
+ line.warning("Label 'MatchOK' should be spelt 'MatchOk'"
+ " (using 'MatchOk')")
+ return "MatchOk"
+ elif label == "MatchFail":
+ return "MatchFail"
+ elif label == "next":
+ return "+1"
+ elif label == "previous":
+ return "-1"
+ elif label == "repeat":
+ return "0"
+ else:
+ line.error("Undefined label '%s'"%label)
+ return label
+
+ def expand(self,stream,block=None):
+ """Write out the expanded equivalent of ourselves.
+
+ stream -- an object with a "write" method, e.g., a file
+ block -- if we're in a block, this is it, otherwise None
+ """
+
+ self.startline.expand(stream,block=block)
+ for item in self.items[:-1]:
+ item.expand(stream,block=self)
+
+ self.items[-1].expand(stream,block=self)
+
+ # Deal with closing any block parentheses
+ if self.startline.class_name == "TableBlockLine" or \
+ self.startline.class_name == "BadTableBlockLine":
+ if DEBUGGING:
+ stream.write("Line ...: ")
+
+ stream.write(self.indent_str)
+ if self.outer:
+ # Outer block - just close it
+ stream.write(")")
+ else:
+ # Inner block is a Table block, and we need to close both
+ # the tuple-of-tuples, and also the tuple containing the
+ # Table command...
+ stream.write("))")
+ if not self.is_last:
+ stream.write(",")
+ stream.write("\n")
+
+\f
+# ------------------------------------------------------------
+class File:
+ """This is the class that holds our processed data
+
+ Contains:
+ lines -- a list of the line instances for each "line" in our text
+ items -- a list of lines and BLOCKs
+ """
+
+ def __init__(self,tagtuples,text):
+ """Instantiate a File
+
+ tagtuples -- the list of mxTextTools tag tuples generated by
+ parsing the data in "text"
+ text -- the text we parsed
+ """
+
+ self.text = text
+ self.tagtuples = tagtuples
+
+ # Assemble our list of lines
+ print "Pass 1: assembling lines"
+ if DEBUGGING: print "~~~~~~~~~~~~~~~~~~~~~~~~"
+ self.lines = []
+ lineno = 0
+ prevline = None
+ for tagtuple in tagtuples:
+ lineno = lineno + 1
+ thisline = LineFactory(lineno,tagtuple,text)
+
+ if prevline:
+ prevline.next_indent = thisline.indent
+
+ self.lines.append(thisline)
+ prevline = thisline
+
+ #if DEBUGGING: print
+
+ # The indentation of an empty line is taken to be the same
+ # as the indentation of the first following non-empty line
+ # The easiest way to do that is to work backwards through
+ # the list (is it better to take a copy and reverse THAT,
+ # or to reverse our original list twice?)
+ print "Pass 2: sorting out indentation of empty lines"
+ if DEBUGGING: print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+ revlist = self.lines[:]
+ revlist.reverse()
+ indent = 0
+ for line in revlist:
+ if line.class_name == "EmptyLine":
+ line.change_indent(indent)
+ else:
+ indent = line.indent
+ del revlist
+
+ if DEBUGGING:
+ print "Pass 2.5 - the contents of those lines..."
+ print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+ for line in self.lines:
+ print "Line %d %s"%(line.lineno,line.class_name)
+ #print_tuples([line.tagtuple],self.text," ")
+ print
+
+ # Now we need to assemble blocks
+ print "Pass 3: assembling blocks"
+ if DEBUGGING: print "~~~~~~~~~~~~~~~~~~~~~~~~~"
+ self.reset()
+ self.items = []
+
+ while 1:
+ try:
+ item = self.next()
+ except EOFError:
+ break
+
+ if DEBUGGING:
+ print "%sTOP %s"%(item.indent_str,item)
+ if item.starts_block():
+ block = Block(startline=item,outer=1,file=self)
+ self.items.append(block)
+ block.is_last = 1 # Everything at outer level is "last"
+ else:
+ if item.only_in_block():
+ item.error("This line is not allowed outside a block "
+ "- continuing anyway")
+ self.items.append(item)
+ if item.our_business():
+ item.is_last = 1 # Everything at outer level is "last"
+
+ if DEBUGGING: print
+
+
+ def reset(self):
+ """Ensure that the next call of "nextline" returns the first line."""
+ self.index = -1
+
+ def unget(self):
+ """Unread the current line."""
+ self.index = self.index - 1
+ if self.index < 0:
+ self.index = 0
+
+ def next(self):
+ """Retrieve the next line from the list of lines in this "file".
+
+ Raises EOFError if there is no next line (i.e., "end of file")
+ """
+ self.index = self.index + 1
+ try:
+ return self.lines[self.index]
+ except IndexError:
+ # leave the index off the end, so we get EOF again if
+ # we're called again - but there's no point courting overflow...
+ self.index = self.index -1
+ raise EOFError
+
+ def expand(self,stream):
+ """Expand out the result."""
+ for item in self.items:
+ item.expand(stream)
+
+\f
+# ------------------------------------------------------------
+def print_tuples(tuples,text,indent=""):
+ """Print out a list of tuples in a neat form
+
+ tuples -- our tuple list
+ text -- the text it tags
+ indent -- our current indentation
+ """
+
+ # Tuples are of the form:
+ # (object,left_index,right_index,sublist)
+
+ for obj,left,right,sub in tuples:
+ if sub:
+ print "%s%s"%(indent,obj)
+ print_tuples(sub,text,indent+" ")
+ else:
+ # Terminal node - show the actual text we've tagged!
+ print "%s%s = %s"%(indent,obj,`text[left:right]`)
+
+\f
+# ------------------------------------------------------------
+def print_text(text):
+ """Print out text with line numbers."""
+ lines = string.split(text,"\n")
+ lineno = 0
+
+ print "Original text"
+ print "============="
+ for line in lines:
+ lineno = lineno + 1
+ print "%3d: %s"%(lineno,`line`)
+
+\f
+# ------------------------------------------------------------
+def print_usage(argv0):
+ #script_name = string.split(argv0, os.sep)[-1]
+ #print __doc__%(script_name)
+ print argv0
+ print __doc__
+
+\f
+# ------------------------------------------------------------
+def show_tup(indent,nn,tup):
+ ll = []
+ for item in tup:
+ if type(item) == type((1,)) or type(item) == type([]):
+ ll.append("(..)")
+ else:
+ ll.append(`item`)
+
+ if nn:
+ print "%s%d: (%s)"%(indent,nn,string.join(ll,","))
+ else:
+ print "%s(%s)"%(indent,string.join(ll,","))
+
+def comp_sub(indent,one,two):
+ len1 = len(one)
+ if len(two) != len(one):
+ print "%sTuple lengths differ - 1:%d, 2:%d"%(indent,len1,len(two))
+ show_tup(indent,1,one)
+ show_tup(indent,2,two)
+ # If this is all, let's try to continue...
+ len1 = min(len1,len(two))
+
+ for count in range(len1):
+ a = one[count]
+ b = two[count]
+ if type(a) != type(b):
+ print "%sValue types differ, item %d: 1:%s, 2:%s"%(indent,count,
+ type(a),type(b))
+ show_tupe(indent,1,one)
+ show_tupe(indent2,two)
+ return 0
+ if type(a) == type((1,)) or type(a) == type([]):
+ if not comp_sub(indent+" ",a,b):
+ # They're the same at this level, so show only one...
+ show_tup(indent,0,one)
+ return 0
+ else:
+ if a != b:
+ print "%sValues differ, item %d: 1:%s, 2:%s"%(indent,count,
+ `a`,`b`)
+ show_tup(indent,1,one)
+ show_tup(indent,2,two)
+ return 0
+ return 1
+
+def compare_tagtables(one,two):
+ # Each table is made up of tuples of the form
+ # (tagobj,action,arg,onfalse,ontrue)
+ # but if action is Table or SubTable then arg may be a tuple
+ # itself...
+ if comp_sub("",one,two):
+ print "They appear to be the same"
+
+\f
+# ------------------------------------------------------------
+def main():
+ """Used to test the module."""
+
+ debug_pytag = DEFAULT_DEBUG
+ use_pytag = DEFAULT_PYTAG
+ use_stdout = 0
+ import_tags = 0
+ force_overwrite = 0
+ compare_tables = 0
+
+ if os.name == "posix":
+ use_testdata = 0
+ else:
+ # At home...
+ use_testdata = 1
+ use_stdout = 1
+ global DEBUGGING
+ DEBUGGING = 0
+
+ # Do we have command line arguments?
+ arg_list = sys.argv[1:]
+ args = []
+
+ while 1:
+ if len(arg_list) == 0:
+ break
+
+ word = arg_list[0]
+
+ if word == "-pytag":
+ use_pytag = 1
+ elif word == "-debug":
+ debug_pytag = 1
+ elif word == "-stdout":
+ use_stdout = 1
+ elif word == "-force":
+ force_overwrite = 1
+ elif word == "-import":
+ import_tags = 1
+ elif word == "-compare":
+ compare_tables = 1
+ elif word == "-diag":
+ global DEBUGGING
+ DEBUGGING = 1
+ elif word == "-test":
+ use_testdata = 1
+ use_stdout = 1
+ elif word == "-help":
+ print_usage(sys.argv[0])
+ return
+ elif word == "-version":
+ print "Version:",__version__
+ return
+ elif word == "-history":
+ print "History:"
+ print __history__
+ return
+ else:
+ args.append(word)
+
+ arg_list = arg_list[1:]
+ continue
+
+ if compare_tables:
+ from Translate_tags import t_file
+ i_file = define_tagtable()
+ print "Comparing internal table (1) against external (2)"
+ compare_tagtables(i_file,t_file)
+ return
+
+ if not use_testdata and (not args or len(args) > 2):
+ print_usage(sys.argv[0])
+ return
+
+ if not use_testdata:
+ infile = args[0]
+
+ if import_tags:
+ print "Importing tag table definition"
+ from Translate_tags import t_file
+ else:
+ print "Using internal tag table definition"
+ t_file = define_tagtable()
+
+ if use_stdout:
+ outfile = "standard output"
+ elif len(args) > 1:
+ outfile = args[1]
+ else:
+ base,ext = os.path.splitext(infile)
+ if ext != ".py":
+ outfile = base + ".py"
+ else:
+ print "Input file has extension .py so won't guess"\
+ " an output file"
+ return
+
+ if outfile != "standard output":
+ if outfile == infile:
+ print "The output file is the same as the input file"
+ print "Refusing to overwrite %s"%outfile
+ return
+ elif os.path.exists(outfile):
+ if force_overwrite:
+ print "Output file %s already exists"\
+ " - overwriting it"%outfile
+ else:
+ print "Output file %s already exists"%outfile
+ return
+
+ # Read the input file
+ if use_testdata:
+ if DEBUGGING: print
+ print "Using test data"
+ if DEBUGGING: print "==============="
+ text = test_data
+ else:
+ if DEBUGGING: print
+ print "Reading text from %s"%infile
+ if DEBUGGING: print "=================="+"="*len(infile)
+ file = open(infile,"r")
+ text = file.read()
+ file.close()
+
+ # Show what we are trying to parse
+ if DEBUGGING or use_testdata:
+ print
+ print_text(text)
+
+ # Tag it
+ print
+ print "Tagging text"
+ if DEBUGGING: print "============"
+ if use_pytag:
+ import pytag
+ pytag.set_verbosity(0)
+ if debug_pytag:
+ pytag.set_verbosity(1)
+ pytag.use_debugger()
+ result,taglist,next = pytag.pytag(text,t_file)
+ else:
+ timer = TextTools._timer()
+ timer.start()
+ result, taglist, next = tag(text,t_file)
+ #result, taglist, next = tag(text,t_file,0,len(text),taglist)
+ print "Tagging took",timer.stop()[0],"seconds"
+
+ # Now print out the result of the tagging
+ print
+ print "Manipulating tagged data"
+ if DEBUGGING: print "========================"
+ tagfile = File(taglist,text)
+
+ print
+ print "Writing translation to %s"%outfile
+ if DEBUGGING: print "======================="+"="*len(outfile)
+
+ # Open the output file, if necessary
+ if use_stdout:
+ file = sys.stdout
+ else:
+ file = open(outfile,"w")
+
+ tagfile.expand(file)
+
+\f
+# ------------------------------------------------------------
+if __name__ == '__main__':
+ main()
--- /dev/null
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+try:
+ import mx.TextTools
+ import sys
+ sys.modules['TextTools']=mx.TextTools
+except:
+ # Le package mx n'est pas installé. On essaie d'importer
+ # directement TextTools au cas ou
+ try:
+ import TextTools
+ except:
+ # Aucun des deux packages n'est installé
+ #print """ Le package mx.TextTools ou TextTools doit etre
+ #installé pour pouvoir relire des fichiers de commandes
+ #au format Aster V5
+ #voir : http://www.lemburg.com/python/mxextensions.html
+ #"""
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+import sys,string
+try :
+ import TextTools
+except :
+ ""
+try :
+ from tables import ERRORS
+except :
+ ""
+
+#
+__version__="$Name: V7_main $"
+__Id__="$Id: conv.py,v 1.6.52.1 2013-01-24 14:25:23 pnoyret Exp $"
+#
+
+Keywords=('MAILLE_1','MAILLE_2','MAILLE_ESCL','MAILLE_FOND','MAILLE_MAIT','MAILLE_ORIG','MAILLE',
+ 'NOEUD', 'NOEUD_1','NOEUD_2','NOEUD_INIT','NOEUD_FIN', 'NOEUD_ORIG','NOEUD_REFE','NOEUD_EXTR',
+ 'NOEUD_I', 'NOEUD_J','NOEUD_CHOC','NOEUD_ANCRAGE','NOEUD_CENTRE','NOEUD_CMP','NOEUD_DOUBLE',
+ 'NOEUD_ESCL','NOEUD_FOND','NOEUD_PARA','NOEUD_POIN_TANG',
+ 'GROUP_MA', 'GROUP_MA_1','GROUP_MA_2','GROUP_MA_INT','GROUP_MA_EXT', 'GROUP_MA_ORIG',
+ 'GROUP_MA_BORD','GROUP_MA_INTE','GROUP_MA_FLUIDE', 'GROUP_MA_INTERF','GROUP_MA_BETON',
+ 'GROUP_MA_ESCL','GROUP_MA_FINAL','GROUP_MA_FLU_SOL','GROUP_MA_FLU_STR','GROUP_MA_FOND',
+ 'GROUP_MA_MAIT','GROUP_MA_RADIER','GROUP_MA_SOL_SOL','GROUP_MA_INIT',
+ 'GROUP_NO', 'GROUP_NO_1','GROUP_NO_2','GROUP_NO_EXT', 'GROUP_NO_ORIG','GROUP_NO_CHOC',
+ 'GROUP_NO_ANCRAGE','GROUP_NO_CENTRE','GROUP_NO_ESCL','GROUP_NO_EXTR','GROUP_NO_FIN',
+ 'GROUP_NO_FOND','GROUP_NO_INIT','GROUP_NO_POIN_TG','GROUP_NO_RADIER',
+ 'NOM','NOM_GROUP_MA',
+ 'SANS_NOEUD', 'SANS_GROUP_NO',
+ 'INTERSEC', 'UNION','DIFFE',
+ 'VECT_GRNO_ORIG','VECT_GRNO_EXTR',
+ 'VALE_CO'
+ )
+
+liste_macros=('MACRO_MATR_ASSE','MACRO_ELAS_MULT','MACR_ASCOUF_MAIL','MACR_ASCOUF_CALC','MACR_ASPIC_MAIL',
+ 'MACR_ASPIC_CALC','MACRO_MATR_AJOU','MACRO_ELAS_MULT','MACRO_MODE_MECA','MACRO_PROJ_BASE',
+ 'MACR_ADAP_MAIL',
+ )
+liste_concepts_produits=[]
+commande_courante=''
+
+def text_nom_ope(text,tags,left,right):
+ global commande_courante
+ if len(tags) :
+ tag,l,r,subtags=tags[0]
+ commande_courante=text[left:l]
+ return text[left:l]+'('+text[l:r]
+ else :
+ commande_courante=text[left:right]
+ return text[left:right]+'('
+
+def text_reuse(text,tags):
+ s=''
+ for tag,l,r,subtags in tags:
+ if tag == 'ident' :
+ sd=text[l:r]
+ s=s+ sd
+ elif tag == 'nom_ope' : s=s+ '='+text_nom_ope(text,subtags,l,r)
+ elif tag == 'affe' :
+ s=s+ '='+text_affe(text,subtags)
+ elif tag == 'comm' :
+ if commande_courante in liste_macros:
+ s=s+'reuse='+sd+','+text_macro(text,subtags)+')'
+ else:
+ s=s+'reuse='+sd+','+text_com(text,subtags)+')'
+ else:pass
+ s=s+'\n'
+ return s
+
+def text_noreuse(text,tags):
+ global commande_courante
+ s=''
+ for tag,l,r,subtags in tags:
+ if tag == 'ident' :
+ sd=text[l:r]
+ s=s+ text[l:r]
+ elif tag == 'nom_ope' :
+ s=s+ '='+ text_nom_ope(text,subtags,l,r)
+ elif tag == 'affe' :
+ liste_concepts_produits.append(sd)
+ s=s+ '='+text_affe(text,subtags)
+ elif tag == 'comm' :
+ if oldtag=='ident':
+ if sd in liste_macros:
+ s=s+'('+text_macro(text,subtags)+')'
+ else:
+ s=s+'('+text_com(text,subtags)+')'
+ else:
+ liste_concepts_produits.append(sd)
+ if commande_courante in liste_macros:
+ s=s+text_macro(text,subtags)+')'
+ else:
+ s=s+text_com(text,subtags)+')'
+ else:pass
+ oldtag=tag
+ s=s+'\n'
+ return s
+
+def list_mc(lmc,mcs):
+ s=''
+ for k in lmc:
+ v=mcs[k]
+ if len(v) ==1:
+ va,c=v[0]
+ s=s+c+k+'='+va+','
+ elif len(v) > 1:
+ s=s+k+'=('
+ for va,c in v:
+ s=s+string.join((c,va,','),'')
+ s=s[:-1]+'),'
+ s=s[:-1]
+ return s
+
+def text_com(text,tags):
+ mcs={}
+ lmc=[]
+ currid=None
+ comment=''
+ for tag,l,r,subtags in tags:
+ if tag == 'ident' :
+ currid=text[l:r]
+ if not mcs.has_key(currid):
+ mcs[currid]=[]
+ lmc.append(currid)
+ elif tag == 'mcf':
+ ll=text_mcf(text,subtags)
+ mcs[currid].append((ll,comment))
+ comment=''
+ elif tag == 'num' :
+ a=string.replace(text[l:r],'D','E')
+ mcs[currid].append((a,comment))
+ comment=''
+ elif tag == 'CPLX' :
+ a=text_cplx(text,text[l:r],subtags)
+ mcs[currid].append((a,comment))
+ comment=''
+ elif tag == 'arg' :
+ a=''
+ if currid in Keywords :
+ # FR : (SGDG) il faut tester s'il n'y a pas déjà des cotes !!!
+ if text[l]!="'" and text[r-1]!="'":
+ a=a+"'"+text[l:r]+"'"
+ else:
+ a=a+text[l:r]
+ else:
+ a=a+text[l:r]
+ mcs[currid].append((a,comment))
+ comment=''
+ elif tag == 'EVAL' :
+ a=text_eval(text,subtags)
+ mcs[currid].append((a,comment))
+ comment=''
+ elif tag == 'comment' :
+ comment=comment + '#'+text[l+1:r]
+ elif tag == 'comments' :
+ comment=comment + text[l:r]
+ elif tag == 'larg' :
+ if currid in Keywords:mcs[currid].append((text_larg2(text,subtags),comment))
+ else:mcs[currid].append((text_larg(text,subtags),comment))
+ comment=''
+ else :pass
+ s=list_mc(lmc,mcs)
+ if comment :s=s+comment
+ return s
+
+def text_macro(text,tags):
+ mcs={}
+ lmc=[]
+ currid=None
+ comment=''
+ for tag,l,r,subtags in tags:
+ if tag == 'ident' :
+ currid=text[l:r]
+ if not mcs.has_key(currid):
+ mcs[currid]=[]
+ lmc.append(currid)
+ elif tag == 'mcf':
+ ll=text_macro_mcf(text,subtags)
+ mcs[currid].append((ll,comment))
+ comment=''
+ elif tag == 'num' :
+ a=string.replace(text[l:r],'D','E')
+ mcs[currid].append((a,comment))
+ comment=''
+ elif tag == 'CPLX' :
+ a=text_cplx(text,text[l:r],subtags)
+ mcs[currid].append((a,comment))
+ comment=''
+ elif tag == 'arg' :
+ a=''
+ if text[l] == "'":
+ # FR : (SGDG) il faut tester s'il n'y a pas déjà des cotes !!!
+ a=a+text[l:r]
+ elif currid in Keywords :
+ a=a+"'"+text[l:r]+"'"
+ else:
+ sd=text[l:r]
+ if sd not in liste_concepts_produits:
+ # Il s agit d un concept produit par la macro mais situe à droite de =
+ a=a+'CO("'+sd+'")'
+ liste_concepts_produits.append(sd)
+ else:
+ a=a+sd
+ mcs[currid].append((a,comment))
+ comment=''
+ elif tag == 'EVAL' :
+ a=text_eval(text,subtags)
+ mcs[currid].append((a,comment))
+ comment=''
+ elif tag == 'comment' :
+ comment=comment + '#'+text[l+1:r]
+ elif tag == 'comments' :
+ comment=comment + text[l:r]
+ elif tag == 'larg' :
+ if currid in Keywords:mcs[currid].append((text_larg2(text,subtags),comment))
+ else:mcs[currid].append((text_larg(text,subtags),comment))
+ comment=''
+ else :pass
+ s=list_mc(lmc,mcs)
+ if comment :s=s+comment
+ return s
+
+def comments_text(text):
+ l=string.replace(text,'%','#')
+ return l
+
+def text_eval(text,tags):
+ # on retourne l expression sans conversion dans un objet EVAL et entre quotes
+ for tag,l,r,subtags in tags:
+ if tag == 'vexpr':
+ s='EVAL("""'+text[l:r]+'""")'
+ return s
+ return ''
+
+def text_mcf(text,tags):
+ s='_F( '
+ comment=''
+ for tag,l,r,subtags in tags:
+ if tag == 'ident' :
+ s=s+comment
+ comment=''
+ currid=text[l:r]
+ s=s+ currid +' = '
+ elif tag == 'arg' :
+ if currid in Keywords :
+ # FR : (SGDG) il faut tester s'il n'y a pas déjà des cotes !!!
+ if text[l]!="'" and text[r-1]!="'":
+ s=s+"'"+text[l:r]+"',"
+ else:
+ s=s+text[l:r]+","
+ else:s=s+text[l:r]+","
+ elif tag == 'num' :
+ s=s+string.replace(text[l:r],'D','E')+','
+ elif tag == 'CPLX' :
+ s=s+text_cplx(text,text[l:r],subtags)+','
+ elif tag == 'EVAL' :
+ s=s+text_eval(text,subtags)+','
+ elif tag == 'larg' :
+ if currid in Keywords:s=s+text_larg2(text,subtags)+','
+ else: s=s+text_larg(text,subtags)+','
+ elif tag == 'comments' :
+ comment=comment+text[l:r]
+ if comment != '':
+ s=s+comment
+ return s+')'
+
+def text_macro_mcf(text,tags):
+ s='_F( '
+ comment=''
+ for tag,l,r,subtags in tags:
+ if tag == 'ident' :
+ s=s+comment
+ currid=text[l:r]
+ s=s+ currid +' = '
+ elif tag == 'arg' :
+ if text[l] == "'":
+ # FR : (SGDG) il faut tester s'il n'y a pas déjà des cotes !!!
+ s=s+text[l:r]+","
+ elif currid in Keywords :
+ s=s+"'"+text[l:r]+"',"
+ else:
+ sd=text[l:r]
+ if sd not in liste_concepts_produits:
+ # Il s agit d un concept produit par la macro mais situe à droite de =
+ s=s+'CO("'+sd+'"),'
+ liste_concepts_produits.append(sd)
+ else:
+ s=s+sd+','
+ comment=''
+ elif tag == 'num' :
+ s=s+string.replace(text[l:r],'D','E')+','
+ elif tag == 'CPLX' :
+ s=s+text_cplx(text,text[l:r],subtags)+','
+ comment=''
+ elif tag == 'EVAL' :
+ s=s+text_eval(text,subtags)+','
+ comment=''
+ elif tag == 'larg' :
+ if currid in Keywords:s=s+text_larg2(text,subtags)+','
+ else: s=s+text_larg(text,subtags)+','
+ comment=''
+ elif tag == 'comments' :
+ comment=comment+text[l:r]
+ return s[:-1]+')'
+
+def text_cplx(texte,text,tags):
+ """ Retourne une chaîne de caractères représentant un complexe """
+ s="('"+text[0:2]+"'," #text[0:2] = RI ou MP
+ for tag,l,r,subtags in tags:
+ if tag == 'num' :
+ s=s+string.replace(texte[l:r],'D','E')+','
+ s=s+')'
+ return s
+
+def text_larg2(text,tags):
+ """ Pareil que text_larg mais ajoute des cotes autour des arg """
+ ll=[]
+ for tag,l,r,subtags in tags:
+ if tag == 'arg' :
+ # FR : (SGDG) il faut tester le cas où les cotes sont déjà là !!!!
+ if text[l] != "'" and text[r-1] != "'":
+ ll.append( "'"+text[l:r]+"',")
+ else:
+ ll.append(text[l:r]+",")
+ elif tag == 'num' :
+ ll.append(string.replace(text[l:r],'D','E')+',')
+ elif tag == 'CPLX' :
+ ll.append(text_cplx(text,text[l:r],subtags)+',')
+ elif tag == 'comments' :
+ ll.append(text[l:r])
+ return '('+string.join(ll,'')+')'
+
+def text_larg(text,tags):
+ # Pour les listes d arguments il semble plus rapide de construire
+ # une liste puis de faire join (ne pas exagerer : voir ajout ,)
+ ll=[]
+ for tag,l,r,subtags in tags:
+ if tag == 'arg' :
+ ll.append((text,l,r))
+ ll.append(',')
+ elif tag == 'num' :
+ # cette facon de faire est un peu plus rapide que la suivante
+ ll.append(string.replace(text[l:r],'D','E')+',')
+ elif tag == 'comments' :
+ ll.append((text,l,r))
+ elif tag == 'EVAL' :
+ ll.append(text_eval(text,subtags)+',')
+ else:
+ print "Argument ignore: ",text[l:r]
+ return '('+TextTools.join(ll,'')+')'
+
+def comment_text(text):
+ l=string.replace(text,'\n','\n#')
+ if l[-1]=='#':return '#'+l[:-1]
+ else:return '#'+l
+
+def text_affe(text,tags):
+ s=''
+ for tag,l,r,subtags in tags:
+ if tag == 'arg' :
+ s=s+text[l:r]
+ elif tag == 'EVAL' :
+ s=s+text_eval(text,subtags)
+ elif tag == 'larg' :
+ s=s+text_larg(text,subtags)
+ elif tag == 'num' :
+ s=s+string.replace(text[l:r],'D','E')
+ elif tag == 'CPLX' :
+ s=s+text_cplx(text,text[l:r],subtags)+','
+ return s
+
+def text_commande(text,tags):
+ """
+ Convertit une taglist de type commande en une chaine de caracteres
+ à la syntaxe Python représentative d'une commande
+ """
+ s=''
+ for tag,l,r,subtags in tags:
+ if tag == 'noreuse':
+ s=s+text_noreuse(text,subtags)
+ elif tag == 'reuse':s=s+text_reuse(text,subtags)
+ return s
+
+def text_formule(text,tags):
+ """
+ Convertit une taglist de type formule en une chaine de caracteres
+ à la syntaxe Python représentative d'une formule
+ """
+ s=''
+ count=0
+ typ=''
+ for tag,l,r,subtags in tags:
+ if tag == 'id':
+ if count == 0:
+ s=text[l:r]+' = FORMULE('+ty+'="""('
+ else:
+ if count > 1:s=s+','
+ s=s+typ+text[l:r]
+ typ=''
+ count = count +1
+ elif tag == 'typ':
+ typ=text[l:r]
+ elif tag == 'vexpr':
+ s=s+ ') =\n'+text[l:r]
+ elif tag == 'type':
+ ty=text[l:r]
+ return s +'""")\n'
+
+def text_comms(text,tags):
+ """
+ Convertit une taglist resultat d'un appel à TextTools.tag avec une table de type Aster
+ en une chaine de caracteres à la syntaxe Python
+ """
+ # On met la liste globale des concepts produits à zero
+ global liste_concepts_produits
+ liste_concepts_produits=[]
+
+ s=''
+ for tag,l,r,subtags in tags:
+ if tag == 'comment':
+ s=s+ '#'+text[l+1:r]
+ elif tag == 'Null':
+ s=s+ '\n'
+ elif tag == 'formule':
+ s=s+ text_formule(text,subtags)
+ elif tag == 'commande' :
+ s=s+text_commande(text,subtags)
+ else:
+ s=s+ comment_text(text[l:r])
+ return s
+
+def format_errs(text,tags):
+ s=''
+ warnings=''
+ for tag,l,r,subtags in tags:
+ if subtags:
+ err,warn=format_errs(text,subtags)
+ s=s+err
+ warnings=warnings+warn
+ if tag in ERRORS:
+ s=s+ tag+" ligne : "+`TextTools.countlines(text[:l])`+" texte erroné : "+text[l-10:l]+'?'+text[l:r]+'\n'
+ if tag == 'passline':
+ warnings=warnings+ " ligne "+`TextTools.countlines(text[:l])`+" ignorée : " +text[l:r]+'\n'
+ return s,warnings
+
+def conver(text):
+ from tables import aster_script
+ import re
+ # On ajoute un '\n' en fin au cas ou il serait absent
+ text=text+'\n'
+ text=string.upper(text)
+ result, taglist, next = TextTools.tag(text,aster_script)
+ # Pour vérifier les résultats intermédiaires décommenter la ligne suivante
+ #TextTools.print_tags(text,taglist)
+ text=string.replace(text,'%','#')
+ s_errors,warnings = format_errs(text,taglist)
+ if s_errors:
+ return None,s_errors,warnings
+ else:
+ ss=text_comms(text,taglist)
+ return string.replace(ss,'\r\n','\n'),s_errors,warnings
+
+
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+"""
+ Ce fichier définit une table de tags à utiliser avec le package
+ mxTextTools pour décoder un fichier au format Asterv5.
+
+ XXX Ce fichier doit etre corrigé pour incorporer deux modifications
+ réalisées dans la version V1_1p1 d'EFICAS
+"""
+from TextTools import *
+
+#
+__version__="$Name: V7_main $"
+__Id__="$Id: tables.py,v 1.5.52.1 2013-01-24 14:25:23 pnoyret Exp $"
+#
+
+err0='ERR0 , erreur non identifiee : '
+err1='ERR1 , arguments commande errones : '
+err2='ERR2 , parenthese obligatoire : '
+err3='ERR3 , point virgule obligatoire : '
+err4='ERR4 , ":" obligatoire avant mot cle : '
+err5='ERR5 , mot cle facteur ou arg obligatoire : '
+err6='ERR6 , identificateur obligatoire : '
+err7='ERR7 , mot cle facteur errone : '
+err8='ERR8 , signe = ou ( attendu : '
+err9='ERR9 , ( attendue : '
+err10='ERR10 , vexpr attendue : '
+err11='ERR11 , ) attendue : '
+
+ERRORS=(err0,err1,err2,err3,err4,err5,err6,err7,err8,err9,
+ err10,err11)
+
+white_set=set(whitespace)
+
+delim=" ();:=,!&*/%\n"
+
+whitespace = \
+ (None,AllIn,' \t')
+
+opt_whitespace = \
+ whitespace + (MatchOk,)
+
+t_opt_whitespace = \
+ whitespace + (+1,)
+
+t_opt_whitenl = \
+ (None,AllIn,' \t\n\r',+1)
+
+t_err = (
+ (None,AllNotIn,';',+1),
+ (None,Is,';'),
+ (None,Skip,-1),
+)
+
+commespaces = \
+ ('comments',Table,(
+ (None,IsInSet,white_set,+1,+4),
+ (None,Is,'%',MatchFail),
+ # <comment>
+ (None,AllNotIn,'\n\r',+1),
+ (None,AllIn,'\n\r',+1),
+ # <blancs>
+ (None,AllInSet,white_set,+1),
+ (None,Is,'%',MatchOk,-3),
+ ))
+
+t_commespaces = (
+ (None,IsInSet,white_set,+1,+4),
+ (None,Is,'%',MatchFail),
+ # <comment>
+ (None,AllNotIn,'\n\r',+1),
+ (None,AllIn,'\n\r',+1),
+ # <blancs>
+ (None,AllInSet,white_set,+1),
+ (None,Is,'%',MatchOk,-3),
+)
+
+x_commespaces = \
+ ('comments',Table,(
+ # <debut>
+ (None,Is,'%',+3,+1),
+ (None,AllNotIn,'\n\r',+1),
+ (None,AllIn,'\n\r',+1,-2),
+ (None,AllInSet,white_set,+1,-3),
+ ))
+
+t_ident = \
+ ('ident',Table,(
+ (None,IsIn,alpha+'_'),
+ (None,AllIn,alpha+'_'+number,MatchOk),
+ ))
+
+t_identificateur = (
+ (None,IsIn,alpha+'_'),
+ (None,AllIn,alpha+'_'+number,MatchOk),
+)
+
+t_identmc = (
+ (None,IsIn,alpha+'_'),
+ (None,AllIn,alpha+'_'+number,+1),
+ (None,Table,t_commespaces,+1),
+ (None,Is,':',MatchFail),
+)
+
+n_ident = \
+ (None,Table,(
+ (None,IsIn,alpha+'_'),
+ (None,AllIn,alpha+'_'+number,MatchOk),
+ ))
+
+n_string = \
+ (None,Table,(
+ (None,Is,"'"),
+ # <loop>
+ (None,AllNotIn,"'",+1),
+ (None,Word,"''",+1,-1),
+ (None,Is,"'",MatchFail,MatchOk),
+ ))
+
+t_number = \
+ ('num',Table,(
+ (None,IsIn,'-+',+1),
+ (None,Is,'.',+2),
+ (None,IsIn,number,MatchFail,+4),
+ # <entiere>
+ (None,IsIn,number,MatchFail),
+ (None,AllIn,number,+1),
+ (None,Is,'.',+2),
+ # <decimal>
+ (None,AllIn,number,+1),
+ # <exposant> # si pas exposant termine number trouve
+ (None,IsIn,'deDE',MatchOk),
+ (None,IsIn,'-+',+1),
+ (None,AllIn,number,MatchFail,MatchOk),
+ ))
+
+n_number = \
+ (None,Table,(
+ (None,IsIn,'-+',+1),
+ (None,Is,'.',+2),
+ (None,IsIn,number,MatchFail,+4),
+ # <entiere>
+ (None,IsIn,number,MatchFail),
+ (None,AllIn,number,+1),
+ (None,Is,'.',+2),
+ # <decimal>
+ (None,AllIn,number,+1),
+ # <exposant> # si pas exposant termine number trouve
+ (None,IsIn,'deDE',MatchOk),
+ (None,IsIn,'-+',+1),
+ (None,AllIn,number,MatchFail,MatchOk),
+ ))
+
+t_complexe = \
+ ('CPLX',Table,(
+ ("RI",Word,'RI',+7),
+ commespaces + (+1,),
+ t_number + (MatchFail,), # ce n est pas un complexe
+ commespaces + (+1,), # a partir d ici c est un complexe => produire erreurs
+ (None,Is,',',+1),
+ commespaces + (+1,),
+ t_number + (MatchFail,MatchOk),
+ # <mp>
+ ("MP",Word,'MP',MatchFail),
+ commespaces + (+1,),
+ t_number + (MatchFail,), # ce n est pas un complexe
+ commespaces + (+1,), # a partir d ici c est un complexe => produire erreurs
+ (None,Is,',',+1),
+ commespaces + (+1,),
+ t_number + (MatchFail,MatchOk),
+ # <err>
+ (err7,Table,t_err,MatchFail,MatchOk),
+ ))
+
+# Table pour identifier le keyword PI
+
+t_PI = \
+ ('PI',Table,(
+ (None,Word,'PI',MatchFail),
+ (None,IsIn,alpha+'_'+number,MatchOk,+1),
+ (None,Skip,-1),
+ (None,Jump,To,MatchFail),
+ ))
+
+t_vexpr = (
+ ('par',Is,'(',+5,+1),
+ commespaces + (+1,),
+ ('vexpr',Table,ThisTable,+26),
+ commespaces + (+1,),
+ ('par2',Is,')',+25,+15),
+ t_number + (+1,+14),
+ t_complexe + (+1,+13),
+ ('sign',IsIn,'+-',+3,+1),
+ commespaces + (+1,),
+ ('vexpr',Table,ThisTable,+19,+10),
+ t_PI + (+1,+9),
+ t_ident + (MatchFail,),
+ commespaces + (+1,),
+ ('listpar',Is,'(',+6,+1), # on peut avoir une liste de parametres
+ # <params>
+ commespaces + (+1,),
+ ('param',Table,ThisTable,+13),
+ commespaces + (+1,),
+ (None,Is,',',+1,-3),
+ ('finlist',Is,')',+11),
+ # <op>
+ commespaces + (+1,),
+ ('exp',Word,'**',+3,+1),
+ commespaces + (+1,),
+ ('vexpr',Table,ThisTable,+6,MatchOk),
+ ('op',IsIn,'+-*/',+3,+1),
+ commespaces + (+1,),
+ ('vexpr',Table,ThisTable,+3,MatchOk),
+ (None,Jump,To,MatchOk),
+ # <err>
+ (err0,Table,t_err,MatchFail,MatchOk),
+ # <err10>
+ (err10,Table,t_err,MatchFail,MatchOk),
+ # <err9>
+ (err9,Table,t_err,MatchFail,MatchOk),
+)
+
+t_liste_param = \
+ ('liste',Table,(
+ t_ident,
+ commespaces + (+1,),
+ (None,Is,'('),
+ commespaces + (+1,),
+ t_vexpr + (MatchFail,),
+ # <suite>
+ commespaces + (+1,),
+ (None,Is,',',+3),
+ commespaces + (+1,),
+ t_vexpr + (+3,-3),
+ # <fin>
+ commespaces + (+1,),
+ (None,Is,')',+1,MatchOk),
+ # <err>
+ (err7,Table,t_err,MatchFail,MatchOk),
+ ))
+
+t_eval_expr = \
+ ('EVAL',Table,(
+ (None,Word,'EVAL'),
+ commespaces + (+1,),
+ (None,Is,'(',+5),
+ commespaces + (+1,),
+ ('vexpr',Table,t_vexpr,+3),
+ commespaces + (+1,),
+ (None,Is,')',+1,MatchOk),
+ # <err>
+ (err7,Table,t_err,MatchFail,MatchOk),
+ ))
+
+t_entier = \
+ ('entier',Table,(
+ (None,IsIn,number),
+ (None,AllIn,number,+1),
+ (None,IsIn,delim,MatchFail,+1),
+ (None,Skip,-1),
+ ))
+
+t_comment = \
+ ('comment',Table,(
+ (None,Is,'%'),
+ (None,AllNotIn,'\n\r',+1),
+ (None,AllIn,'\n\r',MatchOk),
+ ))
+
+t_nullline = \
+ ('Null',AllIn,' ;\t\n\r')
+
+t_passline = \
+ ('passline',Table,(
+ (None,AllNotIn,newline,+1),
+ (None,IsIn,newline),
+ ))
+
+t_reste = \
+ ('reste',Table,(
+ (None,AllNotIn,';',+1),
+ ))
+
+t_rest2 = \
+ ('reste',Table,(
+ (None,AllNotIn,';',+1),
+ (None,Is,';'),
+ (None,AllNotIn,'\n',+1),
+ (None,Is,'\n',MatchOk,MatchOk),
+ ))
+
+t_formule = \
+ ('formule',Table,(
+ commespaces + (+1,),
+ (None,Word,'!FORMULE'),
+ commespaces + (+1,),
+ (None,Is,'(',+32),
+ commespaces + (+1,),
+ ('type',Table,t_identificateur,+29),
+ commespaces + (+1,),
+ (None,Is,':',+27),
+ commespaces + (+1,),
+ (None,Is,'(',+26),
+ commespaces + (+1,),
+ ('id',Table,t_identificateur,+23),
+ commespaces + (+1,),
+ (None,Is,'(',+22),
+ # <params>
+ commespaces + (+1,),
+ ('typ',Table,t_identmc,+1),
+ commespaces + (+1,),
+ ('id',Table,t_identificateur,+17),
+ commespaces + (+1,),
+ (None,Is,',',+1,-5),
+ commespaces + (+1,),
+ (None,Is,')',-7),
+ commespaces + (+1,),
+ (None,Is,'=',+11),
+ commespaces + (+1,),
+ ('vexpr',Table,t_vexpr,+9),
+ commespaces + (+1,),
+ (None,Is,')',+9),
+ commespaces + (+1,),
+ (None,Is,')',+7),
+ commespaces + (+1,),
+ (None,Is,';',+3),
+ (None,AllNotIn,'\n',+1),
+ (None,Is,'\n',MatchOk,MatchOk),
+ # <err>
+ (err0,Table,t_err,MatchFail,MatchOk),
+ # <err9>
+ (err9,Table,t_err,MatchFail,MatchOk),
+ # <err11>
+ (err11,Table,t_err,MatchFail,MatchOk),
+ ))
+
+t_nom_ope = \
+ ('nom_ope',Table,(
+ (None,Word,'EVAL',+1,MatchFail), # EVAL n est pas un nom d operateur, il est reserve
+ (None,IsIn,alpha+'_'),
+ (None,AllIn,alpha+'_'+number,+1),
+ commespaces + (+1,),
+ (None,Is,'(',MatchFail),
+ (None,Skip,-1),
+ ))
+
+t_arg = \
+ ('arg',Table,(
+ n_string + (+1,MatchOk),
+ n_ident,
+ ))
+
+t_larg = \
+ ('larg',Table,(
+ (None,Is,'(',MatchFail),
+ # <arg>
+ commespaces + (+1,),
+ t_complexe + (+1,+4),
+ t_number + (+1,+3),
+ t_eval_expr + (+1,+2),
+ t_arg + (MatchFail,+1),
+ # <suite>
+ commespaces + (+1,),
+ (None,Is,',',+1),
+ (None,Is,')',-7,MatchOk),
+ ))
+
+t_mcf = \
+ ('mcf',Table,(
+ (None,Is,'(',MatchFail),
+ ("comments",Table,t_commespaces,+1),
+ (None,Is,')',+1,MatchOk),
+ t_ident + (MatchFail,),
+ ("comments",Table,t_commespaces,+1),
+ (None,Is,':',MatchFail), # a partir d ici on est dans un mot cle facteur (erreurs eventuelles)
+ # <args>
+ ("comments",Table,t_commespaces,+1),
+ t_larg + (+1,+5),
+ t_complexe + (+1,+4),
+ t_number + (+1,+3),
+ t_eval_expr + (+1,+2),
+ t_arg + (+8,),
+ # <suite>
+ ("comments",Table,t_commespaces,+1),
+ (None,Is,',',+1),
+ ("comments",Table,t_commespaces,+1),
+ (None,Is,')',+1,MatchOk),
+ t_ident + (+3,),
+ ("comments",Table,t_commespaces,+1),
+ (None,Is,':',+1,-12),
+ # <err>
+ (err7,Table,t_err,MatchFail,MatchOk),
+ ))
+
+t_comm = \
+ ('comm',Table,( # on attend les arguments entre () sinon erreur
+ (None,Is,'(',+21),
+ commespaces + (+1,),
+ (None,Is,')',+1,MatchOk),
+ # <call>
+ t_ident + (+18,),
+ commespaces + (+1,),
+ (None,Is,':',+16),
+ commespaces + (+1,),
+ t_mcf + (+5,),
+ # <mcfsuite>
+ commespaces + (+1,),
+ (None,Is,',',+1),
+ commespaces + (+1,),
+ t_mcf + (+7,-3),
+ # <args>
+ t_larg + (+1,+5),
+ t_complexe + (+1,+4),
+ t_number + (+1,+3),
+ t_eval_expr + (+1,+2),
+ t_arg + (+5,),
+ # <suite>
+ commespaces + (+1,),
+ # <sep>
+ (None,Is,',',+1),
+ commespaces + (+1,),
+ (None,Is,')',-17,MatchOk),
+ # <err>
+ (err1,Table,t_err,MatchFail,MatchOk),
+ ))
+
+t_affe = \
+ ('affe',Table,(
+ commespaces + (+1,),
+ t_larg + (+1,+6),
+ t_complexe + (+1,+5),
+ t_number + (+1,+4),
+ t_eval_expr + (+1,+3),
+ t_arg + (+1,+2),
+ (None,Jump,To,+2),
+ # <suite>
+ (None,Jump,To,MatchOk),
+ # <err>
+ (err0,Table,t_err,MatchFail,MatchOk),
+ ))
+
+t_reuse = \
+ ('reuse',Table,(
+ t_opt_whitespace,
+ t_ident,
+ t_opt_whitespace,
+ (None,Is,'=',+5),
+ t_opt_whitespace,
+ t_nom_ope + (+2,+1),
+ # <comm>
+ t_comm + (MatchFail,MatchOk),
+ # <affe>
+ t_affe + (MatchFail,MatchOk),
+ # <err>
+ (err8,Table,t_err,MatchFail,MatchOk),
+ ))
+
+t_noreuse = \
+ ('noreuse',Table,(
+ t_opt_whitespace,
+ t_ident,
+ t_opt_whitenl,
+ (None,Is,'=',+3,+1), # on a affaire a un operateur ou une affectation
+ t_opt_whitespace,
+ t_nom_ope + (+4,+3),
+ (None,Is,'(',+5,+1),
+ (None,Skip,-1),
+ # <comm>
+ t_comm + (+2,MatchOk),
+ # <affe>
+ t_affe + (+1,MatchOk),
+ # <err>
+ (err0,Table,t_err,MatchFail,MatchOk),
+ # <err8>
+ (err8,Table,t_err,MatchFail,MatchOk),
+ ))
+
+t_fin = \
+ ('commande',Table,(
+ ('noreuse',Table,(
+ t_opt_whitespace,
+ ('ident',Word,"FIN"),
+ t_opt_whitenl,
+ (None,Is,'(',MatchFail), # On est vraiment sur d avoir la commande FIN apres avoir identifie (
+ # On recule d un caractere pour identifier les arguments entre parenthèses
+ (None,Skip,-1),
+ t_comm + (+1,MatchOk),
+ (err0,Table,t_err,MatchFail,MatchOk),
+ )),
+ commespaces + (+1,),
+ (None,Is,';',+1,MatchOk),
+ # <err>
+ (err0,Table,t_err,MatchFail,MatchOk),
+ ))
+
+t_commande = \
+ ('commande',Table,(
+ t_opt_whitespace,
+ (None,Is,'&',+2,+1),
+ t_reuse + (MatchFail,+2),
+ t_noreuse + (MatchFail,),
+ # <fin>
+ commespaces + (+1,),
+ (None,Is,';',+1,MatchOk),
+ # <err>
+ (err0,Table,t_err,MatchFail,MatchOk),
+ ))
+
+aster_script = (
+ # <top>
+ t_nullline + (+1,+0),
+ t_comment + (+1,-1),
+ t_formule + (+1,-2),
+ t_fin + (+1,+4),
+ t_commande + (+1,-4),
+ t_passline + (+1,-5),
+ (None,EOF,Here,-6),
+ # <AfterFin>
+ t_nullline + (+1,+0),
+ t_passline + (+1,-1),
+ (None,EOF,Here,-2),
+)
+
+
+
--- /dev/null
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+"""
+ Ce fichier définit une table de tags à utiliser avec le package
+ mxTextTools pour décoder un fichier au format Asterv5.
+
+ XXX Ce fichier doit etre corrigé pour incorporer deux modifications
+ réalisées dans la version V1_1p1 d'EFICAS
+"""
+from TextTools import *
+
+#
+__version__="$Name: V7_main $"
+__Id__="$Id: tables.tag,v 1.2.62.1 2013-01-24 14:25:23 pnoyret Exp $"
+#
+
+err0='ERR0 , erreur non identifiee : '
+err1='ERR1 , arguments commande errones : '
+err2='ERR2 , parenthese obligatoire : '
+err3='ERR3 , point virgule obligatoire : '
+err4='ERR4 , ":" obligatoire avant mot cle : '
+err5='ERR5 , mot cle facteur ou arg obligatoire : '
+err6='ERR6 , identificateur obligatoire : '
+err7='ERR7 , mot cle facteur errone : '
+err8='ERR8 , signe = ou ( attendu : '
+err9='ERR9 , ( attendue : '
+err10='ERR10 , vexpr attendue : '
+err11='ERR11 , ) attendue : '
+
+ERRORS=(err0,err1,err2,err3,err4,err5,err6,err7,err8,err9,
+ err10,err11)
+
+white_set=set(whitespace)
+
+delim=" ();:=,!&*/%\n"
+
+whitespace is:
+ AllIn ' \t'
+
+opt_whitespace is:
+ whitespace F:MatchOk
+
+t_opt_whitespace is:
+ whitespace F:next
+
+t_opt_whitenl is:
+ AllIn ' \t\n\r' F:next
+
+t_err = Table is:
+ AllNotIn ';' F:next
+ Is ';'
+ Skip back
+
+commespaces is:
+ 'comments' = Table is:
+ IsInSet white_set F:next T:<blancs>
+ Is '%' F:MatchFail
+ <comment>
+ AllNotIn '\n\r' F:next
+ AllIn '\n\r' F:next
+ <blancs>
+ AllInSet white_set F:next
+ Is '%' F:MatchOk T:<comment>
+
+t_commespaces = Table is:
+ IsInSet white_set F:next T:<blancs>
+ Is '%' F:MatchFail
+ <comment>
+ AllNotIn '\n\r' F:next
+ AllIn '\n\r' F:next
+ <blancs>
+ AllInSet white_set F:next
+ Is '%' F:MatchOk T:<comment>
+
+x_commespaces is:
+ 'comments' = Table is:
+ <debut>
+ Is '%':
+ AllNotIn '\n\r' F:next
+ AllIn '\n\r' F:next T:<debut>
+ AllInSet white_set F:next T:<debut>
+
+t_ident is:
+ 'ident' = Table is:
+ IsIn alpha+'_'
+ AllIn alpha+'_'+number F:MatchOk
+
+t_identificateur = Table is:
+ IsIn alpha+'_'
+ AllIn alpha+'_'+number F:MatchOk
+
+t_identmc = Table is:
+ IsIn alpha+'_'
+ AllIn alpha+'_'+number F:next
+ None = Table t_commespaces F:next
+ Is ':' F:MatchFail
+
+n_ident is:
+ None = Table is:
+ IsIn alpha+'_'
+ AllIn alpha+'_'+number F:MatchOk
+
+n_string is:
+ None = Table is:
+ Is "'"
+ <loop>
+ AllNotIn "'" F:next
+ Word "''" F:next T:<loop>
+ Is "'" F:MatchFail T:MatchOk
+
+t_number is:
+ 'num' = Table is:
+ IsIn '-+' F:next
+ Is '.' F:<entiere>
+ IsIn number F:MatchFail T:<decimal>
+ <entiere>
+ IsIn number F:MatchFail
+ AllIn number F:next
+ Is '.' F:<exposant>
+ <decimal>
+ AllIn number F:next
+ <exposant> # si pas exposant termine number trouve
+ IsIn 'deDE' F:MatchOk
+ IsIn '-+' F:next
+ AllIn number F:MatchFail T:MatchOk
+
+n_number is:
+ None = Table is:
+ IsIn '-+' F:next
+ Is '.' F:<entiere>
+ IsIn number F:MatchFail T:<decimal>
+ <entiere>
+ IsIn number F:MatchFail
+ AllIn number F:next
+ Is '.' F:<exposant>
+ <decimal>
+ AllIn number F:next
+ <exposant> # si pas exposant termine number trouve
+ IsIn 'deDE' F:MatchOk
+ IsIn '-+' F:next
+ AllIn number F:MatchFail T:MatchOk
+
+t_complexe is:
+ 'CPLX' = Table is:
+ "RI" = Word 'RI' F:<mp>
+ commespaces F:next
+ t_number F:MatchFail # ce n est pas un complexe
+ commespaces F:next # a partir d ici c est un complexe => produire erreurs
+ Is ',' F:next
+ commespaces F:next
+ t_number F:MatchFail T:MatchOk
+ <mp>
+ "MP" = Word 'MP' F:MatchFail
+ commespaces F:next
+ t_number F:MatchFail # ce n est pas un complexe
+ commespaces F:next # a partir d ici c est un complexe => produire erreurs
+ Is ',' F:next
+ commespaces F:next
+ t_number F:MatchFail T:MatchOk
+ <err>
+ err7 = Table t_err F:MatchFail T:MatchOk
+
+# Table pour identifier le keyword PI
+
+t_PI is:
+ 'PI' = Table is:
+ Word 'PI' F:MatchFail
+ IsIn alpha+'_'+number F:MatchOk T:next
+ Skip back
+ Jump To MatchFail
+
+t_vexpr = Table is:
+ 'par' = Is '(':
+ commespaces F:next
+ 'vexpr' = Table ThisTable F:<err10>
+ commespaces F:next
+ 'par2' = Is ')' F:<err9> T:<op>
+ t_number F:next T:<op>
+ t_complexe F:next T:<op>
+ 'sign' = IsIn '+-':
+ commespaces F:next
+ 'vexpr' = Table ThisTable F:<err10> T:<op>
+ t_PI F:next T:<op>
+ t_ident F:MatchFail
+ commespaces F:next
+ 'listpar' = Is '(': # on peut avoir une liste de parametres
+ <params>
+ commespaces F:next
+ 'param' = Table ThisTable F:<err10>
+ commespaces F:next
+ Is ',' F:next T:<params>
+ 'finlist' = Is ')' F:<err9>
+ <op>
+ commespaces F:next
+ 'exp' = Word '**':
+ commespaces F:next
+ 'vexpr' = Table ThisTable F:<err10> T:MatchOk
+ 'op' = IsIn '+-*/':
+ commespaces F:next
+ 'vexpr' = Table ThisTable F:<err10> T:MatchOk
+ Jump To MatchOk
+ <err>
+ err0 = Table t_err F:MatchFail T:MatchOk
+ <err10>
+ err10 = Table t_err F:MatchFail T:MatchOk
+ <err9>
+ err9 = Table t_err F:MatchFail T:MatchOk
+
+t_liste_param is:
+ 'liste' = Table is:
+ t_ident
+ commespaces F:next
+ Is '('
+ commespaces F:next
+ t_vexpr F:MatchFail
+ <suite>
+ commespaces F:next
+ Is ',' F:<fin>
+ commespaces F:next
+ t_vexpr F:<err> T:<suite>
+ <fin>
+ commespaces F:next
+ Is ')' F:<err> T:MatchOk
+ <err>
+ err7 = Table t_err F:MatchFail T:MatchOk
+
+t_eval_expr is:
+ 'EVAL' = Table is:
+ Word 'EVAL'
+ commespaces F:next
+ Is '(' F:<err>
+ commespaces F:next
+ 'vexpr' = Table t_vexpr F:<err>
+ commespaces F:next
+ Is ')' F:<err> T:MatchOk
+ <err>
+ err7 = Table t_err F:MatchFail T:MatchOk
+
+t_entier is:
+ 'entier' = Table is:
+ IsIn number
+ AllIn number F:next
+ IsIn delim T:next
+ Skip back
+
+t_comment is:
+ 'comment' = Table is:
+ Is '%'
+ AllNotIn '\n\r' F:next
+ AllIn '\n\r' F:MatchOk
+
+t_nullline is:
+ 'Null' = AllIn ' ;\t\n\r'
+
+t_passline is:
+ 'passline' = Table is:
+ AllNotIn newline F:next
+ IsIn newline
+
+t_reste is:
+ 'reste' = Table is:
+ AllNotIn ';' F:next
+
+t_rest2 is:
+ 'reste' = Table is:
+ AllNotIn ';' F:next
+ Is ';'
+ AllNotIn '\n' F:next
+ Is '\n' F:MatchOk T:MatchOk
+
+t_formule is:
+ 'formule' = Table is:
+ commespaces F:next
+ Word '!FORMULE'
+ commespaces F:next
+ Is '(' F:<err9>
+ commespaces F:next
+ 'type' = Table t_identificateur F:<err>
+ commespaces F:next
+ Is ':' F:<err>
+ commespaces F:next
+ Is '(' F:<err9>
+ commespaces F:next
+ 'id' = Table t_identificateur F:<err>
+ commespaces F:next
+ Is '(' F:<err9>
+ <params>
+ commespaces F:next
+ 'typ' = Table t_identmc F:next
+ commespaces F:next
+ 'id' = Table t_identificateur F:<err>
+ commespaces F:next
+ Is ',' F:next T:<params>
+ commespaces F:next
+ Is ')' F:<params>
+ commespaces F:next
+ Is '=' F:<err>
+ commespaces F:next
+ 'vexpr' = Table t_vexpr F:<err>
+ commespaces F:next
+ Is ')' F:<err11>
+ commespaces F:next
+ Is ')' F:<err11>
+ commespaces F:next
+ Is ';' F:<err>
+ AllNotIn '\n' F:next
+ Is '\n' F:MatchOk T:MatchOk
+ <err>
+ err0 = Table t_err F:MatchFail T:MatchOk
+ <err9>
+ err9 = Table t_err F:MatchFail T:MatchOk
+ <err11>
+ err11 = Table t_err F:MatchFail T:MatchOk
+
+t_nom_ope is:
+ 'nom_ope' = Table is:
+ Word 'EVAL' F:next T:MatchFail # EVAL n est pas un nom d operateur, il est reserve
+ IsIn alpha+'_'
+ AllIn alpha+'_'+number F:next
+ commespaces F:next
+ Is '(' F:MatchFail
+ Skip back
+
+t_arg is:
+ 'arg' = Table is:
+ n_string F:next T:MatchOk
+ n_ident
+
+t_larg is:
+ 'larg' = Table is:
+ Is '(' F:MatchFail
+ <arg>
+ commespaces F:next
+ t_complexe F:next T:<suite>
+ t_number F:next T:<suite>
+ t_eval_expr F:next T:<suite>
+ t_arg F:MatchFail T:<suite>
+ <suite>
+ commespaces F:next
+ Is ',' F:next
+ Is ')' F:<arg> T:MatchOk
+
+t_mcf is:
+ 'mcf' = Table is:
+ Is '(' F:MatchFail
+ "comments" = Table t_commespaces F:next
+ Is ')' F:next T:MatchOk
+ t_ident F:MatchFail
+ "comments" = Table t_commespaces F:next
+ Is ':' F:MatchFail # a partir d ici on est dans un mot cle facteur (erreurs eventuelles)
+ <args>
+ "comments" = Table t_commespaces F:next
+ t_larg F:next T:<suite>
+ t_complexe F:next T:<suite>
+ t_number F:next T:<suite>
+ t_eval_expr F:next T:<suite>
+ t_arg F:<err>
+ <suite>
+ "comments" = Table t_commespaces F:next
+ Is ',' F:next
+ "comments" = Table t_commespaces F:next
+ Is ')' F:next T:MatchOk
+ t_ident F:<err>
+ "comments" = Table t_commespaces F:next
+ Is ':' F:<err> T:<args>
+ <err>
+ err7 = Table t_err F:MatchFail T:MatchOk
+
+t_comm is:
+ 'comm' = Table is: # on attend les arguments entre () sinon erreur
+ Is '(' F:<err>
+ commespaces F:next
+ Is ')' F:<call> T:MatchOk
+ <call>
+ t_ident F:<err>
+ commespaces F:next
+ Is ':' F:<err>
+ commespaces F:next
+ t_mcf F:<args>
+ <mcfsuite>
+ commespaces F:next
+ Is ',' F:next
+ commespaces F:next
+ t_mcf F:<sep> T:<mcfsuite>
+ <args>
+ t_larg F:next T:<suite>
+ t_complexe F:next T:<suite>
+ t_number F:next T:<suite>
+ t_eval_expr F:next T:<suite>
+ t_arg F:<err>
+ <suite>
+ commespaces F:next
+ <sep>
+ Is ',' F:next
+ commespaces F:next
+ Is ')' F:<call> T:MatchOk
+ <err>
+ err1 = Table t_err F:MatchFail T:MatchOk
+
+t_affe is:
+ 'affe' = Table is:
+ commespaces F:next
+ t_larg F:next T:<suite>
+ t_complexe F:next T:<suite>
+ t_number F:next T:<suite>
+ t_eval_expr F:next T:<suite>
+ t_arg F:next T:<suite>
+ Jump To <err>
+ <suite>
+ Jump To MatchOk
+ <err>
+ err0 = Table t_err F:MatchFail T:MatchOk
+
+t_reuse is:
+ 'reuse' = Table is:
+ t_opt_whitespace
+ t_ident
+ t_opt_whitespace
+ Is '=' F:<err>
+ t_opt_whitespace
+ t_nom_ope F:<affe> T:<comm>
+ <comm>
+ t_comm F:MatchFail T:MatchOk
+ <affe>
+ t_affe F:MatchFail T:MatchOk
+ <err>
+ err8 = Table t_err F:MatchFail T:MatchOk
+
+t_noreuse is:
+ 'noreuse' = Table is:
+ t_opt_whitespace
+ t_ident
+ t_opt_whitenl
+ Is '=': # on a affaire a un operateur ou une affectation
+ t_opt_whitespace
+ t_nom_ope F:<affe> T:<comm>
+ Is '(' F:<err8> T:next
+ Skip back
+ <comm>
+ t_comm F:<err> T:MatchOk
+ <affe>
+ t_affe F:<err> T:MatchOk
+ <err>
+ err0 = Table t_err F:MatchFail T:MatchOk
+ <err8>
+ err8 = Table t_err F:MatchFail T:MatchOk
+
+t_fin is:
+ 'commande' = Table is:
+ 'noreuse' = Table is:
+ t_opt_whitespace
+ 'ident' = Word "FIN"
+ t_opt_whitenl
+ Is '(' F:MatchFail # On est vraiment sur d avoir la commande FIN apres avoir identifie (
+ # On recule d un caractere pour identifier les arguments entre parenthèses
+ Skip back
+ t_comm F:next T:MatchOk
+ err0 = Table t_err F:MatchFail T:MatchOk
+ commespaces F:next
+ Is ';' F:<err> T:MatchOk
+ <err>
+ err0 = Table t_err F:MatchFail T:MatchOk
+
+t_commande is:
+ 'commande' = Table is:
+ t_opt_whitespace
+ Is '&':
+ t_reuse F:MatchFail T:<fin>
+ t_noreuse F:MatchFail
+ <fin>
+ commespaces F:next
+ Is ';' F:<err> T:MatchOk
+ <err>
+ err0 = Table t_err F:MatchFail T:MatchOk
+
+aster_script = Table is:
+ <top>
+ t_nullline F:next T:<top>
+ t_comment F:next T:<top>
+ t_formule F:next T:<top>
+ t_fin F:next T:<AfterFin>
+ t_commande F:next T:<top>
+ t_passline F:next T:<top>
+ EOF Here F:<top>
+ <AfterFin>
+ t_nullline F:next T:<AfterFin>
+ t_passline F:next T:<AfterFin>
+ EOF Here F:<AfterFin>
+
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+from __future__ import print_function
+
+try:
+ standard_library.install_aliases()
+except:
+ pass
+try:
+ from builtins import str
+except:
+ pass
+from builtins import object
+import sys, re, tokenize
+import io
+
+
+class ENTITE_JDC(object):
+ def __init__(self):
+ self.texte = ""
+
+ def setText(self, texte):
+ self.texte = texte
+
+ def appendText(self, texte):
+ """ """
+ self.texte = self.texte + texte
+
+
+class COMMENTAIRE(ENTITE_JDC):
+ def __str__(self):
+ """
+ Retourne une chaine de caracteres representant self
+ sous une forme interpretable par EFICAS
+ """
+ t = repr(self.texte)
+ return "COMMENTAIRE(u" + t + ")\n"
+
+ def appendText(self, texte):
+ """
+ Ajoute texte a self.texte en enlevant le # initial
+ """
+ if texte[0] == "#":
+ self.texte = self.texte + texte[1:]
+ else:
+ # le diese n'est pas sur le premier caractere
+ amont, aval = texte.split(
+ "#", 1
+ ) # on decoupe suivant la premiere occurrence de #
+ self.texte = self.texte + amont + aval
+
+
+class AFFECTATION(ENTITE_JDC):
+ def appendText(self, texte):
+ """
+ Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
+ """
+ self.texte = self.texte + texte
+
+ def __str__(self):
+ """
+ Retourne une expression de l'affectation comprehensible par ACCAS
+ et exploitable par EFICAS
+ """
+ # t=repr(self.texte)
+ t = self.texte
+ return "PARAMETRE(nom='" + self.name + "',valeur=" + t + ")"
+
+
+class COMMANDE_COMMENTARISEE(ENTITE_JDC):
+ def appendText(self, texte):
+ """
+ Ajoute texte a self.texte en enlevant les doubles commentaires
+ """
+ texte = texte.strip()
+ texte = texte[2:].strip()
+ self.texte = self.texte + (len(self.texte) > 0) * "\n" + texte
+
+ def __str__(self):
+ """
+ Retourne une expression de la commande commentarisee comprehensible par ACCAS
+ et exploitable par EFICAS
+ """
+ return "COMMANDE_COMM(texte=" + repr(self.texte) + ")\n"
+
+
+next = {}
+next["if"] = next["elif"] = "elif", "else", "end"
+next["while"] = next["for"] = "else", "end"
+next["try"] = "except", "finally"
+next["except"] = "except", "else", "end"
+next["else"] = next["finally"] = next["def"] = next["class"] = "end"
+next["end"] = ()
+start = "if", "while", "for", "try", "def", "class"
+
+
+class PARSEUR_PYTHON(object):
+ """
+ Cette classe sert a creer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
+ representant un JDC Python en distinguant :
+ - les commentaires inter commandes
+ - les affectations
+ - les commandes
+ """
+
+ # au moins 1 caractere non blanc ou non tabulation
+ # pattern_ligne_non_blanche = re.compile(r'^[\w\t]+')
+ pattern_ligne_non_blanche = re.compile(r"[^ \t]+")
+ kwprog = re.compile(r"^\s*(?P<kw>[a-z]+)" r"(\s+(?P<id>[a-zA-Z_]\w*))?" r"[^\w]")
+ endprog = re.compile(
+ r"^\s*#?\s*end\s+(?P<kw>[a-z]+)" r"(\s+(?P<id>[a-zA-Z_]\w*))?" r"[^\w]"
+ )
+ wsprog = re.compile(r"^[ \t]*")
+ optionprog = re.compile(r'#\s*parse:\s*([^\n\'"]*)$')
+
+ def __init__(self, texte):
+ # on verifie que le texte fourni se compile correctement
+ compile(texte, "<string>", "exec")
+ self.texte = io.StringIO(texte)
+ self.line = ""
+ self.out = ""
+ self.lastcol = 0
+ self.lastrow = 1
+ self.please_indent = 1
+ self.indent_list = []
+ self.indentation = 0
+ self.paren_level = 0
+ self.affectation = 0
+ self.indent_list = [""]
+ self.objet_courant = None
+ self.affectation_flag = 1
+ self.comment_flag = 1
+ self.buffer = []
+ self.buffer_indent = ""
+
+ def getOptions(self):
+ m = self.optionprog.match(self.line)
+ if m:
+ option = m.group(1)
+ name = option[1:]
+ flag = option[0] == "+"
+ if name == "affectation":
+ self.affectation_flag = flag
+ if name == "comment":
+ self.comment_flag = flag
+ if name == "all":
+ self.comment_flag = flag
+ self.affectation_flag = flag
+
+ def readline(self):
+ self.line = self.texte.readline()
+ # print "line:",self.line
+ # option ?
+ self.getOptions()
+ return self.line
+
+ def getTexte(self, appliEficas=None):
+ """
+ Retourne le texte issu de l'analyse
+ """
+ for tk in tokenize.generate_tokens(self.readline):
+ self.processToken(tk)
+ return self.out
+
+ def processToken(self, tk):
+ """ """
+ ttype, tstring, spos, epos, line = tk
+ thisrow, thiscol = spos
+ # print spos, epos,tokenize.tok_name[ttype],self.lastrow, self.lastcol
+
+ if thisrow > self.lastrow:
+ # si plusieurs lignes (>1)
+ self.out = self.out + "\n" * (thisrow - self.lastrow - 1)
+ self.lastcol = 0
+
+ # if thiscol > self.lastcol :
+ # self.out=self.out+ " " * (thiscol - self.lastcol)
+ # self.please_indent = None
+
+ self.thiscol = thiscol
+ # self.nextrow, self.nextcol = epos
+
+ try:
+ fn = getattr(self, tokenize.tok_name[ttype])
+ except AttributeError:
+ print("No match!", tokenize.tok_name[ttype], tstring)
+ return
+
+ if ttype != tokenize.DEDENT and ttype != tokenize.INDENT and self.please_indent:
+ self.doIndent()
+
+ fn(tstring)
+ self.lastrow, self.lastcol = epos
+
+ def output(self, tstring):
+ # print "output",tstring
+
+ if self.thiscol > self.lastcol:
+ # print self.thiscol,self.lastcol
+ self.out = self.out + " " * (self.thiscol - self.lastcol)
+ self.lastcol = self.thiscol
+
+ self.out = self.out + tstring
+
+ def outputCom(self, tstring):
+ self.out = self.out + tstring
+
+ def updateIndent(self):
+ # print "updateIndent",len(self.indent_list[-1]),len(self.buffer_indent)
+ if len(self.indent_list[-1]) > len(self.buffer_indent):
+ self.out = (
+ self.out + (len(self.indent_list[-1]) - len(self.buffer_indent)) * " "
+ )
+ self.buffer_indent = self.indent_list[-1]
+
+ def doIndent(self):
+ # print "indentation dans doIndent",len(self.indent_list)
+
+ self.out = self.out + self.indent_list[-1]
+ self.buffer_indent = self.indent_list[-1]
+ if self.lastcol + len(self.indent_list[-1]) > self.thiscol:
+ self.lastcol = self.thiscol
+ else:
+ self.lastcol = self.lastcol + len(self.indent_list[-1])
+ self.please_indent = None
+
+ def flush_buffer(self):
+ # if self.buffer:
+ # print len(self.indent_list),self.please_indent
+ for ob in self.buffer:
+ self.out = self.out + str(ob)
+ self.doIndent()
+ self.buffer = []
+ self.objet_courant = None
+
+ def NL(self, tstring):
+ if self.affectation:
+ if self.paren_level == 0:
+ # affectation en cours mais complete
+ self.out = self.out + str(self.affectation_courante)
+ self.affectation_courante = None
+ self.please_indent = 1
+ self.affectation = 0
+ else:
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol:
+ self.affectation_courante.appendText(
+ (self.thiscol - self.lastcol) * " "
+ )
+ self.affectation_courante.appendText(tstring)
+ return
+
+ if self.objet_courant:
+ self.objet_courant = None
+ self.buffer.append(tstring)
+ # self.please_indent = None
+ return
+ self.output(tstring)
+ self.please_indent = 1
+
+ def COMMENT(self, tstring):
+ liste = string.split(self.line, "##", 1)
+ if len(liste) > 1:
+ # On a trouve un double commentaire
+ before, after = liste
+ if self.affectation:
+ # affectation en cours, on ignore
+ pass
+ elif self.paren_level > 0:
+ self.output(tstring)
+ elif self.comment_flag and not self.pattern_ligne_non_blanche.search(
+ before
+ ):
+ # il s'agit d'une commande commentarisee
+ if self.objet_courant == None:
+ if not self.buffer:
+ self.buffer_indent = self.indent_list[-1]
+ self.objet_courant = COMMANDE_COMMENTARISEE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ elif isinstance(self.objet_courant, COMMENTAIRE):
+ self.objet_courant = COMMANDE_COMMENTARISEE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ else:
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ else:
+ # commentaire inline
+ self.output(tstring)
+ self.please_indent = 1
+ return
+
+ else:
+ # On a un commentaire simple
+ new_line = self.line.split("#")[0]
+ if self.affectation:
+ # affectation en cours, on ignore
+ pass
+ elif self.paren_level > 0:
+ self.output(tstring)
+ elif self.comment_flag and not self.pattern_ligne_non_blanche.search(
+ new_line
+ ):
+ # commentaire precede de blancs
+ if self.objet_courant == None:
+ if not self.buffer:
+ self.buffer_indent = self.indent_list[-1]
+ self.objet_courant = COMMENTAIRE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ elif isinstance(self.objet_courant, COMMANDE_COMMENTARISEE):
+ self.objet_courant = COMMENTAIRE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ else:
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ else:
+ # commentaire inline
+ self.output(tstring)
+ self.please_indent = 1
+ return
+
+ def ERRORTOKEN(self, tstring):
+ print("ERRORTOKEN", tstring)
+
+ def NAME(self, tstring):
+ if self.buffer:
+ self.updateIndent()
+ self.flush_buffer()
+
+ if self.affectation == 1:
+ # on a une expression du type NAME=NAME
+ # on ne veut pas des expressions qui commencent par NAME=NAME(NAME=
+ # on en prend le chemin : on met affectation a 3 pour le signaler
+ # on attend d'en savoir plus
+ if self.thiscol > self.lastcol:
+ self.affectation_courante.appendText(
+ (self.thiscol - self.lastcol) * " "
+ )
+ self.affectation_courante.appendText(tstring)
+ self.affectation = 3
+ return
+ elif self.affectation == 4:
+ # on a une expression qui commence par NAME=NAME(NAME
+ # il s'agit tres probablement d'une commande
+ # on annule l'affectation en cours
+ if self.thiscol > self.lastcol:
+ self.affectation_courante.appendText(
+ (self.thiscol - self.lastcol) * " "
+ )
+ self.affectation_courante.appendText(tstring)
+ self.affectation = 5
+ return
+ elif self.affectation == 2:
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol:
+ self.affectation_courante.appendText(
+ (self.thiscol - self.lastcol) * " "
+ )
+ self.affectation_courante.appendText(tstring)
+ self.affectation = 2
+ return
+ self.affectation = 0
+ self.name = None
+ if self.paren_level == 0 and self.affectation_flag:
+ # si on est en dehors de parentheses et en mode transformation d'affectation
+ # on initialise l'attribut name qui indique une affectation en cours
+ self.name = tstring
+ self.output(tstring)
+
+ def ident(self, tstring):
+ self.flush_buffer()
+ self.affectation = 0
+ self.output(tstring)
+
+ def NUMBER(self, tstring):
+ self.flush_buffer()
+ if self.affectation >= 1:
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol:
+ self.affectation_courante.appendText(
+ (self.thiscol - self.lastcol) * " "
+ )
+ self.affectation_courante.appendText(tstring)
+ self.affectation = 2
+ return
+ self.output(tstring)
+
+ def OP(self, tstring):
+ self.flush_buffer()
+ if tstring in ("(", "[", "{"):
+ self.paren_level = self.paren_level + 1
+ if tstring in (")", "]", "}"):
+ self.paren_level = self.paren_level - 1
+
+ if tstring == "=" and self.affectation == 5:
+ # on a une expression qui commence par NAME=NAME(NAME=)
+ # il peut s'agir d'une commande
+ # on annule l'affectation en cours
+ self.out = self.out + self.affectation_courante.texte
+ self.affectation_courante = None
+ self.name = None
+ self.affectation = 0
+ elif tstring == ")" and self.affectation == 4:
+ # on a une expression qui commence par NAME=NAME()
+ # il peut s'agir d'une commande
+ # on annule l'affectation en cours
+ self.out = self.out + self.affectation_courante.texte
+ self.affectation_courante = None
+ self.affectation = 0
+ elif tstring == "(" and self.affectation == 3:
+ # on a deja trouve NAME=NAME
+ # on passe affectation a 4
+ if self.thiscol > self.lastcol:
+ self.affectation_courante.appendText(
+ (self.thiscol - self.lastcol) * " "
+ )
+ self.affectation_courante.appendText(tstring)
+ self.affectation = 4
+ return
+ elif tstring == ";" and self.affectation >= 1:
+ # l'affectation est terminee
+ self.out = self.out + str(self.affectation_courante)
+ self.affectation_courante = None
+ self.please_indent = 1
+ self.affectation = 0
+ elif self.affectation >= 1:
+ # on complete l'affectation
+ if self.thiscol > self.lastcol:
+ self.affectation_courante.appendText(
+ (self.thiscol - self.lastcol) * " "
+ )
+ self.affectation_courante.appendText(tstring)
+ self.affectation = 2
+ return
+
+ self.affectation = 0
+ if self.name and tstring == "=":
+ self.affectation = 1
+ self.affectation_courante = AFFECTATION()
+ self.affectation_courante.name = self.name
+ self.output(tstring)
+
+ ENDMARKER = ident
+ NEWLINE = NL
+
+ def INDENT(self, tstring):
+ # tstring=str(len(self.indent_list))*len(tstring)
+ self.indent_list.append(tstring)
+ # print "indentation dans INDENT",len(self.indent_list),len(tstring)
+ self.affectation = 0
+ if self.buffer:
+ self.updateIndent()
+ self.flush_buffer()
+
+ def DEDENT(self, tstring):
+ # print "DEDENT",tstring,len(tstring)
+ if self.buffer:
+ self.out = self.out + str(self.buffer[0])
+ if len(self.buffer) > 1:
+ for ob in self.buffer[1:]:
+ self.doIndent()
+ self.out = self.out + str(ob)
+ self.buffer = []
+ self.objet_courant = None
+ self.please_indent = 1
+
+ self.affectation = 0
+ self.indent_list = self.indent_list[:-1]
+ # print "indentation dans DEDENT",len(self.indent_list)
+
+ def STRING(self, tstring):
+ self.flush_buffer()
+ if self.affectation >= 1:
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol:
+ self.affectation_courante.appendText(
+ (self.thiscol - self.lastcol) * " "
+ )
+ self.affectation_courante.appendText(tstring)
+ self.affectation = 2
+ return
+ self.output(tstring)
+
+
+if __name__ == "__main__":
+ import sys
+ import io
+
+ text = """
+#
+# comment
+# comment
+# comment
+#
+
+import sys,os
+
+# commentaire
+# commentaire
+# commentaire
+
+DEBUT();
+##toto = FORMULE(REEL='(REEL:A) = A',);
+
+x=2*cos(90.)/34.
+
+a=1.
+if a != 0:
+ a=+1
+
+b=2.
+c=a+b
+#if 1:
+# d=3
+# e=5
+#try:
+# a=1/2
+#except KeyError:
+# pass
+
+if 1:
+ a=2
+ b=3
+ # commenta
+else:
+ # commen
+ # commen
+ a=3
+ #qqqqqqqqqqqqqqqqqqqqqqqq
+ c=5
+
+b=5
+ # commentaire
+toto = FORMULE(REEL='(REEL:A) = A',);
+titi = FORMULE(REEL='(REEL:A) = A',) # commentaire inline
+tutu = FORMULE(REEL='(REEL:A) = A',) ## commentaire inline
+
+TEST_TABLE( TABLE=RELV[k],
+ FILTRE=(
+ _F( NOM_PARA = 'QUANTITE',
+ VALE_K = 'MAXIMUM'),),
+ # commentaire
+ NOM_PARA='VMIS', # comm
+ VALE=1.9669824189084E9,
+ REFERENCE='NON_REGRESSION',
+ VERSION='8.1.0' )
+
+if 1:
+ a=fff(a=1,
+ b=2)
+if 1:
+ a=2
+ b=3
+ # commenta
+else:
+ # commen
+ # commen
+ a=3
+
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+
+
+a = 1.
+b=3
+c= 3 * 5
+d= 4 + \
+ 5 \
+ -4
+e=toto(a=1)
+x=(1,2)
+y=[3,
+#comme
+4]
+z="a"
+zz='v'
+u='''aaaa
+bbbb'''
+if 1:
+ a=45
+else:
+ a=5.6
+d={"a":0}
+e={"a":0,
+#comme
+"d":4}
+a==1
+x=a==1
+s="-"*80
+fmt_raison='-'*80+'''
+
+ Exception erreur_Fatale interceptee
+ Raison : %s
+
+'''+'-'*80+'xxxxxxxxxxxxxxxx'
+q=30*cos(12)
+f=cos(12)
+#commen'''
+#commen'''
+y=a[1]
+y=["x"]*10
+
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+#
+# comment
+# comment
+# comment
+#
+zz=8.9;
+zz=8.9;aa=10
+P1 = 9.8;
+
+P2 = 8.8;
+
+P3 = 7;
+
+P5 = P3*P1;
+
+P6 = P1-3;
+
+P4 = [2,3,4];
+
+P7=P4[1]
+MA=LIRE_MAILLAGE()
+MA=LIRE_MAILLAGE(#comment
+)
+xyz=cos(10)
+MA=LIRE_MAILLAGE(INFO=1)
+MA=LIRE_MAILLAGE(
+ NFO=1)
+MA=LIRE_MAILLAGE(#comme
+ NFO=1)
+MA=\
+LIRE_MAILLAGE(INFO=1)
+MA= LIRE_MAILLAGE()
+TFIN = 1.790 # Temps fin pour le calcul
+
+PAS = 0.001 # pas de temps du calcul
+# parse: -affectation
+DS1=[None]*5
+DS2=[None]*5
+DS3=[None]*5
+DS4=[None]*5
+CHS1=[None]*5
+CHS2=[None]*5
+MO=AFFE_MODELE( MAILLAGE=MA,
+ #test de validateur GEOM (typ=grma) avec grma derive de GEOM
+ AFFE=(_F(GROUP_MA = ('LI1'),
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = 'DIS_TR'),
+ ),
+ INFO=2,);
+
+for k in range(1,5):
+ DS1[k] = CREA_CHAMP( OPERATION='EXTR', TYPE_CHAM='NOEU_DEPL_R',
+ RESULTAT= MODESTA1, NUME_ORDRE=k, NOM_CHAM = 'DEPL');
+
+# parse: +affectation
+ff=23 # parametre bidon
+
+# parse: -all
+a=45
+#commment1
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+# parse: +all
+b=45
+#commment2
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+# parse: -comment
+c=45
+#commment3
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+# parse: +comment
+d=45
+#commment5
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+p=sin(ff)
+
+e=toto(a=1)
+e=toto(a=1,b=3)
+e=toto(1,b=3)
+e=toto(a,b=3)
+e=toto()
+sensible=[2.1E11, 0.3, 1.E-6, 1.E-6, ]
+
+n=len(sensible)
+# parse: -affectation
+
+PS=[None]*n
+
+for i in range(n):
+ PS[i]=DEFI_PARA_SENSI(VALE=sensible[i])
+# parse: +affectation
+
+TEST_RESU(RESU=(_F(RESULTAT = U3L,
+ INST = 1.0,
+ NOM_CHAM = 'DEPL',
+ GROUP_NO = 'PPA',
+ NOM_CMP = 'DX',
+ VALE = 2.86E-5,
+ PRECISION = 5.E-2,
+ REFERENCE = 'AUTRE_ASTER',
+ VERSION = '7.1.11',
+ ),
+ )
+ )#
+#
+FIN()
+#
+
+TEST_RESU(RESU=(_F(RESULTAT = U3L,
+ INST = 1.0,
+ NOM_CHAM = 'DEPL',
+ GROUP_NO = 'PPA',
+ NOM_CMP = 'DX',
+ VALE = 2.86E-5,
+ PRECISION = 5.E-2,
+ REFERENCE = 'AUTRE_ASTER',
+ VERSION = '7.1.11',
+ ),
+ )
+ ) #a
+
+titi = FORMULE(REEL='(REEL:A) = A',
+) # commentaire inline
+titi = FORMULE(REEL='(REEL:A) = A',
+ ) # commentaire inline
+
+def f(x):return x
+#comment
+def f(x):
+#comment
+ for i in range(10): s=0
+
+#com1
+#com2
+
+#com3
+a=1
+##commendcomm
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+#comm
+ if a==1:
+
+ #comm
+
+ for i in x:
+#comm
+##commendcomm
+#comm
+##commendcomm
+#comm
+ if x==3:
+#comm
+ r=1
+ if w==4:
+#comm
+
+ if k:
+
+#comm
+ if g:
+
+#comm
+
+ if t:
+ a=5
+#comm
+if 1:
+ a=2
+ b=3
+ # commenta
+else:
+ # commen
+ # commen
+ a=3
+ # qqqqqqqqqqqqqqqq
+ c=5
+
+b=5
+
+if 1:
+ a=2
+ # commenta
+else:
+ a=3
+if 1:
+ if 2:
+ if 3:
+ a=1
+ elif 4:
+ b=1
+ else:
+ c=5
+ elif 3:
+ x=1
+ else:
+ y=4
+elif 4:
+ s=1
+else:
+ t=9
+#com1
+#com2
+
+#com3
+a=1
+##commendcomm
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+#comm
+ if 1:
+ if 2:
+ if 3:
+ a=1
+ else:
+ a=6
+a=1
+##commendcomm
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+#comm
+
+ if a==1:
+
+ #comm
+
+ for i in x:
+#comm
+##commendcomm
+#comm
+##commendcomm
+#comm
+ if x==3:
+#comm
+ r=1
+
+ if 1:
+ if 2:
+ if 3:
+ a=1
+ else:
+ a=6
+
+if 1:
+ if 2:
+ if 3:
+ r=1
+ # comm
+ else:
+ x=7
+ toto(a=1,
+b=3)
+SUP_=dict([(grand,0.) for grand in grand_obs])
+
+for k in range(1,ns+1):
+ x=toto(a=1,b=2)
+# comm
+ if 1:
+ #com
+
+ #com
+ x=1
+ #com
+
+ #com
+ ##com
+ elif 3:
+ ##com
+ x=1
+ else:
+ y=3
+
+def f():
+ return
+########################################################################
+
+########################################################################
+# macro commande de post-traitement (ex POST_GOUJ2E)
+# calcul des reactions cumulees suivant les filets
+
+def POST_GOUJ_ops(self,TABLE):
+ ier=0
+
+"""
+ if len(sys.argv) == 2:
+ progname, input = sys.argv
+ f = open(input)
+ t = f.read()
+ f.close()
+ else:
+ t = text
+ txt = PARSEUR_PYTHON(t).getTexte()
+ print(txt)
+ compile(txt, "<string>", "exec")
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+
+from __future__ import absolute_import
+from .convert_python import Pythonparser
+
+
+def entryPoint():
+ """
+ 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": Pythonparser,
+ }
--- /dev/null
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+import re
+from convert_python import Pythonparser
+
+
+def entryPoint():
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {"name": "openturns_study", "factory": OTStudyparser}
+
+
+class OTStudyparser(Pythonparser):
+ """
+ This converter works like Pythonparser, except that it also initializes all
+ model variables to None in order to avoid Python syntax errors when loading
+ a file with a different or inexistent definition of variables.
+ """
+
+ # We look for pattern "ModelVariable=NOMVAR,"
+ pattern_model_variable = re.compile(r"ModelVariable\s*=\s*(\w+)\s*,")
+
+ def convert(self, outformat, appli=None):
+ text = Pythonparser.convert(self, outformat, appli)
+ varnames = self.pattern_model_variable.findall(text)
+ newtext = ""
+ for var in varnames:
+ newtext += "%s = None\n" % var
+ newtext += text
+ return newtext
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+
+import parseur_python
+from convert_python import *
+
+def entryPoint():
+ """
+ Retourne les informations nécessaires pour le chargeur de plugins
+ Ces informations sont retournées dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'openturns_wrapper',
+ # La factory pour créer une instance du plugin
+ 'factory' : Pythonparser,
+ }
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin convertisseur de fichier
+ au format python pour EFICAS.
+
+ Un plugin convertisseur doit fournir deux attributs de classe :
+ extensions et formats et deux methodes : readfile,convert.
+
+ L'attribut de classe extensions est une liste d'extensions
+ de fichiers preconisees pour ce type de format. Cette information
+ est seulement indicative.
+
+ L'attribut de classe formats est une liste de formats de sortie
+ supportes par le convertisseur. Les formats possibles sont :
+ eval, dict ou exec.
+ Le format eval est un texte source Python qui peut etre evalue. Le
+ resultat de l'evaluation est un objet Python quelconque.
+ Le format dict est un dictionnaire Python.
+ Le format exec est un texte source Python qui peut etre execute.
+
+ La methode readfile a pour fonction de lire un fichier dont le
+ nom est passe en argument de la fonction.
+ - convertisseur.readfile(nom_fichier)
+
+ La methode convert a pour fonction de convertir le fichier
+ prealablement lu dans un objet du format passe en argument.
+ - objet=convertisseur.convert(outformat)
+
+ Ce convertisseur supporte le format de sortie dict
+
+"""
+from __future__ import absolute_import
+
+try:
+ from builtins import str
+ from builtins import object
+except:
+ pass
+
+import sys, traceback
+
+from Accas.processing import P_CR
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ "name": "pyth",
+ # La factory pour creer une instance du plugin
+ "factory": Pythparser,
+ }
+
+
+class Pythparser(object):
+ """
+ Ce convertisseur lit un fichier au format pyth avec la
+ methode readfile : convertisseur.readfile(nom_fichier)
+ et retourne le texte au format outformat avec la
+ methode convertisseur.convert(outformat)
+
+ Ses caracteristiques principales sont exposees dans 2 attributs
+ de classe :
+ - extensions : qui donne une liste d'extensions de fichier preconisees
+ - formats : qui donne une liste de formats de sortie supportes
+ """
+
+ # Les extensions de fichier preconisees
+ extensions = (".pyth",)
+ # Les formats de sortie supportes (eval dict ou exec)
+ formats = ("dict",)
+
+ 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 = P_CR.CR(
+ debut="CR convertisseur format pyth", fin="fin CR format pyth"
+ )
+ self.g = {}
+
+ def readfile(self, filename):
+ self.filename = filename
+ try:
+ with open(filename) as fd:
+ self.text = fd.read()
+ except:
+ self.cr.fatal(tr("Impossible d'ouvrir le fichier : %s", str(filename)))
+ return
+ self.g = {}
+ try:
+ exec(self.text, self.g)
+ except EficasException as e:
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ s = "".join(l[2:])
+ s = s.replace('"<string>"', '"<%s>"' % self.filename)
+ self.cr.fatal(tr("Erreur a l'evaluation :\n %s", s))
+
+ def convert(self, outformat, appliEficas=None):
+ if outformat == "dict":
+ return self.getdict()
+ else:
+ raise EficasException(tr("Format de sortie : %s, non supporte", outformat))
+
+ def getdict(self):
+ d = {}
+ for k, v in list(self.g.items()):
+ if k[0] != "_":
+ d[k] = v
+ return d
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+import sys, string, re
+import traceback
+from Accas.extensions.eficas_translation import tr
+
+escapedQuotesRE = re.compile(r"(\\\\|\\\"|\\\')")
+stringsAndCommentsRE = re.compile(
+ "(\"\"\".*?\"\"\"|'''.*?'''|\"[^\"]*\"|'[^']*'|#.*?\n)", re.DOTALL
+)
+# stringsAndCommentsRE = \
+# re.compile(u"(\"\"\".*\"\"\"|'''.*'''|\"[^\"]*\"|\'[^\']*\'|#.*\n)", re.DOTALL)
+allchars = bytes.maketrans(b"", b"")
+allcharsExceptNewline = (
+ allchars[: allchars.index(b"\n")] + allchars[allchars.index(b"\n") + 1 :]
+)
+allcharsExceptNewlineTranstable = bytes.maketrans(
+ allcharsExceptNewline, b"*" * len(allcharsExceptNewline)
+)
+
+
+def maskStringsAndComments(src):
+ """Masque tous les caracteres de src contenus dans des commentaires ou des strings multilignes (triples
+ quotes et guillemets.
+ Le masquage est realise en remplacant les caracteres par des *
+ Attention : cette fonction doit etre utilisee sur un texte complet et pas ligne par ligne
+ """
+ # remplace les \\, les \" les \' par **
+ # supprime toutes les chaines ou commentaires ,y compris multiligne i
+ # entre 3 ou 1 simples ou doubles quotes (ouvrantes fermantes) ou #
+ # laisse les non fermantes ou non ouvrantes
+ # on prend 1 sur 2 en raison du split qui donne python, commentaire, python, commentaire...
+
+ src = escapedQuotesRE.sub("**", src)
+ allstrings = stringsAndCommentsRE.split(src)
+
+ # on a une liste d elements constituee successivement de (string, comment)
+ for i in range(1, len(allstrings), 2):
+ if allstrings[i].startswith("'''") or allstrings[i].startswith('"""'):
+ allstrings[i] = (
+ allstrings[i][:3]
+ + allstrings[i][3:-3].translate(allcharsExceptNewlineTranstable)
+ + allstrings[i][-3:]
+ )
+ else:
+ allstrings[i] = (
+ allstrings[i][0]
+ + allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable)
+ + allstrings[i][-1]
+ )
+
+ return "".join(allstrings)
+
+
+implicitContinuationChars = (("(", ")"), ("[", "]"), ("{", "}"))
+linecontinueRE = re.compile(r"\\\s*(#.*)?$")
+emptyHangingBraces = [0, 0, 0, 0, 0]
+
+
+class parserException(Exception):
+ pass
+
+
+class FatalError(Exception):
+ pass
+
+
+# commentaire double precede d'un nombre quelconque de blancs (pas multiligne)
+pattern_2comments = re.compile(r"^\s*##.*")
+pattern_finComments = re.compile("^\s*##Fin Commentaire")
+# commentaire standard precede d'un nombre quelconque de blancs (pas multiligne)
+pattern_comment = re.compile(r"^\s*#.*")
+# fin de ligne ; suivi d'un nombre quelconque de blancs (pas multiligne)
+pattern_fin = re.compile(r"; *$")
+# pattern pour supprimer les blancs, tabulations et fins de ligne
+pattern_blancs = re.compile(r"[ \t\r\f\v]")
+# pattern_blancs = re.compile(r"[\s\n]")
+number_kw_pattern = re.compile(
+ r"""
+(
+ #groupe nombre decimal
+ (?:
+ #signe : on ignore le signe +
+ [-]?
+ #groupe (avec ?: n'apparait pas en tant que groupe dans le resultat)
+ (?:
+ #mantisse forme entiere.fractionnaire
+ \d+(?:\.\d*)?
+ |
+ #ou forme .fractionnaire
+ \.\d+
+ )
+ (?:[eE][+-]?\d+)?
+ )
+ |
+ #argument keyword
+ [a-zA-Z_]\w*=
+)
+""",
+ re.VERBOSE | re.MULTILINE,
+)
+
+
+def construitGenea(texte, listeMc):
+ """
+ Retourne un dictionnaire dont les cles sont des reels et les valeurs sont leurs representations textuelles.
+
+ Realise un filtrage sur les reels :
+
+ - Ne garde que les reels pour lesquels str ne donne pas une bonne representation.
+ - Ne garde que les reels derriere un argument keyword dont le nom est dans listeMc
+
+ >>> s = '''a=+21.3e-5*85,b=-.1234,c=81.6 , d= -8 , e=_F(x=342.67,y=-1), f=+1.1, g=(1.3,-5,1.54E-3),
+ ... #POMPE_PRIMA._BOUCLE_N._2_ELEMENT_NUMERO:0239
+ ... h=_F(x=34.6,y=-1)'''
+ >>> construitGenea(s,['a','x'])
+ {0.000213: '21.3e-5'}
+ """
+ d = {}
+ mot = ""
+ # on masque les strings et commentaires pour ne pas identifier de faux reels
+ for m in number_kw_pattern.findall(maskStringsAndComments(texte)):
+ if m[-1] == "=":
+ # argument keyword
+ mot = m[:-1]
+ else:
+ if mot not in listeMc:
+ continue
+ # valeur
+ key = eval(m)
+ if str(key) != m:
+ d[key] = m
+ return d
+
+
+class ENTITE_JDC(object):
+ """Classe de base pour tous les objets crees lors de la conversion
+ Tout objet derive est enregistre aupres de son pere a sa creation
+ """
+
+ def __init__(self, pere):
+ self.texte = ""
+ pere.l_objets.append(self)
+
+ def setText(self, texte):
+ self.texte = texte
+
+ def appendText(self, texte):
+ """
+ Ajoute texte a self.texte en mettant un retour chariot a la fin de texte
+ """
+ texte = texte + "\n"
+ self.texte = self.texte + texte
+
+ def __str__(self):
+ return self.texte
+
+
+class COMMENTAIRE(ENTITE_JDC):
+ def __str__(self):
+ """
+ Retourne une chaine de caracteres representants self
+ sous une forme interpretable par EFICAS
+ """
+ t = repr(self.texte)
+ return "COMMENTAIRE(u" + t + ")\n"
+
+ # s='COMMENTAIRE(u"""'+self.texte+'""")\n\n'
+ # return s
+
+ def appendText(self, texte):
+ """
+ Ajoute texte a self.texte en enlevant le # initial
+ """
+ texte = texte + "\n"
+ if texte[0] == "#":
+ self.texte = self.texte + texte[1:]
+ else:
+ # le diese n'est pas sur le premier caractere
+ amont, aval = texte.split(
+ "#", 1
+ ) # on decoupe suivant la premiere occurrence de #
+ self.texte = self.texte + amont + aval
+
+
+class COMMANDE(ENTITE_JDC):
+ def __str__(self):
+ """
+ Retourne self.texte
+ """
+ return self.texte + "\n"
+
+ def getNbPar(self):
+ """
+ Retourne la difference entre le nombre de parentheses ouvrantes
+ et le nombre de parentheses fermantes presentes dans self.texte
+ Peut donc retourner un entier negatif
+ """
+ # faire attention aux commentaires contenus dans self.texte
+ # qui peuvent eux-memes contenir des parentheses !!!!
+ l_lignes = self.texte.split("\n")
+ nb = 0
+ for ligne in l_lignes:
+ ligne = ligne.split("#")[0]
+ # nb = nb + (string.count(ligne,'(')-string.count(ligne,')'))
+
+ nb = nb + (ligne.count("(") - ligne.count(")"))
+ return nb
+
+
+class AFFECTATION(ENTITE_JDC):
+ def appendText(self, texte):
+ """
+ Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
+ PN et tout commentaire
+ """
+ if texte[-1] == "\n":
+ texte = texte[0:-1].rstrip()
+ if texte[-1] == ";":
+ texte = texte[0:-1].rstrip()
+ self.texte = self.texte + texte + "\n"
+
+ def __str__(self):
+ """
+ Retourne une expression de l'affectation comprehensible par ACCAS
+ et exploitable par EFICAS
+ """
+ nom, valeur = self.texte.split("=", 1)
+ n = nom.rstrip()
+ nom = n.lstrip()
+ if valeur[-1] == "\n":
+ valeur = valeur[:-1]
+ return n + " = PARAMETRE(nom='" + nom + "',valeur=" + valeur + ")\n"
+
+
+class COMMANDE_COMMENTARISEE(ENTITE_JDC):
+ def appendText(self, texte):
+ """
+ Ajoute texte a self.texte en enlevant les doubles commentaires
+ """
+ texte = texte.strip()
+ texte = texte[2:].strip()
+ self.texte = self.texte + (len(self.texte) > 0) * "\n" + texte
+
+ def __str__(self):
+ """
+ Retourne une expression de la commande commentarisee comprehensible par ACCAS
+ et exploitable par EFICAS
+ """
+ return "COMMANDE_COMM(texte=" + repr(self.texte) + ")\n"
+ # return "COMMANDE_COMM(texte='''"+self.texte+"''')\n"
+
+
+class AFFECTATION_EVAL(ENTITE_JDC):
+ def appendText(self, texte):
+ """
+ Ajoute texte a self.texte en enlevant tout retour chariot
+ """
+ if texte[-1] == "\n":
+ texte = texte[1:-1]
+ self.texte = self.texte + texte
+
+ def __str__(self):
+ """
+ Retourne une expression du parametre EVAL comprehensible par ACCAS
+ et exploitable par EFICAS
+ """
+ nom, valeur = self.texte.split("=", 1)
+ nom = nom.strip()
+ if valeur[-1] == "\n":
+ valeur = valeur[:-1]
+ valeur = valeur.strip()
+ return nom + " = PARAMETRE_EVAL(nom='" + nom + "',valeur='" + valeur + "')\n\n"
+
+
+class PARSEUR_PYTHON(object):
+ """
+ Cette classe sert a generer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
+ representant un JDC Python en distinguant :
+ - les commentaires inter commandes
+ - les affectations
+ - les commandes
+ """
+
+ pattern_commande = re.compile(r"^([A-Z][a-zA-Z0-9_]+)([ \t\r\f\v]*)\(([\w\W]*)")
+ pattern_eval = re.compile(r"^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)")
+ pattern_ligne_vide = re.compile(r"^[\t\r\f\v\n]+")
+ pattern_name = re.compile(r"[a-zA-Z_]\w*")
+
+ def __init__(self, texte):
+ self.texte = texte
+ self.l_objets = None
+ self.appliEficas = None
+
+ def isAffectation(self, texte):
+ """
+ Methode booleenne qui retourne :
+ 1 si le texte est celui d'une affectation dans un jeu de commandes
+ 0 sinon
+ """
+ if "=" not in texte:
+ return 0
+ if self.pattern_commande.match(texte):
+ # cas d'une procedure ...
+ return 0
+ amont, aval = texte.split("=", 1)
+ aval = aval.strip()
+
+ if self.pattern_commande.match(aval):
+ return 0
+ else:
+ s = amont.strip()
+ m = self.pattern_name.match(s)
+ if m is None:
+ return 0
+ if m.start() != 0:
+ return 0
+ if m.end() != len(s):
+ return 0
+ return 1
+
+ def isEval(self, texte):
+ """
+ Methode booleenne qui retourne 1 si le texte est celui d'une affectation de type EVAL
+ dans un jeu de commandes Aster, 0 sinon
+ """
+ if "=" not in texte:
+ return 0
+ if self.pattern_commande.match(texte):
+ # cas d'une procedure ...
+ return 0
+ amont, aval = texte.split("=", 1)
+ aval = aval.strip()
+ if not self.pattern_commande.match(aval):
+ return 0
+ if self.pattern_eval.match(aval):
+ return 1
+ else:
+ return 0
+
+ def isCommande(self, texte):
+ """
+ Methode booleenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
+ Aster, 0 sinon
+ """
+ if self.pattern_commande.match(texte):
+ # cas d'une procedure ...
+ return 1
+ # A ce stade il faut avoir un OPER ou une MACRO, bref un '=' !
+ if "=" not in texte:
+ return 0
+ # on a un texte de la forme xxxx = yyyyy
+ # --> reste a analyser yyyy
+ amont, aval = texte.split("=", 1)
+ aval = aval.strip()
+ if self.pattern_commande.match(aval):
+ return 1
+ else:
+ return 0
+
+ def isModificationCatalogue(self, texte):
+ if self.pattern_commande.match(texte):
+ return 1
+
+ def analyse(self):
+ """
+ Eclate la chaine self.texte en self.l_objets une liste lignes d'instructions
+ et de commentaires (parmi lesquels des instructions "commentarisees").
+ """
+ l_lignes = self.texte.split("\n")
+ commentaire_courant = None
+ commande_courante = None
+ affectation_courante = None
+ commande_commentarisee_courante = None
+ self.l_objets = []
+
+ # initialisation du nombre de parentheses non fermees et de commentaires non termines
+ # Attention a reinitialiser en fin de ligne logique
+ # Une ligne logique peut s'etendre sur plusieurs lignes physiques avec des caracteres de continuation
+ # explicites ou implicites
+ hangingBraces = list(emptyHangingBraces)
+ hangingComments = 0
+
+ # Masquage des commentaires et strings multilignes
+ srcMasked = maskStringsAndComments("\n".join(l_lignes))
+ masked_lines = srcMasked.split("\n")
+ lineno = 0
+
+ for ligne in l_lignes:
+ line = masked_lines[lineno]
+ lineno = lineno + 1
+ # print ("ligne:",line)
+ # mise a jour du nombre total de parentheses ouvertes (non fermees)
+ # et du nombre de commentaires non termines
+ for i in range(len(implicitContinuationChars)):
+ contchar = implicitContinuationChars[i]
+ numHanging = hangingBraces[i]
+ hangingBraces[i] = (
+ numHanging + line.count(contchar[0]) - line.count(contchar[1])
+ )
+
+ hangingComments ^= line.count('"""') % 2
+ hangingComments ^= line.count("'''") % 2
+ # print (hangingComments,hangingBraces)
+ if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0:
+ raise parserException()
+
+ if ligne.strip() == "":
+ # il s'agit d'un saut de ligne
+ # --> on l'ignore
+ continue
+
+ if pattern_2comments.match(ligne):
+ # on a trouve une commande commentarisee : double commentaire sans rien devant a part des blancs
+ if commentaire_courant:
+ # Si un commentaire ordinaire est en cours on le termine
+ commentaire_courant = None
+
+ if commande_courante:
+ # on a un objet commentarise a l'interieur d'une commande
+ # --> non traite pour l'instant : on l'ajoute simplement a la commande courante comme
+ # un commentaire ordinaire
+ commande_courante.appendText(ligne)
+ elif commande_commentarisee_courante:
+ # commande_commentarisee en cours : on ajoute la ligne
+ commande_commentarisee_courante.appendText(ligne)
+ # on a 2 commandes commentarisees de suite
+ if pattern_finComments.match(ligne):
+ commande_commentarisee_courante = None
+ else:
+ # debut de commande commentarisee : on cree un objet commande_commentarisee_courante
+ commande_commentarisee_courante = COMMANDE_COMMENTARISEE(self)
+ commande_commentarisee_courante.appendText(ligne)
+
+ # on passe a la ligne suivante
+ continue
+
+ if pattern_comment.match(ligne):
+ # commentaire ordinaire avec seulement des blancs devant
+ if commande_commentarisee_courante:
+ # commande_commentarisee en cours : on la clot
+ commande_commentarisee_courante = None
+
+ if commande_courante:
+ # il s'agit d'un commentaire a l'interieur d'une commande --> on ne fait rien de special
+ # on l'ajoute au texte de la commande
+ commande_courante.appendText(ligne)
+ elif commentaire_courant:
+ # il s'agit de la nieme ligne d'un commentaire entre deux commandes
+ # --> on ajoute cette ligne au commentaire courant
+ commentaire_courant.appendText(ligne)
+ else:
+ # il s'agit d'un nouveau commentaire entre deux commandes
+ # --> on le cree et il devient le commentaire courant
+ commentaire_courant = COMMENTAIRE(self)
+ commentaire_courant.appendText(ligne)
+
+ # on passe a la ligne suivante
+ continue
+
+ # la ligne contient des donnees autre qu'un eventuel commentaire
+ if commentaire_courant:
+ # on clot un eventuel commentaire courant
+ commentaire_courant = None
+
+ if commande_commentarisee_courante:
+ # on clot une eventuelle commande commentarisee courante
+ commande_commentarisee_courante = None
+
+ if commande_courante:
+ # on a une commande en cours. On l'enrichit ou on la termine
+ commande_courante.appendText(ligne)
+ if (
+ not linecontinueRE.search(line)
+ and (hangingBraces == emptyHangingBraces)
+ and not hangingComments
+ ):
+ # la commande est terminee
+ self.analyseReel(commande_courante.texte)
+ commande_courante = None
+
+ # on passe a la ligne suivante
+ continue
+
+ if affectation_courante != None:
+ # poursuite d'une affectation
+ affectation_courante.appendText(ligne)
+ if (
+ not linecontinueRE.search(line)
+ and (hangingBraces == emptyHangingBraces)
+ and not hangingComments
+ ):
+ # L'affectation est terminee
+ affectation_courante = None
+ # on passe a la ligne suivante
+ continue
+
+ # il peut s'agir d'une commande ou d'une affectation ...
+ # ou d'un EVAL !!!
+ if self.isEval(ligne):
+ # --> affectation de type EVAL
+ if affectation_courante:
+ affectation_courante = None
+ affectation = AFFECTATION_EVAL(self)
+ affectation.appendText(ligne)
+ # on passe a la ligne suivante
+ continue
+
+ if self.isAffectation(ligne):
+ # print( '--> affectation')
+ text = ligne
+ # traitement des commentaires en fin de ligne
+ compos = line.find("#")
+ if compos > 2:
+ # commentaire en fin de ligne
+ # on cree un nouveau commentaire avant le parametre
+ COMMENTAIRE(self).appendText(ligne[compos:])
+ text = ligne[:compos]
+ # si plusieurs instructions separees par des ; sur la meme ligne
+ inspos = line.find(";")
+ if inspos > 2:
+ # on garde seulement la premiere partie de la ligne
+ # si on a que des blancs apres le point virgule
+ if text[inspos:].strip() == ";":
+ text = text[:inspos]
+ else:
+ raise FatalError(
+ tr(
+ "Eficas ne peut pas traiter plusieurs instructions \
+ sur la meme ligne : %s",
+ ligne,
+ )
+ )
+
+ affectation_courante = AFFECTATION(self)
+ affectation_courante.appendText(text)
+ if (
+ not linecontinueRE.search(line)
+ and (hangingBraces == emptyHangingBraces)
+ and not hangingComments
+ ):
+ # L'affectation est terminee
+ affectation_courante = None
+ # on passe a la ligne suivante
+ continue
+
+ if self.isCommande(ligne):
+ # --> nouvelle commande
+ affectation_courante = None
+ commande_courante = COMMANDE(self)
+ commande_courante.appendText(ligne)
+ # si la commande est complete, on la termine
+ if (
+ not linecontinueRE.search(line)
+ and (hangingBraces == emptyHangingBraces)
+ and not hangingComments
+ ):
+ # la commande est terminee
+ self.analyseReel(commande_courante.texte)
+ commande_courante = None
+ # on passe a la ligne suivante
+ continue
+
+ def enleve(self, texte):
+ """Supprime de texte tous les caracteres blancs, fins de ligne, tabulations
+ Le nouveau texte est retourne
+ """
+ i = 0
+ chaine = ""
+ while i < len(texte):
+ if texte[i] == " " or texte[i] == "\n" or texte[i] == "\t":
+ i = i + 1
+ else:
+ chaine = chaine + texte[i]
+ i = i + 1
+ return chaine
+
+ def construitGenea(self, texte):
+ indiceC = 0
+ mot = ""
+ dict_reel_concept = {}
+
+ # traitement pour chaque caractere
+ while indiceC < len(texte):
+ c = texte[indiceC]
+ if c == "," or c == "(u" or c == ")":
+ mot = ""
+ elif c == "=":
+ # on doit trouver derriere soit une valeur soit une parenthese
+ valeur = ""
+ nouvelindice = indiceC + 1
+ if texte[nouvelindice] != "(u":
+ # pas de parenthese ouvrante derriere un signe =, on a une valeur.
+ while texte[nouvelindice] != "," and texte[nouvelindice] != ")":
+ valeur = valeur + texte[nouvelindice]
+ nouvelindice = nouvelindice + 1
+ if nouvelindice == len(texte):
+ nouvelindice = nouvelindice - 1
+ break
+ if mot in self.appliEficas.liste_simp_reel:
+ if valeur[0] != "'":
+ try:
+ clef = eval(valeur)
+ if str(clef) != str(valeur):
+ dict_reel_concept[clef] = valeur
+ except:
+ pass
+ mot = ""
+ indiceC = nouvelindice
+ else:
+ # parenthese ouvrante derriere un signe =, on a un tuple de valeur ou de mots cles facteurs.
+ # s agit -il d un tuple
+ if texte[nouvelindice + 1] != "(u":
+ # le suivant n'est pas une parenthese ouvrante : on a un tuple de valeurs ou un mot cle facteur
+ tuple = False
+ # on avance jusqu'a la fin du tuple de valeurs ou jusqu'a la fin du premier mot cle simple
+ # contenu dans le mot cle facteur
+ while texte[nouvelindice] != "=":
+ if texte[nouvelindice] == ")":
+ tuple = True
+ break
+ else:
+ nouvelindice = nouvelindice + 1
+ if nouvelindice == len(texte):
+ nouvelindice = nouvelindice - 1
+ break
+ if tuple:
+ # cas du tuple de valeurs
+ valeur = texte[indiceC + 1 : nouvelindice + 1]
+ indiceC = nouvelindice + 1
+ if mot in self.appliEficas.liste_simp_reel:
+ valeur = valeur[1:-1]
+ for val in valeur.split(","):
+ # Attention la derniere valeur est""
+ try:
+ if val[0] != "'":
+ clef = eval(val)
+ if str(clef) != str(val):
+ dict_reel_concept[clef] = val
+ except:
+ pass
+ mot = ""
+ # ou de ( imbriquees
+ else:
+ # cas du mocle facteur simple ou
+ mot = ""
+ else:
+ mot = mot + texte[indiceC]
+ indiceC = indiceC + 1
+ # traitement du dernier inutile
+ # c est un ;
+ return dict_reel_concept
+
+ def analyseReel(self, commande):
+ nomConcept = None
+ # On verifie qu on a bien un OPER
+ # et pas une MACRO
+ if commande.find("=") > commande.find("(u"):
+ return
+ if commande.find("=") > 0:
+ # epure1=self.enleve(commande)
+ epure1 = pattern_blancs.sub("", commande)
+ nomConcept, corps = epure1.split("=", 1)
+ epure2 = corps.replace("_F(u", "(u")
+ # nomConcept=epure1.split(u"=")[0]
+ # index=epure1.find(u"=")
+ # epure2=epure1[index+1:len(epure1)].replace(u"_F(u","(u")
+ # dict_reel_concept=self.construitGenea(epure2)
+ if self.appliEficas:
+ dict_reel_concept = construitGenea(
+ epure2, self.appliEficas.liste_simp_reel
+ )
+ else:
+ dict_reel_concept = {}
+ if nomConcept == "sansnom":
+ nomConcept = ""
+ if nomConcept != None:
+ if len(dict_reel_concept) != 0:
+ self.appliEficas.dict_reels[nomConcept] = dict_reel_concept
+
+ def getTexte(self, appliEficas=None):
+ """
+ Retourne le texte issu de l'analyse
+ """
+ self.appliEficas = appliEficas
+ try:
+ # if 1:
+ if not self.l_objets:
+ self.analyse()
+ txt = ""
+ for obj in self.l_objets:
+ txt = txt + str(obj)
+ # else :
+ except parserException:
+ # Impossible de convertir le texte, on le retourne tel que
+ txt = self.texte
+ return txt
+
+
+def test():
+ # import parseur_python
+ import doctest
+
+ doctest.testmod(parseur_python)
+
+
+if __name__ == "__main__":
+ import time
+
+ # fichier = 'D:/Eficas_dev/Tests/zzzz100a.comm'
+ # fichier = 'U:/Eficas_dev/Tests/test_eval.comm'
+ with open(fichier) as fd:
+ texte = fd.read()
+
+ class appliEficas(object):
+ dict_reels = {}
+ liste_simp_reel = ["VALE", "VALE_C", "GROUP_MA", "RAYON"]
+
+ a = appliEficas()
+
+ compile(txt, "<string>", "exec")
+ print((a.dict_reels))
--- /dev/null
+# -*- coding: utf-8 -*-
+import raw.cata_map_genere as mdm
+mdm.pyxb.GlobalValidationConfig._setContentInfluencesGeneration(mdm.pyxb.GlobalValidationConfig.ALWAYS)
+mdm.pyxb.GlobalValidationConfig._setInvalidElementInContent(mdm.pyxb.GlobalValidationConfig.RAISE_EXCEPTION)
+mdm.pyxb.GlobalValidationConfig._setOrphanElementInContent(mdm.pyxb.GlobalValidationConfig.RAISE_EXCEPTION)
+
+
+print dir(mdm)
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+
+install ( FILES __init__.py generator_python.py Formatage.py generator_aplat.py
+ generator_dicoImbrique.py generator_dico.py generator_modification.py generator_vers3DSalome.py
+ generator_TELEMAC.py generator_map.py generator_GroupMA.py
+ DESTINATION ${CMAKE_INSTALL_PREFIX}/generator
+ )
+
+
+
+# Installation des fichiers : CARMEL
+if (WITH_CARMEL)
+ install ( FILES generator_CARMEL3D_frequentiel.py generator_CARMEL3D_temporel.py
+ DESTINATION ${CMAKE_INSTALL_PREFIX}/generator
+ )
+endif (WITH_CARMEL)
+
+
+
+
+### Local Variables:
+### mode: cmake
+### End:
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient la classe Formatage qui permet le formatage d'une
+ liste de chaines de caractères dans une syntaxe représentative d'un
+ jeu de commandes en un texte présentable
+"""
+import types, re
+from Accas.extensions.eficas_translation import tr
+
+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
+
+ 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
+ + ("\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é 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)
+ 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]
+
+ 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 pour defi fonction
+ if self.texte_etape.find("DEFI_FONCTION") > 1:
+ self.mcSimpDEFI_FONCTION( s_mcsimp, ind)
+
+ longueur = self.longueur(self.texte_etape)
+ increment = len(("\n" + self.indent_courant * " ") * ind + s_mcsimp.strip())
+ if ((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
+
+ def mcSimpDEFI_FONCTION(self, s_mcsimp, ind):
+ 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
+ longueur = self.longueur(self.texte_etape)
+ increment = len(("\n" + self.indent_courant * " ") * ind + s_mcsimp.strip())
+ self.texte_etape = ( self.texte_etape + "\n" + self.indent_courant * " " + s_mcsimp)
+
+ 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 + ","
+
+ 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
+
+
+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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce package contient tous les generateurs de formats de sortie
+ a partir des objets d' EFICAS.
+
+ Ces generateurs sont implementes sous forme de plugins
+"""
+import os
+from Accas.IO import pluginloader
+currentDir = os.path.abspath(os.path.dirname(__file__))
+plugins = pluginloader.PluginLoader(currentDir)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+import traceback
+from Accas.extensions.eficas_translation import tr
+from Accas.IO.generator.generator_python import PythonGenerator
+
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ # name: Le nom du plugin
+ # factory: La factory pour creer une instance du plugin
+ """
+ return {
+ "name": "5CRequeteSelection",
+ "factory": RequeteSelectionGenerator,
+ }
+
+
+class RequeteSelectionGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un etapeSelectionet de type JDC et produit
+ un texte pour requeter la base
+ """
+
+ # Les extensions de fichier permis?
+ pass
+ extensions = (".comm",)
+
+ # ----------------------------------------------------------------------------------------
+ def genereRequeteSelection(self, jdc):
+ debug = 0
+
+ texteRequete = "select id from JobPerformance where "
+ etapeSelection = jdc.etapes[0]
+ if debug:
+ print("appelle genereRequeteSelection avec jdc", jdc)
+ if debug:
+ print("etapeSelection", etapeSelection)
+
+ # L etapeSelection n est pas valide : Tout est obligatoire or tout n est pas rempli
+ # On se contente de verifier les regles d afficher les regles non valides
+ # en enelvant les motclefs invalides
+ listeRegles = etapeSelection.getRegles()
+ dictObjPresents = etapeSelection.dictMcPresents(restreint="oui")
+ dictObjPresentsValides = {}
+
+ for nomObj, obj in dictObjPresents.items():
+ if obj.isValid():
+ dictObjPresentsValides[nomObj] = obj
+ if debug:
+ print("dictObjPresentsValides", dictObjPresentsValides)
+
+ commentaire = "Les données sont insuffisantes pour générer les requetes : \n"
+ reglesOk = 1
+ texteErreurs = []
+ if len(listeRegles) > 0:
+ for regle in listeRegles:
+ if debug:
+ print(regle)
+ texteRegle = regle.getText()
+ texteMauvais, test = regle.verif(dictObjPresentsValides)
+ if debug:
+ print(texteMauvais, test)
+ if not test:
+ reglesOk = 0
+ texteErreurs.append(texteMauvais)
+ if not reglesOk:
+ return 0, commentaire, "".join(texteErreurs)
+
+ separateur = ""
+ for nomObj, obj in dictObjPresentsValides.items():
+ texteRequete += separateur
+ texteRequete += nomObj
+ if nomObj.startswith("Debut"):
+ operateur = ">"
+ elif nomObj.endswith("Fin"):
+ operateur = "<"
+ else:
+ operateur = "="
+ texteRequete += operateur
+ lesTypes = obj.getType()
+ if "TXM" in lesTypes:
+ texteRequete += "'"
+ texteRequete += str(obj.valeur)
+ if "TXM" in lesTypes:
+ texteRequete += "'"
+ separateur = " and "
+ return 1, "requete generee : ", texteRequete
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur d une liste des GroupNo et GroupMA
+"""
+import traceback
+import types, re
+
+from Accas.IO.generator.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": "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
+
+ """
+
+ # Les extensions de fichier preconisees
+ extensions = (".comm",)
+
+ 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 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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+from builtins import str
+
+import traceback
+import types, re, os
+from Accas.extensions.eficas_translation import tr
+from Accas.IO.generator.generator_python import PythonGenerator
+
+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,
+ }
+
+
+class TELEMACGenerator(PythonGenerator):
+ """
+ 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
+
+ # ----------------------------------------------------------------------------------------
+ # initialisations
+ # ----------------------------------------------------------------------------------------
+
+ 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 = ""
+
+ # ----------------------------------------------------------------------------------------
+ # 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()
+
+ # ----------------------------------------------------------------------------------------
+ # ecriture de Leger
+ # ----------------------------------------------------------------------------------------
+
+ 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):
+ if not self.commentaireAvant or self.texteCom.find(obj.nom) < 0:
+ self.texteDico += (
+ "/------------------------------------------------------------------/\n"
+ )
+ self.texteDico += "/\t\t\t" + obj.nom + "\n"
+ self.texteDico += (
+ "/------------------------------------------------------------------/\n"
+ )
+ self.commentaireAvant = False
+ self.texteCom = ""
+ s = PythonGenerator.generPROC_ETAPE(self, obj)
+ if obj.nom in TELEMACGenerator.__dict__:
+ TELEMACGenerator.__dict__[obj.nom](*(self, obj))
+
+ return s
+
+ def generMCSIMP(self, obj):
+ """recuperation de l objet MCSIMP"""
+ s = PythonGenerator.generMCSIMP(self, obj)
+
+ # Attention pas sur --> ds certains cas non traite par MCFACT ?
+ # 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
+
+ # nomMajuscule=obj.nom.upper()
+ # nom=nomMajuscule.replace('_',' ')
+ # if nom in listeSupprime or s == "" : return s
+ 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 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 self.langue == "fr":
+ s1 = str(sTelemac).replace("True", "OUI")
+ s2 = s1.replace("False", "NON")
+ else:
+ 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 s3 != "" and s3[0] == "(":
+ try:
+ s3 = s3[1:-1] # cas de liste vide
+ except:
+ s3 = " "
+
+ # LIQUID_BOUNDARIES
+ # if obj.nom in ('PRESCRIBED_FLOWRATES','PRESCRIBED_VELOCITIES','PRESCRIBED_ELEVATIONS') :
+ # return s
+
+ # cas des Tuples
+ if obj.waitTuple() and s3 != "" and s3 != "None":
+ s3 = s
+ if s3[-1] == ",":
+ s3 = s3[:-1]
+
+ if obj.nom not in self.dicoCataToCas:
+ 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",
+ "VARIABLES FOR 3D GRAPHIC PRINTOUTS",
+ "VARIABLES POUR LES SORTIES GRAPHIQUES 3D",
+ "VARIABLES POUR LES SORTIES GRAPHIQUES 2D",
+ "VARIABLES FOR 2D GRAPHIC PRINTOUTS",
+ "C_VSM_PRINTOUT_SELECTION",
+ ]:
+ if s3 != "" and s3 != "None":
+ s3 = s3.replace(";", ",")
+ s3 = "'" + s3 + "'"
+ else:
+ s3 = "''"
+ if nom in ["COUPLING WITH", "COUPLAGE AVEC"]:
+ s3 = (
+ s3.strip()
+ .replace("\n", "")
+ .replace(" ", "")
+ .replace("\t", "")
+ .replace("';'", ",")
+ )
+ 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.0, 1.0, 1.0, 1.0]
+ 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)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ UQ pour EFICAS.
+
+"""
+from builtins import str
+
+import traceback
+import types, re, os
+import Accas
+
+from Accas.IO.generator.generator_python import PythonGenerator
+
+# texteUranie present dans le banc Reacteur Numerique
+# textePresalys present hors le banc Reacteur Numerique
+try:
+ from Accas.IO.generator.texteUranie import SCRIPT_URANIE
+except:
+ pass
+
+try:
+ from Accas.IO.generator.textePersalys import (
+ headerScriptPersalys,
+ fonctionPersalys,
+ etudeScript,
+ codePersalys,
+ )
+ from Accas.IO.generator.textePersalys import mainPersalys, inputHeaderPersalys, outputHeaderPersalys
+ from Accas.IO.generator.textePersalys import getResultCall, getResultCallAvoidPersalysBug
+ from Accas.IO.generator.textePersalys import centralTendencyTaylor, resultTaylor
+ from Accas.IO.generator.textePersalys import optionalResultTaylor, optionalPrintResultTaylor
+ from Accas.IO.generator.textePersalys import centralTendencyMC, resultMC
+ from Accas.IO.generator.textePersalys import critereArretMC, advancedParameterMC
+ from Accas.IO.generator.textePersalys import optionalResultMC, optionalPrintResultMC
+ from Accas.IO.generator.textePersalys import printResultMC, printResultTaylor
+ from Accas.IO.generator.textePersalys import (
+ yacsJobParameters,
+ yacsJobClusterParameters,
+ yacsJobClusterMultiJob,
+ )
+
+ genereScriptPersalys = True
+except:
+ genereScriptPersalys = False
+
+genereScriptPersalys = False
+
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ "name": "UQ",
+ # La factory pour creer une instance du plugin
+ "factory": UQGenerator,
+ }
+
+
+class UQGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas 'normal'
+ un texte au format eficas avec balise
+ un script python permettant de piloter Persalys
+
+ """
+
+ def gener(self, jdc, format="beautifie"):
+ self.indent1 = " "
+
+ # On remet a jour les MCPath
+ self.jdc = jdc
+ self.recalculeMCPath()
+ if jdc.nature != "JDC" or not jdc.isValid():
+ ret, commentaire = self.sauveUniquementCommEt_UQComm(jdc)
+ if not ret:
+ return (ret, commentaire)
+ self.commentaire = "Le JDC doit etre valide pour generer le script de lancement et le fichier à balises\n"
+ self.commentaire += (
+ "Seuls les fichiers _det.comm et .comm ont été sauvegardés"
+ )
+ return 2
+ ret, commentaire = self.analyseIncertitude()
+ if not ret:
+ self.commentaire = commentaire
+ return ret
+ self.inGenerUQ = True
+ self.generDeterministe = False
+ self.textUQ = PythonGenerator.gener(self, jdc, format)
+ self.inGenerUQ = False
+ self.generDeterministe = True
+ self.text = PythonGenerator.gener(self, jdc, format)
+ return self.text
+
+ def creeNomsFichiers(self, fichier):
+ self.cheminFichierComm = os.path.abspath(os.path.dirname(fichier))
+ if fichier.endswith(".xml"):
+ self.fichierSansSuffixe = os.path.basename(fichier[:-5])
+ elif fichier.endswith(".comm"):
+ self.fichierSansSuffixe = os.path.basename(fichier[:-5])
+ else:
+ self.commentaire = "Le nom du fichier doit finir par .comm ou .xml\n"
+ return (
+ 0,
+ "le fichier jeux de données |"
+ + fichier
+ + "| doit être suffixé par .comm",
+ )
+ self.fichierComm = self.fichierSansSuffixe + ".comm"
+ self.fichierDetComm = self.fichierSansSuffixe + "_det.comm"
+ self.fichierBalise = self.fichierSansSuffixe + "_@det.comm"
+ self.fichierUQExe = self.fichierSansSuffixe + "_UQ.py"
+ self.fichierUQModule = os.path.basename(self.fichierUQExe)[:-3]
+ return (1, "")
+
+ def sauveUniquementCommEt_UQComm(self, jdc):
+ self.inGenerUQ = False
+ self.generDeterministe = True
+ self.text = PythonGenerator.gener(self, jdc, "beautifie")
+ fichierDetComm = os.path.join(self.cheminFichierComm, self.fichierDetComm)
+ if not self.writeFile(fichierDetComm):
+ return (0, "impossible de sauvegarder le _det.comm")
+ self.generDeterministe = False
+ self.text = PythonGenerator.gener(self, jdc, "beautifie")
+ fichierComm = os.path.join(self.cheminFichierComm, self.fichierComm)
+ if not self.writeFile(fichierComm):
+ return (0, "impossible de sauvegarder le .comm")
+ return (1, "")
+
+ def writeUQ(self, fichier):
+ # il manque le checksum
+ fichierBalise = os.path.join(self.cheminFichierComm, self.fichierBalise)
+ fichierUQExe = os.path.join(self.cheminFichierComm, self.fichierUQExe)
+ try:
+ with open(fichierBalise, "w") as fp:
+ fp.write(self.textUQ)
+ except:
+ return (0, "impossible de sauvegarder le _@det.py")
+ try:
+ # if 1 :
+ with open(fichierUQExe, "w") as fp:
+ fp.write(self.txtScript)
+ except:
+ if self.txtScript != "":
+ return (0, "impossible de sauvegarder le .py")
+ # a reecrire pour ne pas appeler trop de fois le gener
+ retour, commentaire = self.sauveUniquementCommEt_UQComm(self.jdc)
+ if not retour:
+ return (retour, commentaire)
+ return (1, None)
+
+ def generPROC_ETAPE(self, obj):
+ if not self.inGenerUQ:
+ return PythonGenerator.generPROC_ETAPE(self, obj)
+ if obj.nom == "ExpressionIncertitude" and self.inGenerUQ:
+ return ""
+ else:
+ return PythonGenerator.generPROC_ETAPE(self, obj)
+ # il faut remplacer @xxx@
+ # DU coup qu est ce que xxx
+
+ def generMCSIMP(self, obj):
+ # inutile tant que FACT et BLOC ne sont pas surcharges
+ if obj.nom == "Consigne":
+ return
+ if not self.inGenerUQ:
+ return PythonGenerator.generMCSIMP(self, obj)
+ if not obj in self.mcIncertains:
+ return PythonGenerator.generMCSIMP(self, obj)
+ else:
+ # a refaire si on decide que les incertains sont sous des fact multiples
+ # ce qui ne me parait pas possible mais ?
+ if obj.etape.nature == "OPERATEUR":
+ return "@ " + obj.etape.sd.nom + "__" + obj.nom + " @,"
+ else:
+ return "@ " + obj.nom + " @,"
+
+ def recalculeMCPath(self):
+ etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude")
+ if len(etapeIncertitude) != 1:
+ return
+ etapeIncertitude = etapeIncertitude[0]
+ self.lesVariablesInput = etapeIncertitude.getChild("Input")[
+ 0
+ ].getChildOrChildInBloc("VariableProbabiliste")
+ index = 0
+ for mc in self.lesVariablesInput.data:
+ itemMCPath = mc.getChild("MCPath")
+ itemMCPath.setValeur(mc.variableDeterministe.getMCPath())
+
+ def analyseIncertitude(self):
+ from functools import reduce as reduce
+
+ self.txtScriptPersalys = ""
+ self.txtScript = ""
+ etapeScenarioData = self.jdc.getEtapesByName("Scenario_data")
+ if etapeScenarioData == []:
+ return (
+ 0,
+ "il faut au moins un mot-clef Scenario_data",
+ ) # TODO : à Résorber après modification du catalogue
+ if len(etapeScenarioData) != 1:
+ return (
+ 0,
+ "il faut au plus un mot-clef Scenario_data",
+ ) # TODO : à Résorber après modification du catalogue
+ etapeScenarioData = etapeScenarioData[0]
+ self.ScenarioType = etapeScenarioData.getChildOrChildInBloc(
+ "scenario_type"
+ ).valeur
+
+ etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude")
+ if etapeIncertitude == []:
+ return (0, "il faut au moins un mot-clef ExpressionIncertitude")
+ if len(etapeIncertitude) != 1:
+ return (0, "il faut au plus un mot-clef ExpressionIncertitude")
+ etapeIncertitude = etapeIncertitude[0]
+
+ incertitudeInput = etapeIncertitude.getChildOrChildInBloc("Input")
+ self.lesVariablesInput = incertitudeInput[0].getChildOrChildInBloc(
+ "VariableProbabiliste"
+ )
+ self.mcIncertains = []
+ self.nomsDesVariablesInput = []
+ self.chaineDesVariablesInput = ""
+ for mc in self.lesVariablesInput:
+ if mc.variableDeterministe.etape.nature == "OPERATEUR":
+ self.chaineDesVariablesInput += (
+ mc.variableDeterministe.etape.sd.nom
+ + "__"
+ + mc.variableDeterministe.nom
+ + ", "
+ )
+ self.nomsDesVariablesInput.append(
+ mc.variableDeterministe.etape.sd.nom
+ + "__"
+ + mc.variableDeterministe.nom
+ )
+ else:
+ self.chaineDesVariablesInput += mc.variableDeterministe.nom + ", "
+ self.nomsDesVariablesInput.append(mc.variableDeterministe.nom)
+ self.mcIncertains.append(mc.variableDeterministe)
+
+ sectionOutput = etapeIncertitude.getChildOrChildInBloc("Output")[0]
+ self.ScriptPosttraitement = sectionOutput.getChildOrChildInBloc(
+ "ScriptPosttraitement"
+ )
+ # dans le cas du catalogue UQ gere dans le banc RN, ScriptPosttraitement n existe pas
+ if self.ScriptPosttraitement:
+ self.ScriptPosttraitement = sectionOutput.getChildOrChildInBloc(
+ "ScriptPosttraitement"
+ ).valeur
+ if isinstance(self.ScriptPosttraitement, Accas.PARAMETRE):
+ self.ScriptPosttraitement = self.ScriptPosttraitement.valeur
+ self.chaineDesVariablesInput = self.chaineDesVariablesInput[0:-2]
+
+ # Cas RN OpenTurns ScriptPosttraitement = None
+ # on ne fait pas le return : la suite du traitement est necessaire a uranie
+ sectionPropagation = etapeIncertitude.getChildOrChildInBloc("Propagation")[0]
+ self.Methode = sectionPropagation.getChildOrChildInBloc("Methode").valeur
+ if not sectionPropagation.getChildOrChildInBloc("Result"):
+ self.Result = None
+ else:
+ self.Result = sectionPropagation.getChildOrChildInBloc("Result")[0]
+ if self.Methode == "MonteCarlo":
+ self.critereArret = sectionPropagation.getChildOrChildInBloc(
+ "CritereArret"
+ )[0]
+ if sectionPropagation.getChildOrChildInBloc("EvaluationParameter"):
+ sectionEvaluationParameter = sectionPropagation.getChildOrChildInBloc(
+ "EvaluationParameter"
+ )[0]
+ self.Blocksize = sectionEvaluationParameter.getChildOrChildInBloc(
+ "BlockSize"
+ ).valeur
+ self.advancedParameter = sectionPropagation.getChildOrChildInBloc(
+ "AdvancedParameter"
+ )
+ if self.advancedParameter != None:
+ self.advancedParameter = self.advancedParameter[0]
+ # self.ComputeConfidenceIntervalAt = self.advancedParameter.getChildOrChildInBloc('ComputeConfidenceIntervalAt')[0]
+ # self.Seed = self.advancedParameter.getChildOrChildInBloc('Seed')[0]
+ self.lesVariablesOutput = sectionOutput.getChildOrChildInBloc(
+ "VariableDeSortie"
+ )
+ self.chaineDesVariablesOutputEncodee = ""
+ self.txtOutputVariableInitList = ""
+ self.txtGetAllResults = ""
+ # TODO? from cata_UQ import FonctionDAggregationDict
+ fctAggPy = {
+ "valeur à t=O": "vInitialTime",
+ "valeur à mi-temps": "vHalfTime",
+ "valeur à t final": "vFinalTime",
+ "valeur moyenne": "vMean",
+ "valeur cumulée": "vSum",
+ "valeur minimale": "vMin",
+ "valeur maximale": "vMax",
+ }
+
+ index = 0
+ self.resultSkList = [0]
+ for mc in self.lesVariablesOutput:
+ nomShortVariableOutputList = ""
+ nomFctAggPyList = ""
+ nomOutputList = ""
+ nomVar = mc.getChildOrChildInBloc("VariablePhysique").valeur
+ nomVarEncode = nomVar.replace(" ", "__") # TODO : function
+ nomVarPostraite = mc.getChildOrChildInBloc(
+ "VariablePosttraiteeAssociee"
+ ).valeur
+ nomFctAggList = mc.getChildOrChildInBloc("FonctionDAggregation").valeur
+ for nomFctAgg in nomFctAggList:
+ nomFctAggPy = fctAggPy[nomFctAgg]
+ nomFctAggPyList += nomFctAggPy + ", "
+ nomOutput = nomVarEncode + "_" + nomFctAggPy
+ nomOutputList += nomOutput + ", "
+ self.chaineDesVariablesOutputEncodee += nomOutput + ", "
+ variablesOutputDesc = (
+ '("' + nomFctAgg + '","' + nomVarPostraite + '")'
+ ) # TODO : Interdire ',' dans FctAgg et nomVarPost
+ nomShortVariableOutputList += (
+ "a" + str(index) + ", "
+ ) # Avoid a Persalys Bug
+ index += 1
+ self.txtOutputVariableInitList += (
+ self.indent1
+ + nomOutput
+ + " = persalys.Output('"
+ + nomVar
+ + " ("
+ + nomFctAgg
+ + ")"
+ + "', '"
+ + variablesOutputDesc
+ + "')\n"
+ )
+ # tmpGetResultCall = getResultCall.format(
+ tmpGetResultCall = (
+ getResultCallAvoidPersalysBug.format( # Avoid a Persalys Bug
+ variableOutputList=nomOutputList[0:-2],
+ nomVarPostraite=nomVarPostraite,
+ fonctionAggregationList=nomFctAggPyList[0:-2],
+ shortVariableOutputList=nomShortVariableOutputList[
+ 0:-2
+ ], # Avoid a Persalys Bug
+ )
+ )
+ self.txtGetAllResults += tmpGetResultCall
+ self.resultSkList.append(index)
+
+ self.chaineDesVariablesOutputEncodee = self.chaineDesVariablesOutputEncodee[
+ 0:-2
+ ]
+ self.chaineDesShortVariablesOutput = reduce(
+ lambda x, y: x + y, ["a" + str(i) + ", " for i in range(index)]
+ )[0:-2]
+
+ sectionExecution = etapeIncertitude.getChildOrChildInBloc("Execution")[0]
+ if (
+ etapeIncertitude.getChildOrChildInBloc("UncertaintyTool").valeur
+ == "Persalys"
+ ):
+ self.NbDeBranches = sectionExecution.getChildOrChildInBloc(
+ "NbDeBranches"
+ ).valeur
+ if genereScriptPersalys:
+ if sectionExecution.getChildOrChildInBloc("ExecutionMode") != None:
+ self.ExecutionMode = sectionExecution.getChildOrChildInBloc(
+ "ExecutionMode"
+ ).valeur
+ self.JobName = sectionExecution.getChildOrChildInBloc("JobName").valeur
+ self.ResourceName = sectionExecution.getChildOrChildInBloc(
+ "ResourceName"
+ ).valeur
+ self.Login = sectionExecution.getChildOrChildInBloc("Login").valeur
+ self.WorkDirectory = sectionExecution.getChildOrChildInBloc(
+ "WorkDirectory"
+ ).valeur
+ self.ResultDirectory = sectionExecution.getChildOrChildInBloc(
+ "ResultDirectory"
+ ).valeur
+ self.UncertaintyScript = sectionExecution.getChildOrChildInBloc(
+ "UncertaintyScript"
+ ).valeur
+ if isinstance(self.UncertaintyScript, Accas.PARAMETRE):
+ self.UncertaintyScript = self.UncertaintyScript.valeur
+ print("self.UncertaintyScript : ", self.UncertaintyScript)
+ NbOfProcs = sectionExecution.getChildOrChildInBloc(
+ "NbOfProcs"
+ ) # None si 'desktop', vérification à faire ds jobmanager
+ MultiJobStudy = sectionExecution.getChildOrChildInBloc(
+ "MultiJobStudy"
+ ) # None si 'desktop'
+ if NbOfProcs != None:
+ self.NbOfProcs = NbOfProcs.valeur
+ else:
+ self.NbOfProcs = None
+ if MultiJobStudy != None:
+ self.MultiJobStudy = MultiJobStudy.valeur
+ else:
+ self.MultiJobStudy = None
+ self.creeScriptPersalys()
+ if etapeIncertitude.getChildOrChildInBloc("UncertaintyTool").valeur == "Uranie":
+ if (
+ sectionExecution.getChildOrChildInBloc("ExecutionMode").valeur
+ == "desktop"
+ ):
+ self.ExecutionMode = sectionExecution.getChildOrChildInBloc(
+ "ExecutionMode"
+ ).valeur
+ self.visualization = sectionExecution.getChildOrChildInBloc(
+ "visualization"
+ ).valeur
+ self.sample_size = sectionExecution.getChildOrChildInBloc(
+ "sample_size"
+ ).valeur
+ self.launcher_type = sectionExecution.getChildOrChildInBloc(
+ "launcher_type"
+ ).valeur
+ if self.launcher_type == "distrib":
+ self.parallel_execs = sectionExecution.getChildOrChildInBloc(
+ "parallel_executions"
+ ).valeur
+ self.WorkDirectory = sectionExecution.getChildOrChildInBloc(
+ "UWorkDirectory"
+ ).valeur
+ self.ResultDirectory = sectionExecution.getChildOrChildInBloc(
+ "UResultDirectory"
+ ).valeur
+ self.cree_script_uranie()
+
+ elif (
+ sectionExecution.getChildOrChildInBloc("ExecutionMode").valeur
+ == "cluster"
+ ):
+ self.ExecutionMode = sectionExecution.getChildOrChildInBloc(
+ "ExecutionMode"
+ ).valeur
+ self.sample_size = sectionExecution.getChildOrChildInBloc(
+ "sample_size"
+ ).valeur
+ self.parallel_execs = sectionExecution.getChildOrChildInBloc(
+ "parallel_executions"
+ ).valeur
+ self.WorkDirectory = sectionExecution.getChildOrChildInBloc(
+ "UWorkDirectory"
+ ).valeur
+ self.ResultDirectory = sectionExecution.getChildOrChildInBloc(
+ "UResultDirectory"
+ ).valeur
+ self.nb_of_tasks = sectionExecution.getChildOrChildInBloc(
+ "nb_of_tasks"
+ ).valeur
+ self.nb_of_cpu_per_task = sectionExecution.getChildOrChildInBloc(
+ "nb_of_cpu_per_task"
+ ).valeur
+ self.memory_per_cpu = sectionExecution.getChildOrChildInBloc(
+ "memory_per_cpu"
+ ).valeur
+ self.partitions = sectionExecution.getChildOrChildInBloc(
+ "partitions"
+ ).valeur
+ self.qos = sectionExecution.getChildOrChildInBloc("qos").valeur
+ self.account = sectionExecution.getChildOrChildInBloc("account").valeur
+ self.walltime = sectionExecution.getChildOrChildInBloc(
+ "walltime"
+ ).valeur
+ self.job_name = sectionExecution.getChildOrChildInBloc(
+ "job_name"
+ ).valeur
+ self.output_file = sectionExecution.getChildOrChildInBloc(
+ "output_file"
+ ).valeur
+ self.error_file = sectionExecution.getChildOrChildInBloc(
+ "error_file"
+ ).valeur
+ self.email = sectionExecution.getChildOrChildInBloc("email").valeur
+ self.email_type = sectionExecution.getChildOrChildInBloc(
+ "email_type"
+ ).valeur
+ self.liste_of_nodes = sectionExecution.getChildOrChildInBloc(
+ "liste_of_nodes"
+ ).valeur
+ self.myscript_to_launch = sectionExecution.getChildOrChildInBloc(
+ "myscript_to_launch"
+ ).valeur
+ self.cree_script_uranie()
+
+ return (1, "")
+
+ def cree_script_uranie(self, debug: bool = False):
+ import pickle
+ import logging
+ import shutil
+ import uranie_interface.uncertainty_data as uncertainty_data
+ import uranie_interface.serialize_data as serialize_data
+
+ if debug:
+ print("def cree_script_uranie(self, debug = True):")
+
+ generatorDir = os.path.abspath(os.path.dirname(__file__))
+ if debug:
+ print("generatorDir: ", generatorDir)
+
+ ## inputs ##
+ u_inputs = uncertainty_data.Inputs()
+ for mc in self.lesVariablesInput:
+ if mc.variableDeterministe.etape.nature == "OPERATEUR":
+ name = (
+ mc.variableDeterministe.etape.sd.nom
+ + "__"
+ + mc.variableDeterministe.nom
+ )
+ else:
+ name = mc.variableDeterministe.nom
+ balise = " @" + name + "@ "
+ object_name = mc.variableDeterministe.etape.sd.nom
+ model_variable = mc.variableDeterministe.nom
+
+ distribution_info = u_inputs.Distribution()
+ distribution = mc.getChildOrChildInBloc("Distribution").valeur
+ if distribution == "Uniform":
+ lower_bound = mc.getChildOrChildInBloc("A").valeur
+ upper_bound = mc.getChildOrChildInBloc("B").valeur
+ distribution_info.add_distribution_uniform(
+ distribution, lower_bound, upper_bound
+ )
+ elif distribution == "TruncatedNormal":
+ lower_bound = mc.getChildOrChildInBloc("A").valeur
+ upper_bound = mc.getChildOrChildInBloc("B").valeur
+ standard_deviation = mc.getChildOrChildInBloc("SigmaN").valeur
+ mean = mc.getChildOrChildInBloc("MuN").valeur
+ distribution_info.add_distribution_truncated_normal(
+ distribution, lower_bound, upper_bound, mean, standard_deviation
+ )
+ else:
+ values = mc.getChildOrChildInBloc("Values").valeur
+ distribution_info.add_distribution_user_defined(distribution, values)
+
+ if debug:
+ print("balise = ", balise)
+ flag = balise.replace(" ", "")
+ if debug:
+ print("flag = ", flag)
+ u_inputs.add_input(
+ balise,
+ object_name,
+ model_variable,
+ distribution_info.distribution_info,
+ flag,
+ )
+
+ if debug:
+ print("len(u_inputs.inputs) = ", len(u_inputs.inputs))
+ for i in range(0, len(u_inputs.inputs)):
+ print(f"u_inputs.inputs[{i}].balise = {u_inputs.inputs[i].balise}")
+ print(
+ f"u_inputs.inputs[{i}].balise_flag = {u_inputs.inputs[i].balise_flag}"
+ )
+ print(
+ f"u_inputs.inputs[{i}].object_name = {u_inputs.inputs[i].object_name}"
+ )
+ print(
+ f"u_inputs.inputs[{i}].model_variable = {u_inputs.inputs[i].model_variable}"
+ )
+ if u_inputs.inputs[i].distribution_info[0].distribution == "Uniform":
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].distribution = "
+ f"{u_inputs.inputs[i].distribution_info[0].distribution}"
+ )
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].lower_bound = "
+ f"{u_inputs.inputs[i].distribution_info[0].lower_bound}"
+ )
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].upper_bound = "
+ f"{u_inputs.inputs[i].distribution_info[0].upper_bound}"
+ )
+ elif (
+ u_inputs.inputs[i].distribution_info[0].distribution
+ == "TruncatedNormal"
+ ):
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].distribution = "
+ f"{u_inputs.inputs[i].distribution_info[0].distribution}"
+ )
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].lower_bound = "
+ f"{u_inputs.inputs[i].distribution_info[0].lower_bound}"
+ )
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].upper_bound = "
+ f"{u_inputs.inputs[i].distribution_info[0].upper_bound}"
+ )
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].standard_deviation = "
+ f"{u_inputs.inputs[i].distribution_info[0].standard_deviation}"
+ )
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].mean = "
+ f"{u_inputs.inputs[i].distribution_info[0].mean}"
+ )
+ elif (
+ u_inputs.inputs[i].distribution_info[0].distribution
+ == "UserDefined"
+ ):
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].distribution = "
+ f"{u_inputs.inputs[i].distribution_info[0].distribution}"
+ )
+ print(
+ f"u_inputs.inputs[{i}].distribution_info[0].values = "
+ f"{u_inputs.inputs[i].distribution_info[0].values}"
+ )
+
+ file_balise_dot_comm = self.fichierBalise
+ u_inputs.add_file_balise_dot_comm(file_balise_dot_comm)
+ if debug:
+ print("u_inputs.file_balise_dot_comm = ", u_inputs.file_balise_dot_comm)
+
+ ## propagation ##
+ u_propagation = uncertainty_data.Propagation()
+ u_propagation.set_sampling_method(self.Methode)
+ if debug:
+ print("u_propagation.sampling_method = ", self.Methode)
+
+ ## outputs ##
+ u_outputs = uncertainty_data.Outputs()
+ aggregation_functions = u_outputs.AggregationFunction()
+ agg_fct_py = {
+ "valeur_a_t=0": "vInitialTime",
+ "valeur_a_mi_temps": "vHalfTime",
+ "valeur_a_t_final": "vFinalTime",
+ "valeur_moyenne": "vMean",
+ "valeur_cumulee": "vSum",
+ "valeur_minimale": "vMin",
+ "valeur_maximale": "vMax",
+ }
+ if debug:
+ print(
+ "GENERATOR_UQ.PY: self.lesVariablesOutput = ", self.lesVariablesOutput
+ ) # self.lesVariablesOutput.valeur
+ for mc in self.lesVariablesOutput:
+ type_of_physics = mc.getChildOrChildInBloc("Physique").valeur
+ variable_physics = mc.getChildOrChildInBloc("VariablePhysique").valeur
+ var_post_processed = mc.getChildOrChildInBloc(
+ "VariablePosttraiteeAssociee"
+ ).valeur
+ nom_agg_fct_list = mc.getChildOrChildInBloc("FonctionDAggregation").valeur
+ if debug:
+ print("GENERATOR_UQ.PY: nom_agg_fct_list = ", nom_agg_fct_list)
+ for nom_agg_fct in nom_agg_fct_list:
+ nom_agg_fct = nom_agg_fct.replace(" ", "_")
+ nom_agg_fct = nom_agg_fct.replace("-", "_")
+ nom_agg_fct = nom_agg_fct.replace("O", "0")
+ nom_agg_fct = nom_agg_fct.replace("à", "a")
+ nom_agg_fct = nom_agg_fct.replace("é", "e")
+ aggregation_functions.add_aggregation_function(
+ nom_agg_fct, agg_fct_py[nom_agg_fct]
+ )
+ if debug:
+ print("GENERATOR_UQ.PY: nom_agg_fct_list = ", nom_agg_fct_list)
+
+ u_outputs.add_output(
+ type_of_physics,
+ variable_physics,
+ var_post_processed,
+ aggregation_functions.aggregation_functions,
+ )
+ if debug:
+ for i in range(0, len(u_outputs.outputs)):
+ print(
+ f"u_outputs.outputs[{i}].type_of_physics = "
+ f"{u_outputs.outputs[i].type_of_physics}"
+ )
+ print(
+ f"u_outputs.outputs[{i}].variable_physics = "
+ f"{u_outputs.outputs[i].variable_physics}"
+ )
+ print(
+ f"u_outputs.outputs[{i}].var_post_processed = "
+ f"{u_outputs.outputs[i].var_post_processed}"
+ )
+ print(
+ f"u_outputs.outputs[{i}].aggregation_functions = "
+ f"{u_outputs.outputs[i].aggregation_functions}"
+ )
+ for cle, valeur in u_outputs.outputs[
+ i
+ ].aggregation_functions.items():
+ print(
+ "nom_agg_fct = ", cle, ", aggregation_function = ", valeur
+ )
+
+ ## execution ##
+ u_execution = uncertainty_data.Execution()
+ u_execution.set_execution_mode(self.ExecutionMode)
+ if self.ExecutionMode == "desktop":
+ u_execution.set_visualization(self.visualization)
+ u_execution.set_sample_size(self.sample_size)
+ u_execution.set_launcher_type(self.launcher_type)
+ if self.launcher_type == "distrib":
+ u_execution.set_parallel_execs(self.parallel_execs)
+ u_execution.set_work_dir_name(self.WorkDirectory)
+ u_execution.set_output_dir_name(self.ResultDirectory)
+
+ elif self.ExecutionMode == "cluster":
+ u_execution.set_sample_size(self.sample_size)
+ u_execution.set_parallel_execs(self.parallel_execs)
+ u_execution.set_work_dir_name(self.WorkDirectory)
+ u_execution.set_output_dir_name(self.ResultDirectory)
+ u_execution.set_nb_of_tasks(self.nb_of_tasks)
+ u_execution.set_nb_of_cpu_per_task(self.nb_of_cpu_per_task)
+ u_execution.set_memory_per_cpu(self.memory_per_cpu)
+ u_execution.set_partitions(self.partitions)
+ u_execution.set_qos(self.qos)
+ u_execution.set_account(self.account)
+ u_execution.set_walltime(self.walltime)
+ u_execution.set_job_name(self.job_name)
+ u_execution.set_output_file(self.output_file)
+ u_execution.set_error_file(self.error_file)
+ u_execution.set_email(self.email)
+ u_execution.set_email_type(self.email_type)
+ u_execution.set_liste_of_nodes(self.liste_of_nodes)
+ u_execution.set_myscript_to_launch(self.myscript_to_launch)
+
+ if debug:
+ if self.ExecutionMode == "desktop":
+ print("u_execution.visualization = ", u_execution.visualization)
+ print("u_execution.sample_size = ", u_execution.sample_size)
+ print("u_execution.launcher_type = ", u_execution.launcher_type)
+ if self.launcher_type == "distrib":
+ print("u_execution.parallel_execs = ", u_execution.parallel_execs)
+ print("u_execution.work_dir_name = ", u_execution.work_dir_name)
+ print("u_execution.output_dir_name = ", u_execution.output_dir_name)
+
+ elif self.ExecutionMode == "cluster":
+ print("u_execution.sample_size = ", u_execution.sample_size)
+ print("u_execution.parallel_execs = ", u_execution.parallel_execs)
+ print("u_execution.work_dir_name = ", u_execution.work_dir_name)
+ print(
+ "u_execution.output_dir_name = ", u_execution.output_dir_name
+ )
+ print("u_execution.nb_of_tasks = ", u_execution.nb_of_tasks)
+ print(
+ "u_execution.nb_of_cpu_per_task = ",
+ u_execution.nb_of_cpu_per_task,
+ )
+ print("u_execution.memory_per_cpu = ", u_execution.memory_per_cpu)
+ print("u_execution.partitions = ", u_execution.partitions)
+ print("u_execution.qos = ", u_execution.qos)
+ print("u_execution.account = ", u_execution.account)
+ print("u_execution.walltime = ", u_execution.walltime)
+ print("u_execution.job_name = ", u_execution.job_name)
+ print("u_execution.output_file = ", u_execution.output_file)
+ print("u_execution.error_file = ", u_execution.error_file)
+ print("u_execution.email = ", u_execution.email)
+ print("u_execution.email_type = ", u_execution.email_type)
+ print("u_execution.liste_of_nodes = ", u_execution.liste_of_nodes)
+ print(
+ "u_execution.myscript_to_launch = ",
+ u_execution.myscript_to_launch,
+ )
+
+ # Creat the pickle_dir_name directory
+ pickle_dir_name = "." + u_execution.output_dir_name + "_uncertainty_parameters"
+ pickle_dir_name_path = os.path.join(u_execution.work_dir_name, pickle_dir_name)
+ print("pickle_dir_name_path = ", pickle_dir_name_path)
+ if os.path.exists(pickle_dir_name_path):
+ choice = input(
+ f"The output directory '{pickle_dir_name_path}' already exist."
+ f" Do you want to overwrite it ? (y/n): "
+ ).lower()
+ yess = ["y", "yes"]
+ nos = ["n", "no"]
+ while choice not in yess and choice not in nos:
+ choice = input("Please choose 'y' (yes) or 'n' (no)")
+ if choice in yess:
+ shutil.rmtree(pickle_dir_name_path)
+ os.makedirs(pickle_dir_name_path, exist_ok=True)
+ print("Overwriting of the directory... Done !")
+ else:
+ logging.log(
+ logging.WARNING, "Execution terminated. Directory is not removed."
+ )
+ return 1
+ else:
+ os.makedirs(pickle_dir_name_path, exist_ok=True)
+ print("Writing of the directory... Done !")
+
+ serialize_data.save(
+ pickle_dir_name_path, u_inputs, u_propagation, u_outputs, u_execution
+ )
+
+ self.txtScript = SCRIPT_URANIE.format(pickle_dir=pickle_dir_name_path)
+
+ def parseMcInputVariable(self, mc, indent):
+ if mc.variableDeterministe.etape.nature == "OPERATEUR":
+ nom = (
+ mc.variableDeterministe.etape.sd.nom
+ + "__"
+ + mc.variableDeterministe.nom
+ )
+ else:
+ nom = mc.variableDeterministe.nom
+ loiDistribution = mc.getChildOrChildInBloc("Distribution").valeur
+
+ # on cherche le bloc qui contient ce qui est necessaire a la loi
+ # on est confiant !!!! sur l adequation du catalogue et des attributs des lois persalys
+ # reflechir a cela
+ chaineArgs = ""
+ leBlocDesArgs = None
+ for mc in mc.mcListe:
+ if (mc.nom).find("b_Model_Variable_") == 0:
+ for mcFils in mc.mcListe:
+ if mcFils.nom.find(loiDistribution) > 1:
+ leBlocDesArgs = mcFils
+ break
+ if not leBlocDesArgs:
+ print("souci pour dumper la loi")
+ return ""
+ for mcFils in leBlocDesArgs.mcListe:
+ chaineArgs += str(mcFils.valeur) + ", "
+
+ return nom, loiDistribution, chaineArgs[0:-2]
+
+ def creeTexteInputVariables(self, indent):
+ texte = ""
+ for v in self.lesVariablesInput:
+ nomVariableInput, loiDistribution, chaineArgs = self.parseMcInputVariable(
+ v, indent
+ )
+ texte += "{}{} = persalys.Input('{}', ot.{}(".format(
+ indent, nomVariableInput, nomVariableInput, loiDistribution
+ )
+ texte += chaineArgs + "))\n"
+
+ return texte
+
+ def creeTexteInputVariablesSummary(self, indent):
+ texte = ""
+ for v in self.lesVariablesInput:
+ nomVariableInput, loiDistribution, chaineArgs = self.parseMcInputVariable(
+ v, indent
+ )
+ texte += "{}'{}{} : {}({})\\n'\n".format(
+ 2 * indent, indent, nomVariableInput, loiDistribution, chaineArgs
+ )
+ # texte+=chaineArgs[0:-2]+'))\n'
+ # texte+='\n'
+
+ return texte[0:-1]
+
+ def creeScriptPersalys(self, debug=True):
+ from functools import reduce
+
+ # chaineDesVariablesInput=reduce(lambda x,y:x+','+y,l)
+ def getStrVarList(l, sep=","):
+ return reduce(lambda x, y: str(x) + sep + str(y), l)
+
+ def getStrVarStrList(l, sep=","):
+ return reduce(
+ lambda x, y: x + sep + y, map(lambda x: "'" + str(x) + "'", l)
+ )
+
+ def getStrInitList(l):
+ return getStrVarList(
+ map(lambda x: "self.{} = {}".format(x, x), l), "\n" + 2 * self.indent1
+ )
+
+ def getStrReplaceVarList(l):
+ return getStrVarList(
+ map(lambda x: "'@ {} @': repr(self.{})".format(x, x), l), ","
+ )
+
+ def getStrSelfVarList(l):
+ return getStrVarList(map(lambda x: "self.{}".format(x), l), ",")
+
+ generatorDir = os.path.abspath(os.path.dirname(__file__))
+ nomEtude = "monEtude" # TODO
+ if debug:
+ print("nomEtude : ", nomEtude, "generatorDir :", generatorDir)
+
+ self.txtScriptPersalys += headerScriptPersalys
+
+ # TODO: Résorber le cas particulier du HLO en mettant les options de lancement ds le catalog
+ if self.ScenarioType == "HLO":
+ txtUncertaintyScriptParameters = (
+ self.fichierComm + " --cocagne-thermo-solver\ FaSTT"
+ )
+ else:
+ txtUncertaintyScriptParameters = self.fichierComm
+
+ print("self.nomsDesVariablesInput :", self.nomsDesVariablesInput)
+ self.txtScriptPersalys += etudeScript.format(
+ chaineDesVariablesInput=self.chaineDesVariablesInput,
+ chaineSelfDesVariablesInput=getStrSelfVarList(self.nomsDesVariablesInput),
+ chaineInitDesVariablesInput=getStrInitList(self.nomsDesVariablesInput),
+ commFileBalise=self.fichierBalise,
+ commFile=self.fichierComm,
+ nproc=self.NbOfProcs, # En local le nombre de procs est inutile
+ # sauf si lancement mpi externe au script applicatif
+ # auquel cas != NbOfTasks du jobmanager car
+ # on ne compte pas les threads
+ replaceDataList=getStrReplaceVarList(self.nomsDesVariablesInput),
+ uncertaintyScript=os.path.basename(self.UncertaintyScript),
+ uncertaintyScriptParameters=txtUncertaintyScriptParameters,
+ workDirectory=self.WorkDirectory,
+ )
+
+ txtFonctionPersalys = fonctionPersalys.format(
+ currentFile=self.fichierUQModule,
+ chaineDesVariablesInput=self.chaineDesVariablesInput,
+ getAllResults=self.txtGetAllResults,
+ # chaineDesVariablesOutput = self.chaineDesVariablesOutputEncodee
+ chaineDesVariablesOutput=self.chaineDesShortVariablesOutput, # Avoid a Persalys Bug until v9.9
+ )
+ self.txtScriptPersalys += codePersalys.format(
+ fonctionPersalys=txtFonctionPersalys
+ )
+
+ ## Propagation des incertitudes :
+ ## Choix de la méthode, de ses paramètres, et des résultats attendus
+ if self.Methode == "Taylor":
+ txtCentralTendencyPersalys = centralTendencyTaylor
+ optionalResult = optionalResultTaylor
+ optionalPrintResult = optionalPrintResultTaylor
+ printResult = printResultTaylor
+ txtResultCT = resultTaylor
+ elif self.Methode == "MonteCarlo":
+ critereArret = ""
+ for mc in self.critereArret.mcListe:
+ critereArret += (
+ self.indent1
+ + critereArretMC[mc.nom].format(**{mc.nom: mc.valeur})
+ + "\n"
+ )
+
+ txtAdvancedParameterMC = ""
+ advancedParameter = ""
+ if self.advancedParameter != None:
+ for mc in self.advancedParameter.mcListe:
+ advancedParameter += (
+ self.indent1
+ + advancedParameterMC[mc.nom].format(**{mc.nom: mc.valeur})
+ + "\n"
+ )
+
+ txtCentralTendencyPersalys = centralTendencyMC.format(
+ critereArretMC=critereArret,
+ advancedParameterMC=advancedParameter,
+ BlockSize=self.Blocksize,
+ )
+ optionalResult = optionalResultMC
+ optionalPrintResult = optionalPrintResultMC
+ printResult = printResultMC
+ txtResultCT = resultMC
+ else:
+ return (0, "Impossible de gérer la méthode :", self.Methode)
+
+ result = ""
+ optionalResultNames = []
+ if self.Result:
+ for mc in self.Result.mcListe:
+ # print('mc : ',mc)
+ # print('mc.nature : ',mc.nature)
+ # print('mc.valeur : ',mc.valeur)
+ if mc.nom == "EmpiricalQuantile" and mc.valeur == "yes":
+ mc_nom = (
+ mc.nom[0].lower() + mc.nom[1:]
+ ) ##TODO: Utiliser un nv dict commun des symboles avec optionalResult
+ optionalResultNames.append(mc_nom)
+ empiricalQuantile_Order = self.Result.getChildOrChildInBloc(
+ "EmpiricalQuantile_Order"
+ )
+ result += (
+ self.indent1
+ + optionalResult[mc.nom].format(
+ **{
+ empiricalQuantile_Order.nom: empiricalQuantile_Order.valeur
+ }
+ )
+ + "\n"
+ )
+ result += (
+ self.indent1
+ + optionalPrintResult["EmpiricalQuantile_Order"]
+ + "\n"
+ )
+ result += self.indent1 + optionalPrintResult[mc.nom] + "\n"
+ elif mc.nature == "MCSIMP" and mc.valeur == "yes":
+ mc_nom = (
+ mc.nom[0].lower() + mc.nom[1:]
+ ) ##TODO: Utiliser un nv dict commun des symboles avec optionalResult
+ optionalResultNames.append(mc_nom)
+ result += self.indent1 + optionalResult[mc.nom] + "\n"
+ # result+= self.indent1+optionalPrintResult[mc.nom] + '\n'
+
+ # print('result:',result)
+ # print('txtResultCT:',txtResultCT)
+ optionalResultList = getStrVarList(optionalResultNames)
+ optionalResultStrList = getStrVarStrList(optionalResultNames)
+ post_csv_rnScript = os.path.basename(self.ScriptPosttraitement).split(".")[0]
+ post_csv_rnPath = os.path.dirname(self.ScriptPosttraitement)
+ print(post_csv_rnScript)
+ print(post_csv_rnPath)
+ txtPrintResult = printResult.format(
+ post_csv_rnScript=post_csv_rnScript,
+ post_csv_rnPath=post_csv_rnPath,
+ optionalResultList=optionalResultList,
+ optionalResultStrList=optionalResultStrList,
+ resultSkList=getStrVarList(self.resultSkList),
+ Uncertain_inputs=self.creeTexteInputVariablesSummary(self.indent1),
+ )
+ txtResult = txtResultCT.format(optionalResult=result)
+ txtResult += txtPrintResult
+
+ # TODO ;: Tester si Cluster== Gaia, ajouter les champs suivants
+ # resourceName = 'gaia'
+ # login='C65845'
+ # workDirectory = '/scratch/'+login+'/workingdir/persalys_light' #TODO: path.join
+ # resultDirectory = '/tmp/result_0'
+ wckey = "P11N0:SALOME"
+
+ inFiles = []
+ inFiles.append(os.path.join(generatorDir, "incertainty_tools.py"))
+ pyFile = self.fichierUQExe
+ inFiles.append(os.path.join(self.cheminFichierComm, pyFile))
+ pyFile = self.fichierBalise
+ inFiles.append(os.path.join(self.cheminFichierComm, pyFile))
+ scriptFile = os.path.abspath(self.UncertaintyScript)
+ inFiles.append(scriptFile)
+ postFile = os.path.abspath(self.ScriptPosttraitement)
+ inFiles.append(postFile)
+
+ if self.ExecutionMode == "cluster":
+ txtYacsJobClusterParameters = yacsJobClusterParameters.format(
+ nprocs=self.NbOfProcs, wckey=wckey
+ )
+ else:
+ txtYacsJobClusterParameters = ""
+
+ txtYacsJobParameters = yacsJobParameters.format(
+ nomEtude=self.JobName,
+ workDirectory=self.WorkDirectory,
+ resultDirectory=self.ResultDirectory,
+ resourceName=self.ResourceName,
+ nbBranches=self.NbDeBranches,
+ inFiles=repr(inFiles),
+ )
+ txtYacsJobParameters += txtYacsJobClusterParameters
+ if self.MultiJobStudy != None and self.MultiJobStudy == True:
+ txtYacsJobParameters += yacsJobClusterMultiJob
+
+ self.txtScriptPersalys += mainPersalys.format(
+ nomEtude=nomEtude,
+ inputVariableInitList=self.creeTexteInputVariables(self.indent1),
+ outputVariableInitList=self.txtOutputVariableInitList,
+ # outputVariableInitList = '#Not yet implemented',
+ inputHeaderPersalys=inputHeaderPersalys.format(indent=self.indent1),
+ chaineDesVariablesInput=self.chaineDesVariablesInput,
+ outputHeaderPersalys=outputHeaderPersalys.format(indent=self.indent1),
+ chaineDesVariablesOutput=self.chaineDesVariablesOutputEncodee,
+ yacsJobParameters=txtYacsJobParameters,
+ centralTendencyPersalys=txtCentralTendencyPersalys,
+ scenarioType=self.ScenarioType,
+ resultPersalys=txtResult,
+ )
+ self.txtScript = self.txtScriptPersalys
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+from builtins import str
+
+import traceback
+import types, re, os
+from Accas.extensions.eficas_translation import tr
+from Accas.IO.generator.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,
+ }
+
+
+class XMLGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+
+ """
+
+ # Les extensions de fichier permis?
+ extensions = (".comm",)
+
+ # ----------------------------------------------------------------------------------------
+ def gener(
+ self, obj, format="brut", config=None, appliEficas=None, uniteAsAttribut=False
+ ):
+ # try :
+ if 1:
+ self.texteXML = obj.toXml()
+ # except :
+ # self.texteXML='Erreur a la generation du fichier XML'
+ # 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):
+ if self.texteXML == "Erreur a la generation du fichier XML":
+ print(self.texteXML)
+ return 0
+ fileXML = fn[: fn.rfind(".")] + ".xml"
+ # filePyxb = fn[:fn.rfind(".")] + '.py'
+ fileBase = os.path.basename(fileXML)
+ fileBase = fileBase[: fileBase.rfind(".")] + ".py"
+ filePyxb = "/tmp/example_" + 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")
+ self.textePourAide = 'txt=""' + "\n" + self.textePourAide
+ self.textePourAide = self.textePourAide + "print (txt)" + "\n"
+ f.write(str(self.textePourAide))
+ f.close()
+ return 1
+
+ def generMCSIMP(self, obj):
+ if obj.nom != "Consigne":
+ 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
+ if obj.definition.avecBlancs:
+ self.textePourAide += (
+ nomUtil + " = vimmpCase." + obj.getNomDsXML() + ".s\n"
+ )
+ else:
+ self.textePourAide += (
+ nomUtil + " = vimmpCase." + obj.getNomDsXML() + "\n"
+ )
+ self.textePourAide += (
+ 'txt += "' + nomUtil + '" + " = " +str( ' + nomUtil + ')+"\\n"' + "\n"
+ )
+
+ s = PythonGenerator.generMCSIMP(self, obj)
+ return s
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ aplat pour EFICAS.
+
+"""
+
+import traceback
+import types, re
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+from Accas.processing import P_CR
+from Accas.processing.P_utils import repr_float
+from Accas import ETAPE, PROC_ETAPE, MACRO_ETAPE, ETAPE_NIVEAU, JDC, FORM_ETAPE
+from Accas import MCSIMP, MCFACT, MCBLOC, MCList, EVAL
+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
+
+ 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 = P_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.lNiveaux == ():
+ # 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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+from builtins import str
+
+import traceback
+import types, re, os
+from Accas.extensions.eficas_translation import tr
+from Accas.IO.generator.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,
+ }
+
+
+class DicoGenerator(PythonGenerator):
+ """
+ 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",)
+
+ # ----------------------------------------------------------------------------------------
+ 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 generDico(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.dicoComm
+
+ # ----------------------------------------------------------------------------------------
+ # initialisations
+ # ----------------------------------------------------------------------------------------
+
+ def initDico(self):
+ self.dicoComm = {}
+ self.rang = 0
+
+ # ----------------------------------------------------------------------------------------
+ # ecriture
+ # ----------------------------------------------------------------------------------------
+
+ def writeDefault(self, fn):
+ fileDico = fn[: fn.rfind(".")] + ".py"
+ f = open(str(fileDico), "w")
+ f.write("dicoComm = " + str(self.dicoComm))
+ f.close()
+
+ # ----------------------------------------------------------------------------------------
+ # analyse de chaque noeud de l'arbre
+ # ----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self, obj):
+ """recuperation de l objet MCSIMP"""
+ s = PythonGenerator.generMCSIMP(self, obj)
+ listeParents = []
+ objTraite = obj
+ while hasattr(objTraite, "parent") and objTraite.parent != None:
+ objTraite = objTraite.parent
+ if objTraite.nature == "JDC":
+ break
+ if objTraite.nature == "BLOC":
+ continue
+ if objTraite.nature == "OPERATEUR" or objTraite.nature == "PROCEDURE":
+ listeParents.insert(0, objTraite)
+ elif objTraite.nature == "MCList":
+ if len(objTraite.data > 1):
+ monRang = objTraite.data.index(objTraite)
+ listeParents.insert(0, objTraite.nom + "_" + str(monRang))
+ else:
+ listeParents.insert(0, objTraite.nom)
+ else:
+ listeParents.insert(0, objTraite.nom)
+ courant = self.dicoComm
+ # On traite l etape pour ajouter le rang et la classe
+ etape = listeParents[0]
+ ordreId = etape.parent.etapes.index(etape)
+ if etape.nature == "OPERATEUR":
+ if not etape.sd.nom in courant.keys():
+ courant[etape.sd.nom] = {}
+ courant[etape.sd.nom]["@classeAccas"] = etape.nom
+ courant[etape.sd.nom]["@ordreAccas"] = ordreId
+ courant = courant[etape.sd.nom]
+ else:
+ if not etape.nom in courant.keys():
+ courant[etape.nom] = {}
+ courant[etape.nom]["@classeAccas"] = etape.nom
+ courant[etape.nom]["@ordreAccas"] = ordreId
+ courant = courant[etape.nom]
+ else:
+ if not (isinstance(courant[etape.nom], list)):
+ laListe = [
+ courant[etape.nom],
+ ]
+ courant[etape.nom] = laListe
+ newDict = {}
+ newDict["@classeAccas"] = etape.nom
+ newDict["@ordreAccas"] = ordreId
+ courant[etape.nom].append(newDict)
+ courant = newDict
+ for p in listeParents[1:]:
+ if not (p in courant.keys()):
+ courant[p] = {}
+ courant = courant[p]
+ # on transforme les concepts en nom
+ laValeur = self.transformeObjInRef(obj)
+ courant[obj.nom] = laValeur
+ return s
+
+ def transformeObjInRef(self, obj):
+ # cas d une matrice d ASSD
+ for ssType in obj.definition.type:
+ if hasattr(ssType, "typElt"):
+ if ssType.typElt not in ("R", "I", "C", "TXM"):
+ # on a une matrice d ASSD
+ listeLigne = []
+ for ligne in obj.val:
+ col = []
+ for elt in ligne:
+ col.append(elt.nom)
+ listeLigne.append(col)
+ return listeLigne
+ waitASSDTuple = 0
+ if type(obj.valeur) in (tuple, list):
+ for ss_type in obj.definition.type:
+ if repr(ss_type).find("Tuple") != -1:
+ if hasattr(ssType, "typeDesTuples"):
+ for t in ssType.typeDesTuples:
+ if t not in ("R", "I", "C", "TXM"):
+ waitASSDTuple = 1
+ break
+ elif ss_type not in ("R", "I", "C", "TXM"):
+ waitASSDTuple = 1
+ if waitASSDTuple:
+ listeRetour = []
+ for elt in obj.val:
+ if hasattr(elt, "nom"):
+ listeRetour.append(elt.nom)
+ else:
+ listeRetour.append(elt)
+ return listeRetour
+
+ if hasattr(obj.val, "nom"):
+ listeRetour.append(obj.val.nom)
+ return obj.val
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+from builtins import str
+
+import traceback
+import types, re, os
+from Accas.extensions.eficas_translation import tr
+from Accas.IO.generator.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,
+ }
+
+
+class DicoImbriqueGenerator(PythonGenerator):
+ """
+ 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",)
+
+ # ----------------------------------------------------------------------------------------
+ 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 = ""
+
+ # ----------------------------------------------------------------------------------------
+ # ecriture
+ # ----------------------------------------------------------------------------------------
+
+ def writeDefault(self, fn):
+ fileDico = fn[: fn.rfind(".")] + ".py"
+ f = open(str(fileDico), "w")
+
+ f.write("Dico =" + str(self.Dico))
+ # f.write( self.Entete + "Dico =" + str(self.Dico) )
+ f.close()
+
+ # ----------------------------------------------------------------------------------------
+ # analyse de chaque noeud de l'arbre
+ # ----------------------------------------------------------------------------------------
+
+ 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
+
+ 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 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 hasattr(obj.valeur, "nom"):
+ dicoCourant[nomFeuille] = obj.valeur.nom
+ 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
+ self.Dico[nom] = dicoCourant
+
+ return s
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module sert pour charger les parametres de configuration d'EFICAS
+"""
+# Modules Python
+
+import os, sys, types, re
+from Accas.extensions.eficas_translation 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"
+ )
+
+ return texteModification
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ python pour EFICAS.
+
+"""
+
+from Accas.processing import P_CR
+from Accas.processing.P_utils import repr_float
+from Accas.extensions.parametre import ITEM_PARAMETRE
+from Accas.extensions.param2 import Formula
+from Accas.extensions.eficas_exception import EficasException
+from Accas.extensions.eficas_translation import tr
+import Accas
+
+
+def entryPoint():
+ """
+ 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,
+ }
+
+
+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 = P_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):
+ try:
+ with open(filename, "w") as fp:
+ fp.write(self.text)
+ return 1
+ except:
+ return 0
+
+ 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
+ """
+ if obj == None:
+ return
+ self.appliEficas = appliEficas
+ liste = self.generator(obj)
+ if format == "brut":
+ self.text = liste
+ elif format == "standard":
+ self.text = "".join(liste)
+ elif format == "beautifie":
+ from Accas.IO.generator.Formatage import Formatage
+ 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":
+ from Accas.IO.generator.Formatage import FormatageLigne
+ 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):
+ l.append(self.generUserASSD(obj.sdsDict[objRef]))
+ if obj.definition.lNiveaux == ():
+ # 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):
+ """
+ Methode particuliere pour les objets de type FORMULE
+ """
+ l = []
+ nom = obj.getNom()
+ if nom == "":
+ nom = "sansnom"
+ l.append(nom + " = FORMULE(")
+ for v in obj.mcListe:
+ text = self.generator(v)
+ l.append(v.nom + "=" + text)
+ 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
+ """
+ if (
+ obj.nom == "ExpressionIncertitude"
+ and hasattr(self, "generDeterministe")
+ and self.generDeterministe == True
+ ):
+ return ""
+ 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)
+ 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
+ if v.nom != "Consigne":
+ l.append(data)
+ return l
+
+ def formatItem(self, valeur, etape, obj, vientDeListe=0, matriceDAssd=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):
+ # 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)
+
+ elif matriceDAssd:
+ s = "["
+ for v in valeur:
+ s = s + str(self.generator(v)) + ", "
+
+ s = s + "]"
+ 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
+ matriceDAssd = 0
+ for ssType in obj.definition.type:
+ if hasattr(ssType, "typElt"):
+ if ssType.typElt not in ("R", "I", "C", "TXM"):
+ matriceDAssd = 1
+ break
+ 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, matriceDAssd) + ","
+ 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 :
+ 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
--- /dev/null
+# -*- coding: utf-8 -*-
+import os
+
+
+def value_repr_name(values):
+ """
+ Create a directory name using the representation of the values.
+ Example:
+ >>> valueReprName([0.5, 3.0 / 7.0])
+ 'c0.5_0.42857142857142855_'
+ """
+ s = "c"
+ for v in values:
+ s += repr(v) + "_"
+ return s
+
+
+def hashname(values):
+ """
+ Create a directory name using a hash function.
+ Example:
+ >>> hashName([0.5, 3.0 / 7.0])
+ '6f454e45e9a4fa8856688e80de6bfc58'
+ """
+ import hashlib
+
+ h = hashlib.md5(repr(values))
+ return h.hexdigest()
+
+
+def temp_dirname():
+ """
+ Create a temporary directory in the current directory.
+ """
+ import tempfile
+
+ return tempfile.mkdtemp(dir=os.getcwd())
+
+
+def replace_data(filename, key_values, filename_out=""):
+ """
+ Modify an input file using replace function.
+ Example:
+ origin file: "CPHY_MAT_ISO= $rho $cp $lambda -1 "
+ key_values: {'$rho':'3', '$cp':'5', '$lambda':7}
+ modified file: "CPHY_MAT_ISO= 3 5 7 -1"
+ """
+ with open(filename, "r") as f:
+ filedata = f.read()
+ for key, value in key_values.items():
+ filedata = filedata.replace(key, value)
+ if len(filename_out) == 0:
+ filename_out = filename
+ with open(filename_out, "w") as f:
+ f.write(filedata)
+
+
+def format_data(filename, key_values):
+ """
+ Modify an input file using format function.
+ Example:
+ origin file: "CPHY_MAT_ISO= {rho} {cp} {lambda} -1 "
+ key_values: {'rho':'3', 'cp':'5', 'lambda':'7'}
+ modified file: "CPHY_MAT_ISO= 3 5 7 -1"
+ """
+ with open(filename, "r") as f:
+ filedata = f.read()
+ filedata = filedata.format(**key_values)
+ with open(filename, "w") as f:
+ f.write(filedata)
--- /dev/null
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+Ce module contient les variables
+par defaut pour Aster
+"""
+
+from OpenturnsSTD import STDGenerateur
+from OpenturnsXML import XMLGenerateur
+
+#====================================================
+# Preparation du fichier STD
+#====================================================
+# C.1. Parties du texte en dur dans le fichier STD
+#-------------------------------------------------
+
+DecalSTD = " "
+DecalSTDsaut = "\n "
+
+TexteSTDFIN ="\n\nexcept : \n"
+TexteSTDFIN += DecalSTD + "error_message = sys.exc_type\n"
+TexteSTDFIN += "\nif error_message is not None :\n"
+TexteSTDFIN += DecalSTD + "texte = \"\\n=================================================\""
+TexteSTDFIN += DecalSTD + "texte += \"\\nMessage d'erreur : \" + str(error_message)"
+TexteSTDFIN += DecalSTD + "texte += \"\\n=================================================\\n\""
+TexteSTDFIN += DecalSTD + "print (texte)"
+TexteSTDFIN += DecalSTD + "\nsys.exit(error_message)\n"
+
+# C.2. Definition de composants dans le fichier STD
+#--------------------------------------------------
+
+NomFunction = "myFunction"
+NomPhysicalStartingPoint = "myPhysicalStartingPoint"
+NomCollection = "myCollection"
+NomCopule = "myCopula"
+NomDistribution = "myDistribution"
+NomRandomVector_in = "myRandomVector_in"
+NomRandomVector_out = "myRandomVector_out"
+NomEvent = "myEvent"
+NomMethod = "myMethod"
+NomAlgo = "myAlgo"
+NomRoot = "myRoot"
+NomSampling = "mySampling"
+NomSolverSD = "mySolver"
+NomResu = "myResu"
+
+class Defaut :
+# Cette classe ajoute les parametres par defaut propres au Solver Aster
+# Elle va d abord enrichir le dictionnaire DictMCVal avec des valeurs par defaut
+# C est la methode enrichitMCVal
+# Elle va ensuite enrichir les variables
+# C est la methode enrichitListeVariables
+
+ def __init__(self, parent) :
+ self.parent=parent
+ self.enrichitMCVal()
+ self.enrichitListeVariables()
+
+
+ def enrichitMCVal(self) :
+ #=====================
+ # InformationSolver : nom du wrapper, type de fichiers d'echange, etc
+ #----------------------------------------------------------------------
+ # Ajoute les informations sur le wrapper
+ # nom du wrapper, type de fichiers d'echange, etc.
+ dico = { "WrapperPath" : "Code_Aster.so",
+ "FunctionName" : "Code_Aster",
+ "WrapCouplingMode" : "fork",
+ "State" : "shared",
+ "InDataTransfer" : "files",
+ "OutDataTransfer" : "files",
+ }
+
+ self.parent.ajouteDictMCVal(dico)
+
+ #InformationSolverFile : parametres par defaut pour les fichiers d'echange
+ #--------------------------------------------------------------------------
+
+ liste = []
+ dicoIn = { "Id" : "file_in", "Type" : "in", "Name" : "StdIn", "Path" : "commandes_aster" }
+ liste.append(dicoIn)
+ dicoOut = { "Id" : "file_out", "Type" : "out", "Name" : "StdOut", "Path" : "resultats_aster", }
+ liste.append(dicoOut)
+ dicoFile={"exchange_file" : liste}
+ self.parent.ajouteDictMCVal(dicoFile)
+
+# D.2. InformationSolverCommande : arguments, etc
+#-------------------------------------------------------------------------
+# InformationSolverCommande est un dictionnaire indexe par le nom du solveur externe appele.
+# InformationSolverCommande[solveur] est lui-meme un dictionnaire qui contient les parametres
+# supplementaires pour la commande.
+# Des parametres sont donnes sous forme de tuple : (ok/nok, "mot-cle") ou (ok/nok, "mot-cle", valeur)
+# . On ajoute seulement si ok
+# . Avec (ok/nok, "mot-cle"), on ajoute en arguments les couples ("mot-cle", nom_du_parametre)
+# . Avec (ok/nok, "mot-cle", valeur), on ajoute en arguments les couples ("mot-cle", valeur)
+
+
+# dico = { "file_out" : (1, "-fic_de_aster_vers_ot"),
+# "variable_in" : (1, "-variable") }
+# self.parent.InformationSolverCommande["Code_Aster"] = dico
+
+
+ def enrichitListeVariables(self) :
+ # parametres par defaut pour chaque variable
+ #--------------------------------------------
+
+ dico_in = { "Regexp" : '"^" , "Name", "(.*)= *[0-9eE.+-]+([)]?;?)$"',
+ "Format" : '"Name", "\\1=%20.13G\\2"'
+ }
+ dico_out = { "Regexp" : '"(.*)"' }
+ self.parent.ajouteInfoVariables(dico_in,dico_out)
+
+class MonSTDGenerateur(STDGenerateur) :
+
+ def CreeResu (self) :
+ #------------------
+ '''
+ Le resultat :
+ . Donnees :
+ . l'algorithme choisi.
+ . Resultats :
+ . Ecriture des odres d'impression.
+ '''
+ if self.DictMCVal.has_key("Analysis"):
+ self.Analysis = str(self.DictMCVal["Analysis"])
+ else :
+ self.Analysis = None
+ self.fic_resu_OpenTURNS = "fic_resu_OpenTURNS_glop"
+ Algorithm = str (self.DictMCVal["Algorithm"])
+ texte = "\n\n# Le resultat\n"
+ texte += DecalSTDsaut + NomResu + " = " + NomAlgo + ".getResult()"
+ texte += DecalSTDsaut + "###" + "print ( " + NomResu+")"
+ texte += DecalSTDsaut + "text_resu = \"Resultats\\n=======\\n\""
+
+# Particularites des algorithmes de fiabilite
+
+ if self.Analysis in ( "Reliability", ) :
+ texte += DecalSTDsaut + "aux = " + NomResu + ".getIsStandardPointOriginInFailureSpace()"
+ texte += DecalSTDsaut + "if aux :"
+ texte += DecalSTDsaut + DecalSTD + "texte_bis = \"est\""
+ texte += DecalSTDsaut + "else :"
+ texte += DecalSTDsaut + DecalSTD + "texte_bis = \"n\'est pas\""
+ texte += DecalSTDsaut + "text_resu += \"\\nLe point initial \" + texte_bis + \" dans l\'espace de defaillance.\""
+ l_aux = [ ("Probabilite de defaillance", "EventProbability") ]
+ l_aux.append ( ("Indice de confiance generalise", "GeneralisedReliabilityIndex") )
+ l_aux.append ( ("Indice de confiance de Hasofer", "HasoferReliabilityIndex") )
+ for t_aux in l_aux :
+ texte += DecalSTDsaut + "text_resu += \"\\n" + t_aux[0] + " = \" + str(" \
+ + NomResu + ".get" + t_aux[1] + "())"
+ l_aux = []
+ l_aux.append("StandardSpaceDesignPoint")
+ l_aux.append("PhysicalSpaceDesignPoint")
+ l_aux.append("ImportanceFactors")
+ texte += DecalSTDsaut + "l_aux_var = []"
+ for DictVariable in self.ListeVariables :
+ if ( DictVariable["Type"] == "in" ) :
+ texte += DecalSTDsaut + "l_aux_var.append(\"" + DictVariable["Name"] + "\")"
+ texte += DecalSTDsaut + "l_aux = []"
+ for type_resu in l_aux :
+ texte += DecalSTDsaut + "l_aux.append(" + NomResu + ".get" + type_resu + "())"
+ texte += DecalSTDsaut + "for resu in l_aux :"
+ texte += DecalSTDsaut + DecalSTD + "if not resu.isEmpty() :"
+ texte += DecalSTDsaut + DecalSTD + DecalSTD + "text_resu += \"\\n\" + resu.getName() + \" :\""
+ texte += DecalSTDsaut + DecalSTD + DecalSTD + "size = resu.getDimension()"
+ texte += DecalSTDsaut + DecalSTD + DecalSTD + "l_aux_1 = resu.getCollection()"
+ texte += DecalSTDsaut + DecalSTD + DecalSTD + "for iaux in range(size) :"
+ texte += DecalSTDsaut + DecalSTD + DecalSTD + DecalSTD + "text_resu += \"\\n. \" + l_aux_var[iaux] + \" : \" + str(l_aux_1[iaux])"
+
+# Particularites des algorithmes de simulation
+
+ if self.Analysis in ( "Simulation", ) :
+ l_aux = [ ("Probabilite de defaillance", "ProbabilityEstimate") ]
+ l_aux.append ( ("Variance", "VarianceEstimate") )
+ l_aux.append ( ("Nombre d\'iterations", "OuterSampling") )
+ for t_aux in l_aux :
+ texte += DecalSTDsaut + "text_resu += \"\\n" + t_aux[0] + " = \" + str(" \
+ + NomResu + ".get" + t_aux[1] + "())"
+ texte += DecalSTDsaut + "text_resu += \"\\nNombre d'evaluations de l'etat limite = \" + str(" \
+ + NomResu + ".getOuterSampling()*" + NomResu + ".getBlockSize())"
+ if self.DictMCVal.has_key("ConfidenceIntervalProbability") :
+ aux = self.DictMCVal["ConfidenceIntervalProbability"]
+ texte += DecalSTDsaut + "proba = " + NomResu + ".getProbabilityEstimate()"
+ texte += DecalSTDsaut + "t_aux = "
+ if ( type(aux) is type(0.) ) :
+ texte += "(" + str(aux) + ")"
+ t_aux = [ str(aux) ]
+ else :
+ texte += str(aux)
+ texte += DecalSTDsaut + "for val in t_aux :"
+ texte += DecalSTDsaut + DecalSTD + "length = " + NomResu + ".getConfidenceLength(val)"
+ texte += DecalSTDsaut + DecalSTD + "vinf = str( proba - 0.5*length )"
+ texte += DecalSTDsaut + DecalSTD + "vsup = str( proba + 0.5*length )"
+ texte += DecalSTDsaut + DecalSTD + "text_resu += \"\\nIntervalle de confiance a \" + str(val) + \" = [ \" "
+ texte += "+ vinf + \" , \" + vsup + \" ]\""
+
+# Generalites
+
+ texte += DecalSTDsaut + "d_aux = {}"
+ texte += DecalSTDsaut + "d_aux[\"E\"] = ( \"de la fonction\", " + NomFunction + ".getEvaluationCallsNumber() )"
+ texte += DecalSTDsaut + "d_aux[\"G\"] = ( \"du gradient\", " + NomFunction + ".getGradientCallsNumber() )"
+ texte += DecalSTDsaut + "d_aux[\"H\"] = ( \"du hessien\", " + NomFunction + ".getHessianCallsNumber() )"
+ texte += DecalSTDsaut + "for cle in d_aux.keys() :"
+ texte += DecalSTDsaut + DecalSTD + "if d_aux[cle][1] > 0 :"
+ texte += DecalSTDsaut + DecalSTD + DecalSTD + "text_resu += \"\\nNombre d\'appels au solveur pour le calcul \"" \
+ + " + d_aux[cle][0] + \" = \" + str(d_aux[cle][1])"
+
+# Impression
+
+ texte += DecalSTDsaut + "print ( \"\\n\", text_resu, \" ) \\n\""
+ texte += DecalSTDsaut + "file_resu = open(\"" + self.fic_resu_OpenTURNS + "\", \"w\")"
+ texte += DecalSTDsaut + "file_resu.write(text_resu)"
+ texte += DecalSTDsaut + "file_resu.close()"
+ texte += DecalSTDsaut + "probability = " + NomResu + ".getEventProbability()"
+
+ return texte
+
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+"""
+Ce module contient la partie commune
+aux generateurs XML et Etude d Openturns
+"""
+
+__revision__ = "V1.0"
+
+import os
+import sys
+
+path=os.getcwd()
+pathDef=path+"DefautOpenturns"
+
+sys.path.append(pathDef)
+
+
+#=============================================
+# La classe generale
+#=============================================
+
+class Generateur :
+
+ '''
+ Classe generale du generateur
+ DictMCVal : dictionnaire des mots-cles
+ ListeVariables : chaque variable est decrite par un dictionnaire ; cette liste les regroupe
+ DictLois : dictionnaires des lois
+ '''
+ def __init__ (self, appli, DictMCVal = {}, ListeVariables = [], DictLois = {}, DictVariables = {} ) :
+ #---------------------------------------------------------#
+ self.ListeVariables = ListeVariables
+ self.ListeVariablesIn = []
+ self.ListeVariablesOut = []
+ self.DictLois = DictLois
+ self.DictVariables = DictVariables
+ self.DictMCVal = DictMCVal
+ self.DictTypeVar = {}
+ self.nbVarIn = 0
+ self.nbVarOut = 0
+ self.creeInfoVar()
+ self.appli = appli
+ #
+ # On charge eventuellement le Solver par defaut
+ # et les valeurs par defaut du Solver (dans l init)
+ #
+ try :
+ #if 1 :
+ Solver = self.DictMCVal["PhysicalSolver"]
+ import_name = "Defaut"+Solver
+ self.module = __import__( import_name, globals(), locals() )
+ monDefaut = self.module.Defaut( self )
+ #else :
+ except:
+ self.module = None
+
+
+ def getSTDGenerateur(self) :
+ #--------------------------#
+ try :
+ gener = self.module.__dict__["MonSTDGenerateur"]
+ monSTDGenerateur=gener( self.DictMCVal, self.ListeVariablesIn, self.ListeVariablesOut, self.DictLois )
+ except :
+ from OpenturnsSTD import STDGenerateur
+ monSTDGenerateur = STDGenerateur( self.appli, self.DictMCVal, self.ListeVariablesIn, self.ListeVariablesOut, self.DictLois )
+ return monSTDGenerateur
+
+ def getXMLGenerateur(self) :
+ #--------------------------#
+ try :
+ gener = self.module.__dict__["MonXMLGenerateur"]
+ monXMLGenerateur=gener( self.DictMCVal, self.ListeVariables, self.DictLois )
+ except :
+ from OpenturnsXML import XMLGenerateur
+ monXMLGenerateur = XMLGenerateur( self.appli, self.DictMCVal, self.DictVariables )
+ return monXMLGenerateur
+
+ def creeInfoVar (self) :
+ #----------------------#
+ """
+ On repere les variables in/out et on les numerote.
+ """
+ num = 0
+ liste = []
+ for DictVariable in self.ListeVariables :
+ if not DictVariable.has_key("Type") : DictVariable["Type"] = "in"
+ self.DictTypeVar[num] = DictVariable["Type"]
+ if DictVariable["Type"] == "in" :
+ self.nbVarIn = self.nbVarIn + 1
+ self.ListeVariablesIn.append( DictVariable )
+ print "OpenturnsBase.py: new input variable = ", DictVariable
+ else:
+ self.nbVarOut = self.nbVarOut + 1
+ self.ListeVariablesOut.append( DictVariable )
+ print "OpenturnsBase.py: new output variable = ", DictVariable
+ liste.append( DictVariable )
+ num = num + 1
+ self.ListeVariables = liste
+
+
+ def ajouteDictMCVal(self, dicoPlus) :
+ #-----------------------------------#
+ # Appele par le classe Defaut du python specifique au code (exple DefautASTER.py)
+ # enrichit self.DictMCVal avec les valeurs donnees dans dicoPlus
+ # si elles ne sont pas deja dans le dictionnaire
+
+ for clef in dicoPlus.keys():
+ if not self.DictMCVal.has_key(clef) :
+ self.DictMCVal[clef] = dicoPlus[clef]
+
+ def ajouteInfoVariables (self, dicoVariablesIn, dicoVariablesOut) :
+ #-----------------------------------------------------------------#
+ # Appele par le classe Defaut du python specifique au code (exple DefautASTER.py)
+ # met a jour les dictionnaires qui decrivent les variables (regexp par exemple)
+ liste=[]
+ num = 0
+ for dictVariable in self.ListeVariables:
+ if self.DictTypeVar[num] == "in" :
+ dico = dicoVariablesIn
+ else :
+ dico = dicoVariablesOut
+ for nouvelleVariable in dico.keys() :
+ if not dictVariable.has_key(nouvelleVariable):
+ dictVariable[nouvelleVariable] = dico[nouvelleVariable]
+ liste.append( dictVariable )
+ num = num + 1
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+"""
+Ce module contient le generateur Etude pour Openturns
+"""
+
+from Accas.extensions.eficas_translation import tr
+
+__revision__ = "V1.0"
+
+defaultSTD = """#! /usr/bin/env python
+
+class StudyFileGenerationError:
+ def __init__ (self, st):
+ self.st = st
+ def __str__(self):
+ return "'%s'" % self.st
+
+raise StudyFileGenerationError, "The study file was not generated. Check analysis type."
+"""
+
+headerSTD = """#! /usr/bin/env python
+
+# Chargement du module systeme
+import sys
+sys.path[:0]=['%s']
+
+# Chargement du module math
+import math
+
+# Chargement du module Open TURNS
+from openturns import *
+
+# Fonction verifiant si un echantillon contient des valeurs non valides (NaN)
+def contain_nan_values(sample):
+ for point in sample:
+ for val in point:
+ if math.isnan(val):
+ return True
+ return False
+
+results = {}
+
+"""
+
+viewerSTD = """
+from openturns.viewer import View
+
+# Fonction de test du serveur X
+import subprocess
+xserver_available = None
+def is_xserver_available():
+ global xserver_available
+ if xserver_available is None:
+ xserver_available = True
+ try:
+ subprocess.check_call('python -c "from matplotlib import pyplot;pyplot.figure()" >/dev/null 2>&1', shell = True)
+ except:
+ xserver_available = False
+ return xserver_available
+
+"""
+
+footerSTD = """
+
+# Flush des messages en attente
+Log.Flush()
+
+# Terminaison du fichier
+#sys.exit( 0 )
+"""
+
+#=============================================
+# La classe de creation du fichier STD
+#=============================================
+
+class STDGenerateur :
+
+ '''
+ Generation du fichier python
+ '''
+ def __init__ (self, appli, DictMCVal, ListeVariablesIn, ListeVariablesOut, DictLois ) :
+ self.DictMCVal = DictMCVal
+ self.ListeVariablesIn = ListeVariablesIn
+ self.ListeVariablesOut = ListeVariablesOut
+ self.DictLois = DictLois
+ #print "DictMCVal=", DictMCVal
+ print "ListeVariablesIn= %s", ListeVariablesIn
+
+# A REPRENDRE DEPUIS ICI !!
+ print "ListeVariablesOut= %s", ListeVariablesOut
+ #print "DictLois=", DictLois
+ self.texteSTD = defaultSTD
+ self.OpenTURNS_path = appli.maConfiguration.OpenTURNS_path
+
+ # Ce dictionnaire fait la correspondance entre le mot lu dans le dictionnaire des mots-clefs et la methode a appeler
+ self.traitement = {
+ "Min/Max" :
+ ( "MinMax",
+ { "Experiment Plane" : "ExperimentPlane",
+ "Random Sampling" : "MinMaxRandomSampling",
+ },
+ ),
+ "Central Uncertainty" :
+ ( "CentralUncertainty",
+ { "Taylor Variance Decomposition" : "TaylorVarianceDecomposition",
+ "Random Sampling" : "CentralUncertaintyRandomSampling",
+ },
+ ),
+ "Threshold Exceedence" :
+ ( "ThresholdExceedence",
+ { "Simulation" : "Simulation",
+ "FORM_SORM" : "Analytical",
+ "MonteCarlo" : "MonteCarlo",
+ "LHS" : "LHS",
+ "ImportanceSampling" : "ImportanceSampling",
+ "FirstOrder" : "FORM",
+ "SecondOrder" : "SORM",
+ "Cobyla" : "Cobyla",
+ "AbdoRackwitz" : "AbdoRackwitz",
+ },
+ ),
+ }
+
+ # Ce dictionnaire liste le nom des variables utilisees dans le script
+ # La clef est le nom attendu par les methodes, la valeur est le nom produit dans le fichier de sortie
+ # Le fait de passer par un dictionnaire permet de controler que les variables existent et sont correctement nommees
+ # meme si clef == valeur
+ self.variable = {
+ "n" : "n",
+ "p" : "p",
+ "wrapper" : "wrapper",
+ "wrapperdata" : "wrapperdata",
+ "frameworkdata" : "frameworkdata",
+ "framework" : "framework",
+ "studyid" : "studyid",
+ "studycase" : "studycase",
+ "componentname" : "componentname",
+ "model" : "model",
+ "scaledVector" : "scaledVector",
+ "translationVector" : "translationVector",
+ "levels" : "levels",
+ "myCenteredReductedGrid" : "myCenteredReductedGrid",
+ "myExperimentPlane" : "myExperimentPlane",
+ "inputSample" : "inputSample",
+ "outputSample" : "outputSample",
+ "minValue" : 'results["minValue"]',
+ "maxValue" : 'results["maxValue"]',
+ "flags" : "flags",
+ "inSize" : "inSize",
+ "distribution" : "distribution",
+ "marginal" : "marginal",
+ "collection" : "collection",
+ "copula" : "copula",
+ "correlation" : "correlation",
+ "R" : "R",
+ "vars" : "vars",
+ "description" : "description",
+ "inputRandomVector" : "inputRandomVector",
+ "outputRandomVector" : "outputRandomVector",
+ "myQuadraticCumul" : "myQuadraticCumul",
+ "meanFirstOrder" : 'results["meanFirstOrder"]',
+ "meanSecondOrder" : 'results["meanSecondOrder"]',
+ "standardDeviationFirstOrder" : 'results["standardDeviationFirstOrder"]',
+ "importanceFactors" : 'results["importanceFactors"]',
+ "importanceFactorsGraph" : "importanceFactorsGraph",
+ "importanceFactorsDrawing" : "importanceFactorsDrawing",
+ "empiricalMean" : 'results["empiricalMean"]',
+ "empiricalStandardDeviation" : 'results["empiricalStandardDeviation"]',
+ "empiricalQuantile" : 'results["empiricalQuantile"]',
+ "alpha" : "alpha",
+ "beta" : "beta",
+ "PCCcoefficient" : 'results["PCCcoefficient"]',
+ "PRCCcoefficient" : 'results["PRCCcoefficient"]',
+ "SRCcoefficient" : 'results["SRCcoefficient"]',
+ "SRRCcoefficient" : 'results["SRRCcoefficient"]',
+ "kernel" : "kernel",
+ "kernelSmoothedDist" : "kernelSmoothedDist",
+ "kernelSmoothedPDFDrawing" : "kernelSmoothedPDFDrawing",
+ "kernelSmoothedGraph" : "kernelSmoothedGraph",
+ "meanVector" : "meanVector",
+ "importanceDensity" : "importanceDensity",
+ "myEvent" : "myEvent",
+ "myAlgo" : "myAlgo",
+ "myResult" : "myResult",
+ "probability" : 'results["probability"]',
+ "standardDeviation" : 'results["standardDeviation"]',
+ "level" : "level",
+ "length" : "length",
+ "coefficientOfVariation" : 'results["coefficientOfVariation"]',
+ "convergenceGraph" : "convergenceGraph",
+ "convergenceDrawing" : "convergenceDrawing",
+ "simulationNumbers" : 'results["simulationNumbers"]',
+ "myOptimizer" : "myOptimizer",
+ "specificParameters" : "specificParameters",
+ "startingPoint" : "startingPoint",
+ "hasoferReliabilityIndex" : 'results["hasoferReliabilityIndex"]',
+ "standardSpaceDesignPoint" : 'results["standardSpaceDesignPoint"]',
+ "physicalSpaceDesignPoint" : 'results["physicalSpaceDesignPoint"]',
+ "eventProbabilitySensitivity" : 'results["eventProbabilitySensitivity"]',
+ "hasoferReliabilityIndexSensitivity" : 'results["hasoferReliabilityIndexSensitivity"]',
+ "eventProbabilitySensitivityGraph" : "eventProbabilitySensitivityGraph",
+ "eventProbabilitySensitivityDrawing" : "eventProbabilitySensitivityDrawing",
+ "hasoferReliabilityIndexSensitivityGraph" : "hasoferReliabilityIndexSensitivityGraph",
+ "hasoferReliabilityIndexSensitivityDrawing" : "hasoferReliabilityIndexSensitivityDrawing",
+ "modelEvaluationCalls" : 'results["modelEvaluationCalls"]',
+ "modelGradientCalls" : 'results["modelGradientCalls"]',
+ "modelHessianCalls" : 'results["modelHessianCalls"]',
+ "tvedtApproximation" : 'results["tvedtApproximation"]',
+ "hohenBichlerApproximation" : 'results["hohenBichlerApproximation"]',
+ "breitungApproximation" : 'results["breitungApproximation"]',
+ }
+
+ # Ce dictionnaire fait la correspondance entre le mot-clef du catalogue et le flag de la bibliotheque
+ self.logFlags = {
+ "DebugMessages" : "Log.DBG",
+ "WrapperMessages" : "Log.WRAPPER",
+ "UserMessages" : "Log.USER",
+ "InfoMessages" : "Log.INFO",
+ "WarningMessages" : "Log.WARN",
+ "ErrorMessages" : "Log.ERROR",
+ }
+
+ def CreeSTD (self) :
+ '''
+ Pilotage de la creation du fichier python
+ '''
+ TypeAnalyse = None
+ if ( self.DictMCVal.has_key( 'Type' ) ):
+ TypeAnalyse = self.DictMCVal[ 'Type' ]
+
+ traitement = None
+ subDict = {}
+ if ( self.traitement.has_key( TypeAnalyse ) ):
+ (traitement, subDict) = self.traitement[ TypeAnalyse ]
+
+ if ( traitement is not None ):
+ self.texteSTD = apply( STDGenerateur.__dict__[ traitement ], (self, subDict) )
+
+ return self.texteSTD
+
+ def Header (self) :
+ '''
+ Imprime l entete commun a tous les fichiers
+ '''
+ txt = headerSTD % self.OpenTURNS_path
+ txt += viewerSTD
+ txt += "# Definit le niveau d'affichage de la log\n"
+ txt += "%s = Log.NONE\n" % self.variable["flags"]
+ for flag in self.logFlags.keys():
+ if ( self.DictMCVal.has_key( flag ) ):
+ val = self.DictMCVal[ flag ]
+ op = "-"
+ if val == 'yes' :
+ op = "+"
+ txt += "%s = %s %s %s\n" % (self.variable["flags"], self.variable["flags"], op, self.logFlags[ flag ])
+ txt += "Log.Show( %s )\n" % self.variable["flags"]
+ txt += "\n"
+ return txt
+
+ def Footer (self) :
+ '''
+ Imprime le pied de page commun a tous les fichiers
+ '''
+ return footerSTD
+
+ def MinMax (self, subDict):
+ '''
+ Produit le fichier study correspondant a une analyse Min/Max
+ '''
+ txt = self.Header()
+ txt += self.Model()
+
+ Methode = None
+ if ( self.DictMCVal.has_key( 'Method' ) ):
+ Methode = self.DictMCVal[ 'Method' ]
+
+ traitement = None
+ if ( subDict.has_key( Methode ) ):
+ traitement = subDict[ Methode ]
+
+ if ( traitement is not None ):
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
+
+ txt += self.MinMaxResult()
+
+ txt += self.Footer()
+ return txt
+
+ def Model (self):
+ '''
+ Importe le modele physique
+ '''
+ if ( self.DictMCVal.has_key( 'FileName' ) ):
+ name = self.DictMCVal[ 'FileName' ]
+
+ txt = "# Charge le modele physique\n"
+ txt += "%s = WrapperFile( '%s' )\n" % (self.variable["wrapper"], name)
+ txt += "%s = %s.getWrapperData()\n" % (self.variable["wrapperdata"], self.variable["wrapper"])
+
+ txt += "# Ces lignes sont utiles pour le fonctionnement du script sous Salome\n"
+ txt += "if globals().has_key('%s'):\n" % self.variable["framework"]
+ txt += " %s = %s.getFrameworkData()\n" % (self.variable["frameworkdata"], self.variable["wrapperdata"])
+ txt += " %s.studyid_ = %s['%s']\n" % (self.variable["frameworkdata"], self.variable["framework"], self.variable["studyid"])
+ txt += " %s.studycase_ = %s['%s']\n" % (self.variable["frameworkdata"], self.variable["framework"], self.variable["studycase"])
+ txt += " %s.componentname_ = %s['%s']\n" % (self.variable["frameworkdata"], self.variable["framework"], self.variable["componentname"])
+ txt += " %s.setFrameworkData( %s )\n" % (self.variable["wrapperdata"], self.variable["frameworkdata"])
+ txt += " %s.setWrapperData( %s )\n" % (self.variable["wrapper"], self.variable["wrapperdata"])
+ txt += "# Fin des lignes pour Salome\n"
+
+ txt += "%s = NumericalMathFunction( %s )\n" % (self.variable["model"], self.variable["wrapper"],)
+ txt += "%s = %s.getInputDimension()\n" % (self.variable["n"], self.variable["model"])
+ txt += "\n"
+ return txt
+
+ def ExperimentPlane (self):
+ '''
+ Etude par plan d experience
+ '''
+ txt = "# Etude par plan d'experience\n"
+ txt += self.Levels()
+ txt += self.CenteredReductedGrid()
+ txt += self.ScaledVector()
+ txt += self.TranslationVector()
+ txt += "%s = %s\n" % (self.variable["inputSample"], self.variable["myExperimentPlane"])
+ txt += "\n"
+ txt += "# Etude 'Min/Max'\n"
+ txt += "# Calcul\n"
+ txt += "%s = %s( %s )\n" % (self.variable["outputSample"], self.variable["model"], self.variable["inputSample"])
+ txt += "if contain_nan_values( %s ):\n" % (self.variable["outputSample"])
+ txt += " raise Exception('Some computations failed')\n"
+ txt += "\n"
+ return txt
+
+ def MinMaxRandomSampling (self):
+ '''
+ Etude par echantillonage aleatoire
+ '''
+ size = 0
+ if ( self.DictMCVal.has_key( 'SimulationsNumber' ) ):
+ size = self.DictMCVal[ 'SimulationsNumber' ]
+
+ txt = "# Etude par echantillonage aleatoire\n"
+ txt += self.InputDistribution()
+ txt += self.InputRandomVector()
+ txt += "\n"
+ txt += "# Etude 'Min/Max'\n"
+ txt += "# Calcul\n"
+ txt += "%s = %d\n" % (self.variable["inSize"], size)
+ txt += "%s = RandomVector( %s, %s )\n" % (self.variable["outputRandomVector"], self.variable["model"], self.variable["inputRandomVector"])
+ txt += "%s = %s.getSample( %s )\n" % (self.variable["outputSample"], self.variable["outputRandomVector"], self.variable["inSize"])
+ txt += "if contain_nan_values( %s ):\n" % (self.variable["outputSample"])
+ txt += " raise Exception('Some computations failed')\n"
+ return txt
+
+ def InputDistribution (self):
+ '''
+ Cree la loi jointe des variables d entree
+ '''
+ txt = "# Definit la loi jointe des variables d'entree\n"
+ txt += "%s = DistributionCollection( %s )\n" % (self.variable["collection"], self.variable["n"])
+ txt += "%s = Description( %s )\n" % (self.variable["description"], self.variable["n"])
+ txt += "\n"
+
+ dictVariables = {}
+ for variable in self.ListeVariablesIn:
+ nomVar = variable['ModelVariable'].getName()
+ dictVariables[ nomVar ] = variable['Distribution']
+
+ i = 0
+ sortedVarNames = dictVariables.keys()
+ sortedVarNames.sort()
+ for variable in sortedVarNames:
+ conceptloi = dictVariables[ variable ]
+ loi = self.DictLois[ conceptloi ]
+ if loi.has_key( 'Kind' ):
+ marginale = "%s_%d" % (self.variable["marginal"], i)
+ txt += "# Definit la loi marginale de la composante %d\n" % i
+ txt += "%s = %s\n" % (marginale, apply( STDGenerateur.__dict__[ loi[ 'Kind' ] ], (self, loi) ))
+ txt += "%s.setName( '%s' )\n" % (marginale, conceptloi.getName())
+ txt += "%s[ %d ] = '%s'\n" % (self.variable["description"], i, variable)
+ txt += "%s[ %d ] = Distribution( %s )\n" % (self.variable["collection"], i, marginale)
+ txt += "\n"
+ i += 1
+
+ txt += self.Copula()
+
+ txt += "# Definit la loi jointe\n"
+ txt += "%s = ComposedDistribution( %s, Copula( %s ) )\n" % (self.variable["distribution"], self.variable["collection"], self.variable["copula"])
+ txt += "%s.setDescription( %s )\n" % (self.variable["distribution"], self.variable["description"])
+ txt += "\n"
+ return txt
+
+ def Copula (self):
+ '''
+ Cree la copule de la loi jointe
+ '''
+ txt = "# Definit la copule de la loi jointe\n"
+
+ if ( not self.DictMCVal.has_key( 'Copula' ) ):
+ self.DictMCVal[ 'Copula' ] = 'Independent'
+
+ if ( self.DictMCVal[ 'Copula' ] in ( 'Independent', ) ):
+ txt += "%s = IndependentCopula( %s )\n" % (self.variable["copula"], self.variable["n"])
+ elif ( self.DictMCVal[ 'Copula' ] in ( 'Normal', ) ):
+ varList = self.DictMCVal[ 'CorrelationMatrix' ][0]
+ dimension = len(varList)
+ txt += "%s = {}\n" % self.variable["correlation"]
+ for i in range( dimension ):
+ txt += "%s['%s'] = {}\n" % (self.variable["correlation"], varList[i])
+ for j in range ( dimension ):
+ txt += "%s['%s']['%s'] = %g\n" % (self.variable["correlation"], varList[i], varList[j], self.DictMCVal[ 'CorrelationMatrix' ][i+1][j])
+ txt += "%s = getCorrelationMatrixFromMap( %s.getVariableList(), %s )\n" % (self.variable["R"], self.variable["wrapperdata"], self.variable["correlation"])
+ txt += "%s = NormalCopula( %s )\n" % (self.variable["copula"], self.variable["R"])
+
+ txt += "\n"
+ return txt
+
+ def InputRandomVector (self):
+ '''
+ Cree le vector aleatoire d entree
+ '''
+ txt = "# Definit le vecteur aleatoire d'entree\n"
+ txt += "%s = RandomVector( %s )\n" % (self.variable["inputRandomVector"], self.variable["distribution"])
+ txt += "\n"
+ return txt
+
+ def OutputRandomVector (self):
+ '''
+ Cree le vector aleatoire de sortie
+ '''
+ nomVar = "output"
+ for variable in self.ListeVariablesOut:
+ nomVar = variable['ModelVariable'].getName()
+
+ txt = "# Definit le vecteur aleatoire de sortie\n"
+ txt += "%s = RandomVector( %s, %s )\n" % (self.variable["outputRandomVector"], self.variable["model"], self.variable["inputRandomVector"])
+ txt += "%s.setName( '%s' )\n" % (self.variable["outputRandomVector"], nomVar)
+ txt += "\n"
+ return txt
+
+ def ScaledVector (self):
+ '''
+ Definit les coefficients multiplicateurs par composante du vecteur
+ '''
+ dimension = 0
+ if ( self.DictMCVal.has_key( 'UnitsPerDimension' ) ):
+ unitsPerDimension = self.DictMCVal[ 'UnitsPerDimension' ]
+ dimension = len( unitsPerDimension )
+
+ txt = "# Definit les facteurs d'echelle dans chaque direction\n"
+ txt += "%s = NumericalPoint( %s )\n" % (self.variable["scaledVector"], self.variable["n"])
+ for i in range(dimension):
+ txt += "%s[%d] = %g\n" % (self.variable["scaledVector"], i, unitsPerDimension[i])
+ txt += "%s.scale( %s )\n" % (self.variable["myExperimentPlane"], self.variable["scaledVector"])
+ txt += "\n"
+ return txt
+
+ def TranslationVector (self):
+ '''
+ Definit le vecteur de translation
+ '''
+ dimension = 0
+ if ( self.DictMCVal.has_key( 'Center' ) ):
+ center = self.DictMCVal[ 'Center' ]
+ dimension = len( center )
+
+ txt = "# Definit le vecteur de translation\n"
+ txt += "%s = NumericalPoint( %s )\n" % (self.variable["translationVector"], self.variable["n"])
+ for i in range(dimension):
+ txt += "%s[%d] = %g\n" % (self.variable["translationVector"], i, center[i])
+ txt += "%s.translate( %s )\n" % (self.variable["myExperimentPlane"], self.variable["translationVector"])
+ txt += "\n"
+ return txt
+
+ def Levels (self):
+ '''
+ Definit les niveaux du plan d experience
+ '''
+ dimension = 0
+ if ( self.DictMCVal.has_key( 'Levels' ) ):
+ levels = self.DictMCVal[ 'Levels' ]
+ dimension = len( levels )
+
+ txt = "# Definit les niveaux de la structure de grille\n"
+ txt += "%s = NumericalPoint( %d )\n" % (self.variable["levels"], dimension)
+ for i in range(dimension):
+ txt += "%s[%d] = %g\n" % (self.variable["levels"], i, levels[i])
+ txt += "\n"
+ return txt
+
+ def CenteredReductedGrid (self):
+ '''
+ Definit la grille reduite du plan d experience
+ '''
+ plane = None
+ if ( self.DictMCVal.has_key( 'ExperimentPlane' ) ):
+ plane = self.DictMCVal[ 'ExperimentPlane' ]
+
+ txt = "# Cree le plan d'experience centre reduit\n"
+ txt += "%s = %s(%s, %s)\n" % (self.variable["myCenteredReductedGrid"], plane, self.variable["n"], self.variable["levels"])
+ txt += "%s = %s.generate()\n" % (self.variable["myExperimentPlane"], self.variable["myCenteredReductedGrid"])
+ txt += "\n"
+ return txt
+
+ def MinMaxResult (self):
+ '''
+ Produit les resultats de l etude
+ '''
+ txt = "# Resultats\n"
+ txt += "%s = %s.getMin()\n" % (self.variable["minValue"], self.variable["outputSample"])
+ txt += "print '%s = ', %s\n" % ("minValue", self.variable["minValue"])
+ txt += "\n"
+ txt += "%s = %s.getMax()\n" % (self.variable["maxValue"], self.variable["outputSample"])
+ txt += "print '%s = ', %s\n" % ("maxValue", self.variable["maxValue"])
+ txt += "\n"
+ return txt
+
+ def CentralUncertainty (self, subDict):
+ '''
+ Produit le fichier study correspondant a une analyse d incertitude en valeur centrale
+ '''
+ txt = self.Header()
+ txt += self.Model()
+ txt += self.InputDistribution()
+ txt += self.InputRandomVector()
+ txt += self.OutputRandomVector()
+
+ Methode = None
+ if ( self.DictMCVal.has_key( 'Method' ) ):
+ Methode = self.DictMCVal[ 'Method' ]
+
+ traitement = None
+ if ( subDict.has_key( Methode ) ):
+ traitement = subDict[ Methode ]
+
+ if ( traitement is not None ):
+ txt += "# Etude 'Central Uncertainty'\n"
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
+
+ txt += self.Footer()
+ return txt
+
+
+ def TaylorVarianceDecomposition (self):
+ '''
+ Etude par decomposition de Taylor
+ '''
+ txt = "# Cumul quadratique (decomposition de Taylor)\n"
+ txt += "%s = QuadraticCumul( %s )\n" % (self.variable["myQuadraticCumul"], self.variable["outputRandomVector"])
+ txt += "\n"
+ txt += "# Resultats\n"
+
+ if ( self.DictMCVal.has_key( 'MeanFirstOrder' ) ):
+ if ( self.DictMCVal[ 'MeanFirstOrder' ] == "yes" ):
+ txt += "%s = %s.getMeanFirstOrder()\n" % (self.variable["meanFirstOrder"], self.variable["myQuadraticCumul"])
+ txt += "print '%s = ', %s\n" % ("mean First Order", self.variable["meanFirstOrder"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'MeanSecondOrder' ) ):
+ if ( self.DictMCVal[ 'MeanSecondOrder' ] == "yes" ):
+ txt += "%s = %s.getMeanSecondOrder()\n" % (self.variable["meanSecondOrder"], self.variable["myQuadraticCumul"])
+ txt += "print '%s = ', %s\n" % ("mean Second Order", self.variable["meanSecondOrder"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'StandardDeviationFirstOrder' ) ):
+ if ( self.DictMCVal[ 'StandardDeviationFirstOrder' ] == "yes" ):
+ txt += "%s = %s.getCovariance()\n" % (self.variable["standardDeviationFirstOrder"], self.variable["myQuadraticCumul"])
+ txt += "dim = %s.getDimension()\n" % self.variable["standardDeviationFirstOrder"]
+ txt += "for i in range( dim ):\n"
+ txt += " %s[ i, i ] = math.sqrt( %s[ i, i ] )\n" % (self.variable["standardDeviationFirstOrder"], self.variable["standardDeviationFirstOrder"])
+ txt += " print '%s = ', %s[ i, i ]\n" % ("standard Deviation First Order", self.variable["standardDeviationFirstOrder"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'ImportanceFactor' ) ):
+ if ( self.DictMCVal[ 'ImportanceFactor' ] == "yes" ):
+ txt += "%s = %s.getImportanceFactors()\n" % (self.variable["importanceFactors"], self.variable["myQuadraticCumul"])
+ txt += "for i in range(%s.getDimension()):\n" % self.variable["importanceFactors"]
+ txt += " print %s.getDescription()[i], ':', %s[i]*100., '%%'\n" % (self.variable["distribution"], self.variable["importanceFactors"])
+ txt += "\n"
+ txt += "%s = %s.drawImportanceFactors()\n" % (self.variable["importanceFactorsGraph"], self.variable["myQuadraticCumul"])
+ txt += "%s = '%s'\n" % (self.variable["importanceFactorsDrawing"], self.DictMCVal[ 'ImportanceFactorDrawingFilename' ])
+ txt += "%s.draw( %s )\n" % (self.variable["importanceFactorsGraph"], self.variable["importanceFactorsDrawing"])
+ txt += "#if is_xserver_available():\n"
+ txt += "# view = View(%s)\n" % self.variable["importanceFactorsGraph"]
+ txt += "# view.show(block=True)\n"
+ txt += "#else:\n"
+ txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["importanceFactorsGraph"]
+ txt += "print 'bitmap =', %s.getBitmap()\n" % self.variable["importanceFactorsGraph"]
+ txt += "print 'postscript =', %s.getPostscript()\n" % self.variable["importanceFactorsGraph"]
+ txt += "\n"
+
+ txt += "\n"
+ return txt
+
+ def CentralUncertaintyRandomSampling (self):
+ '''
+ Etude par echantillonage aleatoire
+ '''
+ size = 0
+ if ( self.DictMCVal.has_key( 'SimulationsNumber' ) ):
+ size = self.DictMCVal[ 'SimulationsNumber' ]
+
+ txt = "# Echantillonnage aleatoire de la variable de sortie\n"
+ txt += "%s = %d\n" % (self.variable["inSize"], size)
+ txt += "%s = %s.getSample( %s )\n" % (self.variable["inputSample"], self.variable["inputRandomVector"], self.variable["inSize"])
+ txt += "%s = %s( %s )\n" % (self.variable["outputSample"], self.variable["model"], self.variable["inputSample"])
+ txt += "if contain_nan_values( %s ):\n" % (self.variable["outputSample"])
+ txt += " raise Exception('Some computations failed')\n"
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'EmpiricalMean' ) ):
+ if ( self.DictMCVal[ 'EmpiricalMean' ] == "yes" ):
+ txt += "%s = %s.computeMean()\n" % (self.variable["empiricalMean"], self.variable["outputSample"])
+ txt += "print '%s =', %s[0]\n" % ("empirical Mean", self.variable["empiricalMean"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'EmpiricalStandardDeviation' ) ):
+ if ( self.DictMCVal[ 'EmpiricalStandardDeviation' ] == "yes" ):
+ txt += "%s = %s.computeCovariance()\n" % (self.variable["empiricalStandardDeviation"], self.variable["outputSample"])
+ txt += "dim = %s.getDimension()\n" % self.variable["empiricalStandardDeviation"]
+ txt += "for i in range( dim ):\n"
+ txt += " %s[ i, i ] = math.sqrt( %s[ i, i ] )\n" % (self.variable["empiricalStandardDeviation"], self.variable["empiricalStandardDeviation"])
+ txt += " print '%s = ', %s[ i, i ]\n" % ("empirical Standard Deviation", self.variable["empiricalStandardDeviation"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'EmpiricalQuantile_Order' ) ):
+ ordre = self.DictMCVal[ 'EmpiricalQuantile_Order' ]
+ txt += "%s = %s.computeQuantile( %s )\n" % (self.variable["empiricalQuantile"], self.variable["outputSample"], ordre)
+ txt += "print '%s ( %s ) =', %s\n" % ("empirical Quantile", ordre, self.variable["empiricalQuantile"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'CorrelationAnalysis' ) ):
+ if ( self.DictMCVal[ 'CorrelationAnalysis' ] == "yes" ):
+ txt += "if ( %s.getDimension() == 1 ):\n" % self.variable["outputSample"]
+ txt += " %s = CorrelationAnalysis.PCC( %s, %s )\n" % (self.variable["PCCcoefficient"], self.variable["inputSample"], self.variable["outputSample"])
+ txt += " print 'PCC Coefficients:'\n"
+ txt += " for i in range( %s ):\n" % self.variable["n"]
+ txt += " print %s.getDescription()[i], ':', %s[i]\n" % (self.variable["distribution"], self.variable["PCCcoefficient"])
+ txt += "\n"
+ txt += " %s = CorrelationAnalysis.PRCC( %s, %s )\n" % (self.variable["PRCCcoefficient"], self.variable["inputSample"], self.variable["outputSample"])
+ txt += " print 'PRCC Coefficients:'\n"
+ txt += " for i in range( %s ):\n" % self.variable["n"]
+ txt += " print %s.getDescription()[i], ':', %s[i]\n" % (self.variable["distribution"], self.variable["PRCCcoefficient"])
+ txt += "\n"
+ txt += " %s = CorrelationAnalysis.SRC( %s, %s )\n" % (self.variable["SRCcoefficient"], self.variable["inputSample"], self.variable["outputSample"])
+ txt += " print 'SRC Coefficients:'\n"
+ txt += " for i in range( %s ):\n" % self.variable["n"]
+ txt += " print %s.getDescription()[i], ':', %s[i]\n" % (self.variable["distribution"], self.variable["SRCcoefficient"])
+ txt += "\n"
+ txt += " %s = CorrelationAnalysis.SRRC( %s, %s )\n" % (self.variable["SRRCcoefficient"], self.variable["inputSample"], self.variable["outputSample"])
+ txt += " print 'SRRC Coefficients:'\n"
+ txt += " for i in range( %s ):\n" % self.variable["n"]
+ txt += " print %s.getDescription()[i], ':', %s[i]\n" % (self.variable["distribution"], self.variable["SRRCcoefficient"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'KernelSmoothing' ) ):
+ if ( self.DictMCVal[ 'KernelSmoothing' ] == "yes" ):
+ txt += "# Kernel Smoohing\n"
+ txt += "%s = KernelSmoothing()\n" % self.variable["kernel"]
+ txt += "if ( %s.getDimension() == 1 ):\n" % self.variable["outputSample"]
+ txt += " %s.setName( 'Output' )\n" % self.variable["outputSample"]
+ txt += " %s = %s.build( %s, 'TRUE')\n" % (self.variable["kernelSmoothedDist"], self.variable["kernel"], self.variable["outputSample"])
+ txt += " %s = %s.drawPDF()\n" % (self.variable["kernelSmoothedGraph"], self.variable["kernelSmoothedDist"])
+ txt += " %s = '%s'\n" % (self.variable["kernelSmoothedPDFDrawing"], self.DictMCVal[ 'KernelSmoothingDrawingFilename' ])
+ txt += " %s.draw( %s )\n" % (self.variable["kernelSmoothedGraph"], self.variable["kernelSmoothedPDFDrawing"])
+ txt += " #if is_xserver_available():\n"
+ txt += " # view = View(%s)\n" % self.variable["kernelSmoothedGraph"]
+ txt += " # view.show(block=True)\n"
+ txt += " #else:\n"
+ txt += " # print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["kernelSmoothedGraph"]
+ txt += " print 'bitmap =', %s.getBitmap()\n" % self.variable["kernelSmoothedGraph"]
+ txt += " print 'postscript =', %s.getPostscript()\n" % self.variable["kernelSmoothedGraph"]
+ txt += "\n"
+
+ return txt
+
+ def ThresholdExceedence (self, subDict):
+ '''
+ Produit le fichier study correspondant a une analyse de depassement de seuil
+ '''
+ txt = self.Header()
+ txt += "# Etude 'Threshold Exceedence'\n"
+
+ txt += self.RandomGenerator()
+ txt += self.Model()
+ txt += self.InputDistribution()
+ txt += self.InputRandomVector()
+ txt += self.OutputRandomVector()
+ txt += self.Event()
+
+ Methode = None
+ if ( self.DictMCVal.has_key( 'Method' ) ):
+ Methode = self.DictMCVal[ 'Method' ]
+
+ traitement = None
+ if ( subDict.has_key( Methode ) ):
+ traitement = subDict[ Methode ]
+
+ if ( traitement is not None ):
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self, subDict) )
+
+ txt += self.Footer()
+ return txt
+
+ def Simulation (self, subDict):
+ '''
+ Methodes de simulation
+ '''
+ Algorithme = None
+ if ( self.DictMCVal.has_key( 'Algorithm' ) ):
+ Algorithme = self.DictMCVal[ 'Algorithm' ]
+
+ traitement = None
+ if ( subDict.has_key( Algorithme ) ):
+ traitement = subDict[ Algorithme ]
+
+ if ( traitement is not None ):
+ txt = apply( STDGenerateur.__dict__[ traitement ], (self,) )
+
+ maxOuterSampling = None
+ if ( self.DictMCVal.has_key( 'MaximumOuterSampling' ) ):
+ maxOuterSampling = self.DictMCVal[ 'MaximumOuterSampling' ]
+ txt += "%s.setMaximumOuterSampling( %s )\n" % (self.variable["myAlgo"], maxOuterSampling)
+
+ blockSize = None
+ if ( self.DictMCVal.has_key( 'BlockSize' ) ):
+ blockSize = self.DictMCVal[ 'BlockSize' ]
+ txt += "%s.setBlockSize( %s )\n" % (self.variable["myAlgo"], blockSize)
+
+ maxCoefficientOfVariation = None
+ if ( self.DictMCVal.has_key( 'MaximumCoefficientOfVariation' ) ):
+ maxCoefficientOfVariation = self.DictMCVal[ 'MaximumCoefficientOfVariation' ]
+ txt += "%s.setMaximumCoefficientOfVariation( %s )\n" % (self.variable["myAlgo"], maxCoefficientOfVariation)
+
+ txt += "%s.run()\n" % self.variable["myAlgo"]
+ txt += "\n"
+ txt += "# Resultats de la simulation\n"
+ txt += "%s = %s.getResult()\n" % (self.variable["myResult"], self.variable["myAlgo"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'Probability' ) ):
+ if ( self.DictMCVal[ 'Probability' ] == "yes" ):
+ txt += "%s = %s.getProbabilityEstimate()\n" % (self.variable["probability"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("probability", self.variable["probability"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'StandardDeviation' ) ):
+ if ( self.DictMCVal[ 'StandardDeviation' ] == "yes" ):
+ txt += "%s = math.sqrt( %s.getProbabilityEstimate() )\n" % (self.variable["standardDeviation"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("standard Deviation", self.variable["standardDeviation"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'ConfidenceInterval' ) and self.DictMCVal.has_key( 'Probability' ) ):
+ if ( ( self.DictMCVal[ 'ConfidenceInterval' ] == "yes" ) and ( self.DictMCVal[ 'Probability' ] == "yes" ) ):
+ level = self.DictMCVal[ 'Level' ]
+ txt += "%s = %s.getConfidenceLength( %s )\n" % (self.variable["length"], self.variable["myResult"], level)
+ txt += "print 'confidence interval at %s = [', %s-0.5*%s, ',', %s+0.5*%s, ']'\n" % (level, self.variable["probability"], self.variable["length"], self.variable["probability"], self.variable["length"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'VariationCoefficient' ) ):
+ if ( self.DictMCVal[ 'VariationCoefficient' ] == "yes" ):
+ txt += "%s = %s.getCoefficientOfVariation()\n" % (self.variable["coefficientOfVariation"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("coefficient of Variation", self.variable["coefficientOfVariation"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'SimulationsNumber' ) ):
+ if ( self.DictMCVal[ 'SimulationsNumber' ] == "yes" ):
+ txt += "%s = %s.getOuterSampling()\n" % (self.variable["simulationNumbers"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("simulation Numbers", self.variable["simulationNumbers"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'ConvergenceGraph' ) and self.DictMCVal.has_key( 'ConfidenceInterval' ) ):
+ if ( ( self.DictMCVal[ 'ConvergenceGraph' ] == "yes" ) and ( self.DictMCVal[ 'ConfidenceInterval' ] == "yes" ) ):
+ txt += "%s = %s\n" % (self.variable["alpha"], self.DictMCVal[ 'Level' ])
+ txt += "%s = %s.drawProbabilityConvergence( %s )\n" % (self.variable["convergenceGraph"], self.variable["myAlgo"], self.variable["alpha"])
+ txt += "%s = '%s'\n" % (self.variable["convergenceDrawing"], self.DictMCVal[ 'ConvergenceDrawingFilename' ])
+ txt += "%s.draw( %s )\n" % (self.variable["convergenceGraph"], self.variable["convergenceDrawing"])
+ txt += "#if is_xserver_available():\n"
+ txt += "# view = View(%s)\n" % self.variable["convergenceGraph"]
+ txt += "# view.show(block=True)\n"
+ txt += "#else:\n"
+ txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["convergenceGraph"]
+ txt += "\n"
+
+ return txt
+
+ def Analytical (self, subDict):
+ '''
+ Methodes analytiques
+ '''
+ txt = ""
+
+ OptimizationAlgo = None
+ if ( self.DictMCVal.has_key( 'OptimizationAlgorithm' ) ):
+ OptimizationAlgo = self.DictMCVal[ 'OptimizationAlgorithm' ]
+
+ traitement = None
+ if ( subDict.has_key( OptimizationAlgo ) ):
+ traitement = subDict[ OptimizationAlgo ]
+
+ if ( traitement is not None ):
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
+
+ txt += self.OptimizerSettings()
+ txt += self.PhysicalStartingPoint()
+
+ Approximation = None
+ if ( self.DictMCVal.has_key( 'Approximation' ) ):
+ Approximation = self.DictMCVal[ 'Approximation' ]
+
+ traitement = None
+ if ( subDict.has_key( Approximation ) ):
+ traitement = subDict[ Approximation ]
+
+ if ( traitement is not None ):
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
+
+ txt += self.RunAlgorithm()
+ txt += self.AnalyticalResult()
+
+ return txt
+
+ def OptimizerSettings (self):
+ '''
+ Parametrage de l optimiseur
+ '''
+ txt = ""
+
+ simulationNumbers = None
+ if ( self.DictMCVal.has_key( 'MaximumIterationsNumber' ) ):
+ simulationNumbers = self.DictMCVal[ 'MaximumIterationsNumber' ]
+ txt += "%s.setMaximumIterationsNumber( %s )\n" % (self.variable["myOptimizer"], simulationNumbers)
+
+ absoluteError = None
+ if ( self.DictMCVal.has_key( 'MaximumAbsoluteError' ) ):
+ absoluteError = self.DictMCVal[ 'MaximumAbsoluteError' ]
+ txt += "%s.setMaximumAbsoluteError( %s )\n" % (self.variable["myOptimizer"], absoluteError)
+
+ relativeError = None
+ if ( self.DictMCVal.has_key( 'MaximumRelativeError' ) ):
+ relativeError = self.DictMCVal[ 'MaximumRelativeError' ]
+ txt += "%s.setMaximumRelativeError( %s )\n" % (self.variable["myOptimizer"], relativeError)
+
+ residualError = None
+ if ( self.DictMCVal.has_key( 'MaximumResidualError' ) ):
+ residualError = self.DictMCVal[ 'MaximumResidualError' ]
+ txt += "%s.setMaximumResidualError( %s )\n" % (self.variable["myOptimizer"], residualError)
+
+ constraintError = None
+ if ( self.DictMCVal.has_key( 'MaximumConstraintError' ) ):
+ constraintError = self.DictMCVal[ 'MaximumConstraintError' ]
+ txt += "%s.setMaximumConstraintError( %s )\n" % (self.variable["myOptimizer"], constraintError)
+
+ txt += "\n"
+
+ return txt
+
+ def PhysicalStartingPoint (self):
+ '''
+ Point physique de depart
+ '''
+ txt = "# Point physique de depart\n"
+
+ if ( self.DictMCVal.has_key( 'PhysicalStartingPoint' ) ):
+ point = self.DictMCVal[ 'PhysicalStartingPoint' ]
+ dimension = len( point )
+ txt += "%s = NumericalPoint( %d )\n" % (self.variable["startingPoint"], dimension)
+ for i in range( dimension ):
+ txt += "%s[ %d ] = %g\n" % (self.variable["startingPoint"], i, point[i])
+ else:
+ txt += "%s = %s.getMean()\n" % (self.variable["startingPoint"], self.variable["inputRandomVector"])
+
+ txt += "\n"
+
+ return txt
+
+ def AnalyticalResult (self):
+ '''
+ Resultat des methodes analytiques
+ '''
+ txt = "# Resultat des methodes analytiques\n"
+ txt += "%s = %s.getResult()\n" % (self.variable["myResult"], self.variable["myAlgo"])
+
+ if ( self.DictMCVal.has_key( 'Probability' ) ):
+ if ( self.DictMCVal[ 'Probability' ] == "yes" ):
+ txt += "%s = %s.getEventProbability()\n" % (self.variable["probability"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % (self.variable["probability"], self.variable["probability"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'HasoferReliabilityIndex' ) ):
+ if ( self.DictMCVal[ 'HasoferReliabilityIndex' ] == "yes" ):
+ txt += "%s = %s.getHasoferReliabilityIndex()\n" % (self.variable["hasoferReliabilityIndex"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("hasofer Reliability Index", self.variable["hasoferReliabilityIndex"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'DesignPoint' ) ):
+ if ( self.DictMCVal[ 'DesignPoint' ] == "yes" ):
+ txt += "%s = %s.getStandardSpaceDesignPoint()\n" % (self.variable["standardSpaceDesignPoint"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("standard Space Design Point", self.variable["standardSpaceDesignPoint"])
+ txt += "%s = %s.getPhysicalSpaceDesignPoint()\n" % (self.variable["physicalSpaceDesignPoint"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("physical Space Design Point", self.variable["physicalSpaceDesignPoint"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'ImportanceFactor' ) ):
+ if ( self.DictMCVal[ 'ImportanceFactor' ] == "yes" ):
+ txt += "print 'Importance Factors:'\n"
+ txt += "%s = %s.getImportanceFactors()\n" % (self.variable["importanceFactors"], self.variable["myResult"])
+ txt += "for i in range(%s.getDimension()):\n" % self.variable["importanceFactors"]
+ txt += " print %s.getDescription()[i], ':', %s[i]*100., '%%'\n" % (self.variable["distribution"], self.variable["importanceFactors"])
+ txt += "\n"
+ txt += "%s = %s.drawImportanceFactors()\n" % (self.variable["importanceFactorsGraph"], self.variable["myResult"])
+ txt += "%s = '%s'\n" % (self.variable["importanceFactorsDrawing"], self.DictMCVal[ 'ImportanceFactorDrawingFilename' ])
+ txt += "%s.draw( %s )\n" % (self.variable["importanceFactorsGraph"], self.variable["importanceFactorsDrawing"])
+ txt += "#if is_xserver_available():\n"
+ txt += "# view = View(%s)\n" % self.variable["importanceFactorsGraph"]
+ txt += "# view.show(block=True)\n"
+ txt += "#else:\n"
+ txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["importanceFactorsGraph"]
+ txt += "print 'bitmap =', %s.getBitmap()\n" % self.variable["importanceFactorsGraph"]
+ txt += "print 'postscript =', %s.getPostscript()\n" % self.variable["importanceFactorsGraph"]
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'FORMEventProbabilitySensitivity' ) ):
+ if ( self.DictMCVal[ 'FORMEventProbabilitySensitivity' ] == "yes" ):
+ txt += "%s = %s.getEventProbabilitySensitivity()\n" % (self.variable["eventProbabilitySensitivity"], self.variable["myResult"])
+ txt += "print 'FORM Event Probability Sensitivity:'\n"
+ txt += "for i in range( %s ):\n" % self.variable["n"]
+ txt += " print %s.getDescription()[i], ':'\n" % self.variable["distribution"]
+ txt += " for j in range( %s[i].getDimension() ):\n" % self.variable["eventProbabilitySensitivity"]
+ txt += " print ' ', %s[i].getDescription()[j], ':', %s[i][j]\n" % (self.variable["eventProbabilitySensitivity"], self.variable["eventProbabilitySensitivity"])
+ txt += "\n"
+ txt += "%s = %s.drawEventProbabilitySensitivity()[0]\n" % (self.variable["eventProbabilitySensitivityGraph"], self.variable["myResult"])
+ txt += "%s = '%s'\n" % (self.variable["eventProbabilitySensitivityDrawing"], self.DictMCVal[ 'FORMEventProbabilitySensitivityDrawingFilename' ])
+ txt += "%s.draw( %s )\n" % (self.variable["eventProbabilitySensitivityGraph"], self.variable["eventProbabilitySensitivityDrawing"])
+ txt += "#if is_xserver_available():\n"
+ txt += "# view = View(%s)\n" % self.variable["eventProbabilitySensitivityGraph"]
+ txt += "# view.show(block=True)\n"
+ txt += "#else:\n"
+ txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["eventProbabilitySensitivityGraph"]
+ txt += "print 'bitmap =', %s.getBitmap()\n" % self.variable["eventProbabilitySensitivityGraph"]
+ txt += "print 'postscript =', %s.getPostscript()\n" % self.variable["eventProbabilitySensitivityGraph"]
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'HasoferReliabilityIndexSensitivity' ) ):
+ if ( self.DictMCVal[ 'HasoferReliabilityIndexSensitivity' ] == "yes" ):
+ txt += "%s = %s.getHasoferReliabilityIndexSensitivity()\n" % (self.variable["hasoferReliabilityIndexSensitivity"], self.variable["myResult"])
+ txt += "print 'Hasofer Reliability Index Sensitivity:'\n"
+ txt += "for i in range( %s ):\n" % self.variable["n"]
+ txt += " print %s.getDescription()[i], ':'\n" % self.variable["distribution"]
+ txt += " for j in range( %s[i].getDimension() ):\n" % self.variable["hasoferReliabilityIndexSensitivity"]
+ txt += " print ' ', %s[i].getDescription()[j], ':', %s[i][j]\n" % (self.variable["hasoferReliabilityIndexSensitivity"], self.variable["hasoferReliabilityIndexSensitivity"])
+ txt += "\n"
+ txt += "%s = %s.drawHasoferReliabilityIndexSensitivity()[0]\n" % (self.variable["hasoferReliabilityIndexSensitivityGraph"], self.variable["myResult"])
+ txt += "%s = '%s'\n" % (self.variable["hasoferReliabilityIndexSensitivityDrawing"], self.DictMCVal[ 'HasoferReliabilityIndexSensitivityDrawingFilename' ])
+ txt += "%s.draw( %s )\n" % (self.variable["hasoferReliabilityIndexSensitivityGraph"], self.variable["hasoferReliabilityIndexSensitivityDrawing"])
+ txt += "#if is_xserver_available():\n"
+ txt += "# view = View(%s)\n" % self.variable["hasoferReliabilityIndexSensitivityGraph"]
+ txt += "# view.show(block=True)\n"
+ txt += "#else:\n"
+ txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["hasoferReliabilityIndexSensitivityGraph"]
+ txt += "print 'bitmap =', %s.getBitmap()\n" % self.variable["hasoferReliabilityIndexSensitivityGraph"]
+ txt += "print 'postscript =', %s.getPostscript()\n" % self.variable["hasoferReliabilityIndexSensitivityGraph"]
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'TvedtApproximation' ) ):
+ if ( self.DictMCVal[ 'TvedtApproximation' ] == "yes" ):
+ txt += "%s = %s.getEventProbabilityTvedt()\n" % (self.variable["tvedtApproximation"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("Tvedt Approximation", self.variable["tvedtApproximation"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'HohenBichlerApproximation' ) ):
+ if ( self.DictMCVal[ 'HohenBichlerApproximation' ] == "yes" ):
+ txt += "%s = %s.getEventProbabilityHohenBichler()\n" % (self.variable["hohenBichlerApproximation"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("HohenBichler Approximation", self.variable["tvedtApproximation"])
+ txt += "\n"
+
+ if ( self.DictMCVal.has_key( 'BreitungApproximation' ) ):
+ if ( self.DictMCVal[ 'BreitungApproximation' ] == "yes" ):
+ txt += "%s = %s.getEventProbabilityBreitung()\n" % (self.variable["breitungApproximation"], self.variable["myResult"])
+ txt += "print '%s =', %s\n" % ("Breitung Approximation", self.variable["breitungApproximation"])
+ txt += "\n"
+
+
+ return txt
+
+ def RandomGenerator (self):
+ '''
+ Generateur Aleatoire
+ '''
+ txt = ""
+
+ seed = None
+ if ( self.DictMCVal.has_key( 'RandomGeneratorSeed' ) ):
+ seed = self.DictMCVal[ 'RandomGeneratorSeed' ]
+ txt += "# Initialise le generateur aleatoire\n"
+ txt += "RandomGenerator.SetSeed( %s )\n" % seed
+ txt += "\n"
+
+ return txt
+
+ def Event (self):
+ '''
+ Definition de l evenement de defaillance
+ '''
+ operator = None
+ if ( self.DictMCVal.has_key( 'ComparisonOperator' ) ):
+ operator = self.DictMCVal[ 'ComparisonOperator' ]
+
+ threshold = None
+ if ( self.DictMCVal.has_key( 'Threshold' ) ):
+ threshold = self.DictMCVal[ 'Threshold' ]
+
+ txt = "# Evenement de defaillance\n"
+ txt += "%s = Event( %s, ComparisonOperator( %s() ), %s )\n" % (self.variable["myEvent"], self.variable["outputRandomVector"], operator, threshold)
+ txt += "%s.setName( '%s' )\n" % (self.variable["myEvent"], "myEvent")
+ txt += "\n"
+ return txt
+
+ def MonteCarlo (self):
+ '''
+ Methode de MonteCarlo
+ '''
+ txt = "# Simulation par MonteCarlo\n"
+ txt += "%s = MonteCarlo( %s )\n" % (self.variable["myAlgo"], self.variable["myEvent"])
+ txt += "\n"
+
+ return txt
+
+ def LHS (self):
+ '''
+ Methode LHS
+ '''
+ txt = "# Simulation par LHS\n"
+ txt += "%s = LHS( %s )\n" % (self.variable["myAlgo"], self.variable["myEvent"])
+ txt += "\n"
+
+ return txt
+
+ def ImportanceSampling (self):
+ '''
+ Methode de tirage d importance
+ '''
+ dimension = 0
+ if ( self.DictMCVal.has_key( 'MeanVector' ) ):
+ meanVector = self.DictMCVal[ 'MeanVector' ]
+ dimension = len( meanVector )
+
+ txt = "# Simulation par Tirage d'importance\n"
+ txt += "# Densite d'importance\n"
+ txt += "%s = NumericalPoint( %s )\n" % (self.variable["meanVector"], self.variable["n"])
+ for i in range(dimension):
+ txt += "%s[%d] = %g\n" % (self.variable["meanVector"], i, meanVector[i])
+
+ txt += "%s = Normal( %s, CovarianceMatrix( IdentityMatrix( %s ) ) )\n" % (self.variable["importanceDensity"], self.variable["meanVector"], self.variable["n"])
+ txt += "%s = ImportanceSampling( %s, Distribution( %s ) )\n" % (self.variable["myAlgo"], self.variable["myEvent"], self.variable["importanceDensity"])
+ txt += "\n"
+
+ return txt
+
+ def FORM (self):
+ '''
+ Methode FORM
+ '''
+ txt = "# Algorithme FORM\n"
+ txt += "%s = FORM ( NearestPointAlgorithm( %s ), %s, %s )\n" % (self.variable["myAlgo"], self.variable["myOptimizer"], self.variable["myEvent"], self.variable["startingPoint"])
+ txt += "\n"
+
+ return txt
+
+ def SORM (self):
+ '''
+ Methode SORM
+ '''
+ txt = "# Algorithme SORM\n"
+ txt += "%s = SORM ( NearestPointAlgorithm( %s ), %s, %s )\n" % (self.variable["myAlgo"], self.variable["myOptimizer"], self.variable["myEvent"], self.variable["startingPoint"])
+ txt += "\n"
+
+ return txt
+
+ def RunAlgorithm (self):
+ '''
+ Do the computation
+ '''
+ txt = ""
+ if ( self.DictMCVal.has_key( 'FunctionCallsNumber' ) ):
+ if ( self.DictMCVal[ 'FunctionCallsNumber' ] == "yes" ):
+ txt += "%s = %s.getEvaluationCallsNumber()\n" % (self.variable["modelEvaluationCalls"], self.variable["model"])
+ txt += "%s = %s.getGradientCallsNumber()\n" % (self.variable["modelGradientCalls"], self.variable["model"])
+ txt += "%s = %s.getHessianCallsNumber()\n" % (self.variable["modelHessianCalls"], self.variable["model"])
+ txt += "\n"
+
+ txt += "# Perform the computation\n"
+ txt += "%s.run()\n" % self.variable["myAlgo"]
+ txt += "\n"
+
+
+ if ( self.DictMCVal.has_key( 'FunctionCallsNumber' ) ):
+ if ( self.DictMCVal[ 'FunctionCallsNumber' ] == "yes" ):
+ txt += "%s = %s.getEvaluationCallsNumber() - %s\n" % (self.variable["modelEvaluationCalls"], self.variable["model"], self.variable["modelEvaluationCalls"])
+ txt += "%s = %s.getGradientCallsNumber() - %s\n" % (self.variable["modelGradientCalls"], self.variable["model"], self.variable["modelGradientCalls"])
+ txt += "%s = %s.getHessianCallsNumber() - %s\n" % (self.variable["modelHessianCalls"], self.variable["model"], self.variable["modelHessianCalls"])
+ txt += "\n"
+ txt += "print '%s =', %s\n" % ("model Evaluation Calls", self.variable["modelEvaluationCalls"])
+ txt += "print '%s =', %s\n" % ("model Gradient Calls", self.variable["modelGradientCalls"])
+ txt += "print '%s =', %s\n" % ("model Hessian Calls", self.variable["modelHessianCalls"])
+ txt += "\n"
+
+ return txt
+
+ def Cobyla (self):
+ '''
+ Methode Cobyla
+ '''
+ txt = "# Optimisation par Cobyla\n"
+ txt += "%s = Cobyla()\n" % self.variable["myOptimizer"]
+ txt += "#%s = CobylaSpecificParameters()\n" % self.variable["specificParameters"]
+ txt += "#%s.setSpecificParameters( %s )\n" % (self.variable["myOptimizer"], self.variable["specificParameters"])
+ txt += "\n"
+
+ return txt
+
+ def AbdoRackwitz (self):
+ '''
+ Methode AbdoRackwitz
+ '''
+ txt = "# Optimisation par AbdoRackwitz\n"
+ txt += "%s = AbdoRackwitz()\n" % self.variable["myOptimizer"]
+ txt += "#%s = AbdoRackwitzSpecificParameters()\n" % self.variable["specificParameters"]
+ txt += "#%s.setSpecificParameters( %s )\n" % (self.variable["myOptimizer"], self.variable["specificParameters"])
+ txt += "\n"
+ return txt
+
+ def Beta (self, loi):
+ '''
+ Definition de la loi Beta
+ '''
+ settings = {
+ "RT" : "Beta.RT",
+ "MuSigma" : "Beta.MUSIGMA",
+ }
+ if loi[ 'Settings' ] == 'RT' :
+ arg1 = loi[ 'R' ]
+ arg2 = loi[ 'T' ]
+ else :
+ arg1 = loi[ 'Mu' ]
+ arg2 = loi[ 'Sigma' ]
+
+ arg3 = loi[ 'A' ]
+ arg4 = loi[ 'B' ]
+ txt = "Beta( %g, %g, %g, %g, %s )" % (arg1, arg2, arg3, arg4, settings[ loi[ 'Settings' ] ])
+ return txt
+
+ def Exponential (self, loi):
+ '''
+ Definition de la loi Exponential
+ '''
+ arg1 = loi[ 'Lambda' ]
+ arg2 = loi[ 'Gamma' ]
+ txt = "Exponential( %g, %g )" % (arg1, arg2)
+ return txt
+
+ def Gamma (self, loi):
+ '''
+ Definition de la loi Gamma
+ '''
+ settings = {
+ "KLambda" : "Gamma.KLAMBDA",
+ "MuSigma" : "Gamma.MUSIGMA",
+ }
+ if loi[ 'Settings' ] == 'KLambda' :
+ arg1 = loi[ 'K' ]
+ arg2 = loi[ 'Lambda' ]
+ else :
+ arg1 = loi[ 'Mu' ]
+ arg2 = loi[ 'Sigma' ]
+
+ arg3 = loi[ 'Gamma' ]
+ txt = "Gamma( %g, %g, %g, %s )" % (arg1, arg2, arg3, settings[ loi[ 'Settings' ] ])
+ return txt
+
+ def Geometric (self, loi):
+ '''
+ Definition de la loi Geometric
+ '''
+ txt = "Geometric( %g )" % loi[ 'P' ]
+ return txt
+
+ def Gumbel (self, loi):
+ '''
+ Definition de la loi Gumbel
+ '''
+ settings = {
+ "AlphaBeta" : "Gumbel.ALPHABETA",
+ "MuSigma" : "Gumbel.MUSIGMA",
+ }
+ if loi[ 'Settings' ] == 'AlphaBeta' :
+ arg1 = loi[ 'Alpha' ]
+ arg2 = loi[ 'Beta' ]
+ else :
+ arg1 = loi[ 'Mu' ]
+ arg2 = loi[ 'Sigma' ]
+
+ txt = "Gumbel( %g, %g, %s )" % (arg1, arg2, settings[ loi[ 'Settings' ] ])
+ return txt
+
+ def Histogram (self, loi):
+ '''
+ Definition de la loi Histogram
+ '''
+ arg1 = loi[ 'First' ]
+ arg2 = loi[ 'Values' ]
+ txt = "Histogram( %g, %s )" % (arg1, arg2)
+ return txt
+
+ def Laplace (self, loi):
+ '''
+ Definition de la loi Laplace
+ '''
+ arg1 = loi[ 'Lambda' ]
+ arg2 = loi[ 'Mu' ]
+ txt = "Laplace( %g, %g )" % (arg1, arg2)
+ return txt
+
+ def Logistic (self, loi):
+ '''
+ Definition de la loi Logistic
+ '''
+ arg1 = loi[ 'Alpha' ]
+ arg2 = loi[ 'Beta' ]
+ txt = "Logistic( %g, %g )" % (arg1, arg2)
+ return txt
+
+ def LogNormal (self, loi):
+ '''
+ Definition de la loi LogNormal
+ '''
+ settings = {
+ "MuSigmaLog" : "LogNormal.MUSIGMA_LOG",
+ "MuSigma" : "LogNormal.MUSIGMA",
+ "MuSigmaOverMu" : "LogNormal.MU_SIGMAOVERMU",
+ }
+ if loi[ 'Settings' ] == 'MuSigmaLog' :
+ arg1 = loi[ 'MuLog' ]
+ arg2 = loi[ 'SigmaLog' ]
+ elif loi[ 'Settings' ] == 'MuSigmaOverMu' :
+ arg1 = loi[ 'Mu' ]
+ arg2 = loi[ 'SigmaOverMu' ]
+ else :
+ arg1 = loi[ 'Mu' ]
+ arg2 = loi[ 'Sigma' ]
+
+ arg3 = loi[ 'Gamma' ]
+ txt = "LogNormal( %g, %g, %g, %s )" % (arg1, arg2, arg3, settings[ loi[ 'Settings' ] ])
+ return txt
+
+ def MultiNomial (self, loi):
+ '''
+ Definition de la loi MultiNomial
+ '''
+ arg1 = loi[ 'Values' ]
+ arg2 = loi[ 'N' ]
+ txt = "MultiNomial( NumericalPoint( %s ) , %d)" % (arg1, arg2)
+ return txt
+
+ def NonCentralStudent (self, loi):
+ '''
+ Definition de la loi NonCentralStudent
+ '''
+ arg1 = loi[ 'Nu' ]
+ arg2 = loi[ 'Delta' ]
+ arg3 = loi[ 'Gamma' ]
+ txt = "NonCentralStudent( %g, %g )" % (arg1, arg2, arg3)
+ return txt
+
+ def Normal (self, loi):
+ '''
+ Definition de la loi Normal
+ '''
+ arg1 = loi[ 'Mu' ]
+ arg2 = loi[ 'Sigma' ]
+ txt = "Normal( %g, %g )" % (arg1, arg2)
+ return txt
+
+ def TruncatedNormal (self, loi):
+ '''
+ Definition de la loi TruncatedNormal
+ '''
+ arg1 = loi[ 'MuN' ]
+ arg2 = loi[ 'SigmaN' ]
+ arg3 = loi[ 'A' ]
+ arg4 = loi[ 'B' ]
+ txt = "TruncatedNormal( %g, %g, %g, %g )" % (arg1, arg2, arg3, arg4)
+ return txt
+
+ def Poisson (self, loi):
+ '''
+ Definition de la loi Poisson
+ '''
+ txt = "Poisson( %g )" % loi[ 'Lambda' ]
+ return txt
+
+ def Rayleigh (self, loi):
+ '''
+ Definition de la loi Rayleigh
+ '''
+ arg1 = loi[ 'Sigma' ]
+ arg2 = loi[ 'Gamma' ]
+ txt = "Rayleigh( %g, %g )" % (arg1, arg2)
+ return txt
+
+ def Student (self, loi):
+ '''
+ Definition de la loi Student
+ '''
+ arg1 = loi[ 'Mu' ]
+ arg2 = loi[ 'Nu' ]
+ arg3 = loi[ 'Sigma' ]
+ txt = "Student( %g, %g, %g )" % (arg1, arg2, arg3)
+ return txt
+
+ def Triangular (self, loi):
+ '''
+ Definition de la loi Triangular
+ '''
+ arg1 = loi[ 'A' ]
+ arg2 = loi[ 'M' ]
+ arg3 = loi[ 'B' ]
+ txt = "Triangular( %g, %g, %g )" % (arg1, arg2, arg3)
+ return txt
+
+ def Uniform (self, loi):
+ '''
+ Definition de la loi Uniform
+ '''
+ arg1 = loi[ 'A' ]
+ arg2 = loi[ 'B' ]
+ txt = "Uniform( %g, %g )" % (arg1, arg2)
+ return txt
+
+ def UserDefined (self, loi):
+ '''
+ Definition de la loi UserDefined
+ '''
+ txt = "** UserDefined not defined yet **"
+ return txt
+
+ def Weibull (self, loi):
+ '''
+ Definition de la loi Weibull
+ '''
+ settings = {
+ "AlphaBeta" : "Weibull.ALPHABETA",
+ "MuSigma" : "Weibull.MUSIGMA",
+ }
+ if loi[ 'Settings' ] == 'AlphaBeta' :
+ arg1 = loi[ 'Alpha' ]
+ arg2 = loi[ 'Beta' ]
+ else :
+ arg1 = loi[ 'Mu' ]
+ arg2 = loi[ 'Sigma' ]
+
+ arg3 = loi[ 'Gamma' ]
+ txt = "Weibull( %g, %g, %g, %s )" % (arg1, arg2, arg3, settings[ loi[ 'Settings' ] ])
+ return txt
+
+
+
+ def GraphiquePDF (self, loi, chemin, fichier):
+ '''
+ Produit une image PNG representant la PDF de la loi
+ '''
+ txt = headerSTD % self.OpenTURNS_path
+ txt += "dist = %s\n" % apply( STDGenerateur.__dict__[ loi[ 'Kind' ] ], (self, loi) )
+ txt += "graph = dist.drawPDF()\n"
+ txt += "graph.draw( '%s/%s' , 640, 480, GraphImplementation.PNG)\n" % (chemin, fichier)
+ txt += footerSTD
+ return txt
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+Ce module contient le generateur XML pour Openturns
+"""
+import sys
+print sys.path
+from Accas.extensions.eficas_translation import tr
+import openturns
+
+# Dictionnaires de conversion des valeurs lues dans EFICAS
+# en valeurs reconnues par Open TURNS
+# Les clefs 'None' sont les valeurs par defaut
+
+VariableTypeByName = {
+ "in" : openturns.WrapperDataVariableType.IN,
+ "out" : openturns.WrapperDataVariableType.OUT,
+ None : openturns.WrapperDataVariableType.IN,
+ }
+
+FileTypeByName = {
+ "in" : openturns.WrapperDataFileType.IN,
+ "out" : openturns.WrapperDataFileType.OUT,
+ None : openturns.WrapperDataFileType.IN,
+ }
+
+SymbolProvidedByName = {
+ "no" : openturns.WrapperSymbolProvided.NO,
+ "yes" : openturns.WrapperSymbolProvided.YES,
+ None : openturns.WrapperSymbolProvided.NO,
+ }
+
+WrapperStateByName = {
+ "shared" : openturns.WrapperState.SHARED,
+ "specific" : openturns.WrapperState.SPECIFIC,
+ None : openturns.WrapperState.SPECIFIC,
+ }
+
+WrapperModeByName = {
+ "static-link" : openturns.WrapperMode.STATICLINK,
+ "dynamic-link" : openturns.WrapperMode.DYNAMICLINK,
+ "fork" : openturns.WrapperMode.FORK,
+ None : openturns.WrapperMode.FORK,
+ }
+
+WrapperDataTransferByName = {
+ "files" : openturns.WrapperDataTransfer.FILES,
+ "pipe" : openturns.WrapperDataTransfer.PIPE,
+ "arguments" : openturns.WrapperDataTransfer.ARGUMENTS,
+ "socket" : openturns.WrapperDataTransfer.SOCKET,
+ "corba" : openturns.WrapperDataTransfer.CORBA,
+ None : openturns.WrapperDataTransfer.FILES,
+ }
+
+#==========================
+# La classe de creation XML
+#==========================
+
+class XMLGenerateur :
+
+ '''
+ Generation du fichier XML
+ '''
+ def __init__ (self, appli, DictMCVal, DictVariables ) :
+ self.DictMCVal = DictMCVal
+ self.DictVariables = DictVariables
+ self.appli = appli
+
+ def CreeXML (self) :
+ '''
+ Pilotage general de la creation du fichier XML
+ '''
+ data = openturns.WrapperData()
+ data.setLibraryPath( self.GetMCVal('WrapperPath','') )
+ data.setVariableList( self.VariableList() )
+ data.setFunctionDescription( self.FunctionDefinition() )
+ data.setGradientDescription( self.GradientDefinition() )
+ data.setHessianDescription( self.HessianDefinition() )
+ data.setFileList( self.FileList() )
+ data.setParameters( self.Parameters() )
+ #data.setFrameworkData( self.FrameworkData() )
+
+ wrapper=openturns.WrapperFile()
+ wrapper.setWrapperData( data )
+
+ return wrapper
+
+
+ class __variable_ordering:
+ def __init__ (self, dictVar) :
+ self.dictVar = dictVar
+
+ def __call__(self, a, b):
+ return self.dictVar[a]['numOrdre'] - self.dictVar[b]['numOrdre']
+
+ def VariableList (self) :
+ '''
+ Ecrit la liste des variables
+ '''
+ varList = openturns.WrapperDataVariableCollection()
+ for var in sorted( self.DictVariables.keys(), self.__variable_ordering( self.DictVariables ) ) :
+ varList.add( self.Variable( var, self.DictVariables[var] ) )
+ return varList
+
+ def Variable (self, var, dictVar) :
+ '''
+ Ecrit le parametrage d une variable
+ '''
+ variable = openturns.WrapperDataVariable()
+ variable.id_ = var
+ if dictVar[ 'Type' ] in VariableTypeByName.keys() :
+ variable.type_ = VariableTypeByName[ dictVar[ 'Type' ] ]
+ if dictVar.has_key('Comment') : variable.comment_ = dictVar[ 'Comment' ]
+ if dictVar.has_key('Unit') : variable.unit_ = dictVar[ 'Unit' ]
+ if dictVar.has_key('Regexp') : variable.regexp_ = dictVar[ 'Regexp' ]
+ if dictVar.has_key('Format') : variable.format_ = dictVar[ 'Format' ]
+ return variable
+
+ def FunctionDefinition (self) :
+ '''
+ Ecrit la description de la Fonction
+ '''
+ func = openturns.WrapperFunctionDescription()
+ func.name_ = self.GetMCVal( 'FunctionName', '' )
+ if (len(func.name_) != 0) : func.provided_ = SymbolProvidedByName[ 'yes' ]
+ return func
+
+ def GradientDefinition (self) :
+ '''
+ Ecrit la description du Gradient
+ '''
+ grad = openturns.WrapperFunctionDescription()
+ grad.name_ = self.GetMCVal( 'GradientName', '' )
+ if (len(grad.name_) != 0) : grad.provided_ = SymbolProvidedByName[ 'yes' ]
+ return grad
+
+ def HessianDefinition (self) :
+ '''
+ Ecrit la description de la Hessienne
+ '''
+ hess = openturns.WrapperFunctionDescription()
+ hess.name_ = self.GetMCVal( 'HessianName', '' )
+ if (len(hess.name_) != 0) : hess.provided_ = SymbolProvidedByName[ 'yes' ]
+ return hess
+
+
+
+ def FileList (self) :
+ '''
+ Ecrit la liste des fichiers
+ '''
+ fileList = openturns.WrapperDataFileCollection()
+ for dictFile in self.GetMCVal('Files', []) :
+ fileList.add( self.File( dictFile ) )
+ return fileList
+
+ def File (self, dictFile ) :
+ '''
+ Ecrit le parametrage d un fichier
+ '''
+ fich = openturns.WrapperDataFile()
+ fich.id_ = dictFile[ 'Id' ]
+ if dictFile[ 'Type' ] in FileTypeByName.keys() :
+ fich.type_ = FileTypeByName[ dictFile[ 'Type' ] ]
+ if dictFile.has_key('Name') : fich.name_ = dictFile[ 'Name' ]
+ if dictFile.has_key('Path') : fich.path_ = dictFile[ 'Path' ]
+ if dictFile.has_key('Subst') :
+ import string
+ fich.subst_ = string.join( dictFile[ 'Subst' ], ',' )
+ return fich
+
+ def Parameters (self) :
+ '''
+ Ecrit les parametres de couplage au code externe
+ '''
+ parameters = openturns.WrapperParameter()
+ parameters.mode_ = WrapperModeByName[ self.GetMCVal('WrapCouplingMode') ]
+ if (parameters.mode_ == openturns.WrapperMode.FORK ):
+ parameters.command_ = self.GetMCVal('Command')
+ userPrefix = self.GetMCVal('UserPrefix', None)
+ if userPrefix != None : parameters.userPrefix_ = userPrefix
+ parameters.state_ = WrapperStateByName[ self.GetMCVal('State') ]
+ parameters.in_ = WrapperDataTransferByName[ self.GetMCVal('InDataTransfer') ]
+ parameters.out_ = WrapperDataTransferByName[ self.GetMCVal('OutDataTransfer') ]
+ return parameters
+
+ def FrameworkData (self) :
+ '''
+ Ecrit les donnees liees a l utilisation d un framework englobant
+ '''
+ framework = openturns.WrapperFrameworkData()
+# framework.studycase_ = "12:23:34"
+# framework.componentname_ = self.GetMCVal('SolverComponentName', 'UNDEFINED')
+ CN = self.GetMCVal('SolverComponentName', 'UNDEFINED')
+ print 'CN = %s', CN
+ framework.componentname_ = CN
+ return framework
+
+
+ # ---------------------------------------------------------------------------------
+
+
+ def GetTag (self, tag) :
+ '''
+ Recupere la chaine associee au tag dans la table dictTagsXML.
+ Leve une exception si le tag n est pas trouve
+ '''
+ if ( dictTagsXML.has_key(tag) ) :
+ return dictTagsXML[tag]
+ else :
+ raise KeyError, tr("Tag %s non-defini. Ceci est un bogue interne. en informer les developpeurs.", tag)
+ pass
+
+ def GetMCVal (self, MC, default = None, mandatory = False) :
+ '''
+ Recupere la chaine associee au MC dans la table DictMCVal.
+ Leve une exception si le MC n est pas trouve et mandatory vaut True
+ '''
+ if ( self.DictMCVal.has_key(MC) and self.DictMCVal[MC] != None ) :
+ return self.DictMCVal[MC]
+ else :
+ if ( mandatory ) :
+ raise KeyError, tr(" Le mot-cle %s est obligatoire.", MC)
+ else :
+ return default
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+import traceback
+import types,string,re,os
+from Accas.extensions.eficas_translation import tr
+from generator_python import PythonGenerator
+
+# Groupes de mailles dont les types sont definis par des prefixes dans leur nom
+usePrefix = False # les noms ont des prefixes (True) ou non (False)
+# liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom
+# Ce prefixe (et caractere _) doivent etre supprimes dans le fichier .phys
+listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",
+ "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",
+ "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",
+ "PORT_OMEGA","POST_PHI","PB_GRID",
+ "SCUTE","SCUTN","ZS","ZJ","ZT")
+# liste des prefixes des groupes de mailles, sans le separateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire
+dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'),
+ 'CONDUCTOR':('COND',),
+ 'STRANDED_INDUCTOR':('CURRENT', ),
+ 'EPORT':('EPORT', ),
+ 'HPORT':('HPORT', ),
+ 'ZSURFACIC':('ZS', ),
+ 'ZINSULATOR':('ZJ', ),
+ 'NILMAT':('NILMAT', )}
+# separateur entre le prefixe et le reste du nom du groupe de maille
+sepNomGroupeMaille = '_'
+
+# types de problemes
+HARMONIC = 'HARMONIC' # probleme frequentiel
+TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'CARMEL3D',
+ # La factory pour creer une instance du plugin
+ 'factory' : CARMEL3DGenerator,
+ }
+
+
+class CARMEL3DGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+#----------------------------------------------------------------------------------------
+ def gener(self,obj,format='brut',config=None):
+
+ self.initDico()
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+
+ if self.debug:
+ print "self.text = %s", self.text
+
+ # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
+ # si le jdc est valide (sinon cela n a pas de sens)
+ if obj.isValid() :
+ # constitution du bloc VERSION du fichier PHYS (existe toujours)
+ try :
+ self.generBLOC_VERSION(obj)
+ except ValueError, err:
+ raise ValueError(str(err))
+
+ # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
+ self.generBLOC_MATERIALS()
+
+ # constitution du bloc SOURCES du fichier PHYS (existe toujours)
+ self.generBLOC_SOURCES()
+
+# print "texte carmel3d :\n",self.texteCarmel3D
+# print "dictMaterDielectric : ",self.dictMaterDielectric
+ if self.debug:
+ print "dictMaterConductor : %s", repr(self.dictMaterConductor)
+
+ return self.text
+
+
+#----------------------------------------------------------------------------------------
+# initialisations
+#----------------------------------------------------------------------------------------
+
+ def initDico(self) :
+
+ self.texteCarmel3D=""
+ self.debug = True # affichage de messages pour deboguage (.true.) ou non
+ self.dicoEtapeCourant=None
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=None
+ self.dictGroupesMaillage = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[]} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
+ self.dictMaterConductor={}
+ self.dictMaterDielectric={}
+ self.dictMaterZsurfacic={}
+ self.dictMaterEmIso={}
+ self.dictMaterEmAnIso={}
+ self.dictMaterNilmat={}
+ self.dictMaterZinsulator={}
+ self.dictSourceStInd={}
+ self.dictSourceEport={}
+ self.dictSourceHport={}
+ # on force le probleme a etre frequentiel, seul possible en l'etat des choses
+ self.problem = HARMONIC
+
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def writeDefault(self,fn) :
+ """Ecrit le fichier de parametres (PHYS) pour le code Carmel3D"""
+ if self.debug:
+ print "ecriture du fichier de parametres (PHYS)"
+ filePHYS = fn[:fn.rfind(".")] + '.phys'
+ f = open( str(filePHYS), 'wb')
+ f.write( self.texteCarmel3D)
+ f.close()
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ if self.debug:
+ print "MCSIMP %(v_1)s %(v_2)s", {'v_1': obj.nom, "v_2": obj.valeur}
+ s=PythonGenerator.generMCSIMP(self,obj)
+ self.dicoCourant[obj.nom]=obj.valeurFormatee
+ return s
+
+
+#----------------------------------------------------------------------------------------
+ def generMCFACT(self,obj) :
+ """recuperation de l objet MCFACT"""
+ dico={}
+ self.dicoMCFACTCourant=dico
+ self.dicoCourant=self.dicoMCFACTCourant
+ s=PythonGenerator.generMCFACT(self,obj)
+ self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=self.dicoEtapeCourant
+ return s
+
+#----------------------------------------------------------------------------------------
+ def generPROC_ETAPE(self,obj):
+ """analyse des PROC du catalogue ( VERSION )"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant
+ if self.debug:
+ print "PROC_ETAPE %(v_1)s %(v_2)s", \
+ {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+ def generETAPE(self,obj):
+ """analyse des OPER du catalogue"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant
+ if self.debug:
+ print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s", \
+ {'v_1': obj.nom, 'v_2': obj.valeur}
+ if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
+ if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
+ if obj.nom=="SOURCE" : self.generSOURCE(obj)
+ s=PythonGenerator.generETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+ def generMACRO_ETAPE(self,obj):
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ import generator
+ monGenerateur=generator.plugins["CARMEL3D"]()
+ jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
+ if self.debug:
+ print "jdc_aux_texte : %s", jdc_aux_texte
+
+ for cle in monGenerateur.dictMaterConductor:
+ self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
+ for cle in monGenerateur.dictMaterDielectric:
+ self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
+ for cle in monGenerateur.dictMaterZsurfacic:
+ self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
+ for cle in monGenerateur.dictMaterEmIso:
+ self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
+ for cle in monGenerateur.dictMaterEmAnIso:
+ self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
+ for cle in monGenerateur.dictMaterNilmat:
+ self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
+ for cle in monGenerateur.dictMaterZinsulator:
+ self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
+
+ print "________FIN MACRO______________________________________"
+ s=PythonGenerator.generMACRO_ETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+#----------------------------------------------------------------------------------------
+ def generMESHGROUP(self,obj):
+ """preparation de la ligne NAME referencant le groupe de mailles
+ associe le groupe de mailles au materiau ou a la source utilisateur
+ on sauvegarde aussi les noms des groupes de maillage
+ """
+
+ try:
+ if usePrefix:
+ nomGroupeMaillage = self.nomReelGroupeMaillage(obj.getSdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
+ else:
+ nomGroupeMaillage = obj.getSdname() # nom du groupe de maillage, i.e. nom du concept
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupeMaillage
+ #
+ # on utilise le fait que obj.valeur est un dictionnaire
+ if self.debug:
+ print "obj.valeur.keys()= %s", obj.valeur.keys()
+ if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source.", nomGroupeMaillage)
+ # association a un materiau
+ if 'MATERIAL' in obj.valeur.keys():
+ self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupesMaillage['ordreMateriauxJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
+ # association a une source
+ elif 'SOURCE' in obj.valeur.keys():
+ self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupesMaillage['ordreSourcesJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ else:
+ raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau ou source.", nomGroupeMaillage)
+ if self.debug:
+ print "self.dictGroupesMaillage= %s", repr(self.dictGroupesMaillage)
+ except:
+ pass
+
+
+ def generMATERIAL(self,obj):
+ """preparation du bloc correspondant a un materiau du fichier PHYS"""
+ texte=""
+ if self.debug:
+ print "generation material obj valeur = %s", obj.valeur
+ try :
+ nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
+ if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
+ if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
+ if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
+ if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
+ if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
+ if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
+ if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
+ except:
+ pass
+
+ def generMATERIAL_CONDUCTOR(self,obj):
+ """preparation du sous bloc CONDUCTOR"""
+ texte=""
+ if self.debug:
+ print "_____________cond_____________"
+ # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
+ if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
+ print "ERREUR! Le bloc CONDUCTOR doit contenir PERMEABILITY et CONDUCTIVITY."
+ else:
+ # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
+ for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
+ # seuls les reels sont pris en compte
+ if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
+ texte+=" [NONLINEAR \n"
+ texte+=" ISOTROPY TRUE\n"
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
+ # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
+ for keyN2 in obj.valeur[keyN1] :
+ if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
+ # fin du sous-bloc NONLINEAR
+ texte+=" ]"+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s", texte
+ self.dictMaterConductor[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
+
+ def generMATERIAL_DIELECTRIC(self,obj):
+ """preparation du sous bloc DIELECTRIC"""
+ texte=""
+ if self.debug:
+ print "______________nocond_____________"
+ # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
+ if 'PERMEABILITY' not in obj.valeur or 'PERMITTIVITY' not in obj.valeur:
+ print "ERREUR! Le bloc DIELECTRIC doit contenir PERMEABILITY et PERMITTIVITY."
+ else:
+ # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
+ for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
+ # seuls les reels sont pris en compte
+ if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
+ texte+=" [NONLINEAR \n"
+ texte+=" ISOTROPY TRUE\n"
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
+ # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
+ for keyN2 in obj.valeur[keyN1] :
+ if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
+ # fin du sous-bloc NONLINEAR
+ texte+=" ]"+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s", texte
+ self.dictMaterDielectric[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
+
+ def generMATERIAL_ZSURFACIC(self,obj):
+ """preparation du sous bloc ZSURFACIC"""
+ texte=""
+ if self.debug:
+ print "______________zsurf_____________"
+ # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
+ if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
+ print "ERREUR! Le bloc ZSURFACIC doit contenir PERMEABILITY et CONDUCTIVITY."
+ else:
+ # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
+ for keyN1 in obj.valeur :
+ if keyN1=='TYPE': continue
+ # print "type loi = ", obj.valeur[keyN1]['LAW']
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s", texte
+ self.dictMaterZsurfacic[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
+
+ def generMATERIAL_EMISO(self,obj):
+ """preparation du sous bloc EM_ISOTROPIC_FILES.
+ Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
+ ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
+ """
+ texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
+ texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
+ # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
+ #from os.path import basename
+ #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
+ #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
+ # print "obj get sdname= ", obj.getSdname()
+ # if obj.getSdname() in self.dictMaterEmIso.keys() :
+ # self.dictMaterEmIso[obj.getSdname()].append(texte)
+ # else :
+ self.dictMaterEmIso[obj.getSdname()]=texte
+
+ def generMATERIAL_EMANISO(self,obj):
+ """preparation du sous bloc EM_ANISOTROPIC_FILES.
+ Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
+ ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
+ """
+ texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
+ texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
+ # print "obj get sdname= ", obj.getSdname()
+ # if obj.getSdname() in self.dictMaterEmAnIso.keys() :
+ # self.dictMaterEmAnIso[obj.getSdname()].append(texte)
+ # else :
+ self.dictMaterEmAnIso[obj.getSdname()]=texte
+
+ def generMATERIAL_NILMAT(self,obj):
+ """preparation du sous bloc NILMAT"""
+ texte=""
+ self.dictMaterNilmat[obj.getSdname()]=texte
+
+ def generMATERIAL_ZINSULATOR(self,obj):
+ """"preparation du sous bloc ZINSULATOR"""
+ texte=""
+ self.dictMaterZinsulator[obj.getSdname()]=texte
+
+#-------------------------------------------------------------------
+
+ def generSOURCE(self,obj):
+ """preparation du bloc correspondant a une source du fichier PHYS"""
+ if self.debug:
+ print "generation source obj valeur = %s", obj.valeur
+ texte=""
+ try :
+ # test de la presence des types de sources reconnus
+ # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "STRANDED_INDUCTOR" in obj.valeur:
+ self.generSOURCE_STRANDED_INDUCTOR(obj)
+ elif "HPORT" in obj.valeur:
+ self.generSOURCE_HPORT(obj)
+ elif "EPORT" in obj.valeur:
+ self.generSOURCE_EPORT(obj)
+ else:
+ print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
+ except:
+ pass
+
+ def generSOURCE_STRANDED_INDUCTOR(self,obj):
+ """preparation du sous bloc STRANDED_INDUCTOR"""
+ texte=""
+ sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ try :
+ texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ print tr("ATTENTION! Une source constante \
+ n'est possible qu'a frequence nulle \
+ en regime frequentiel")
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ else:
+ print tr("ERREUR! Une forme de la source du \
+ type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
+ self.dictSourceStInd[obj.getSdname()]=texte
+ if self.debug:
+ print texte
+ except Exception:
+ pass
+
+ def generSOURCE_HPORT(self,obj):
+ """preparation du sous bloc HPORT"""
+ texte=""
+ sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ try :
+ texte+=" TYPE %s\n" % str(sdict['TYPE'])
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ print tr("ATTENTION! Une source constante n'est \
+ possible qu'a frequence nulle en regime frequentiel")
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ else:
+ print tr("ERREUR! Une forme de la source du type \
+ WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
+ self.dictSourceHport[obj.getSdname()]=texte
+ if self.debug:
+ print texte
+ except:
+ pass
+
+ def generSOURCE_EPORT(self,obj):
+ """preparation du sous bloc EPORT"""
+ texte=""
+ sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ try :
+ texte+=" TYPE %s\n" % str(sdict['TYPE'])
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ else:
+ print tr("ERREUR! Une forme de la source du type \
+ WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
+ self.dictSourceEport[obj.getSdname()]=texte
+ if self.debug:
+ print texte
+ except:
+ pass
+
+#---------------------------------------------------------------------------------------
+# traitement fichier PHYS
+#---------------------------------------------------------------------------------------
+
+ def generBLOC_VERSION(self,obj) :
+ # constitution du bloc VERSION du fichier PHYS
+ # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
+ # dans le du catalogue
+ version=obj.addEntite('VERSION',pos=None)
+ self.generPROC_ETAPE(obj.etapes[0])
+ self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
+ for cle in obj.etapes[0].valeur :
+ self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
+ self.texteCarmel3D+="]\n"
+ # destruction de l entite creee
+ obj.suppEntite(version)
+
+#----------------------------------------------------------------------------------------
+ def generBLOC_MATERIALS(self) :
+ """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
+ Le bloc MATERIALS existe toujours !
+ """
+ if self.debug:
+ print "cle dictionnaire materconductor : %s", self.dictMaterConductor.keys()
+ print "cle dictionnaire materdielectric : %s", self.dictMaterDielectric.keys()
+ # constitution du bloc MATERIALS du fichier PHYS
+ self.texteCarmel3D+="[MATERIALS\n"
+ # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
+ nomsGroupesMaillage = self.dictGroupesMaillage['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
+ nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels
+ if self.debug:
+ print "noms groupes de mailles associes a des materiaux \
+ (ordre JdC puis tri)= %(v_1)s %(v_2)s", \
+ {'v_1': self.dictGroupesMaillage['ordreMateriauxJdC'], \
+ 'v_2': nomsGroupesMaillage}
+ # constitution du bloc CONDUCTOR du fichier PHYS si existe
+ if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupesMaillage)
+ # constitution du bloc DIELECTRIC du fichier PHYS si exixte
+ if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupesMaillage)
+ # constitution du bloc ZSURFACIC du fichier PHYS si exixte
+ if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupesMaillage)
+ # constitution du bloc NILMAT du fichier PHYS si exixte
+ if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupesMaillage)
+ # constitution du bloc ZINSULATOR du fichier PHYS si exixte
+ if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupesMaillage)
+ # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
+ # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
+ if self.dictMaterEmIso != {} : self.creaBLOC_EMISO()
+ # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
+ if self.dictMaterEmAnIso != {} : self.creaBLOC_EMANISO()
+ # fin du bloc MATERIALS du fichier PHYS
+ self.texteCarmel3D+="]\n"
+
+ def creaBLOC_CONDUCTOR(self, nomsGroupesMaillage) :
+ """Constitution du bloc CONDUCTOR du fichier PHYS"""
+ typeBloc = 'CONDUCTOR' # initialisation du type de bloc
+ dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s', \
+ {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_DIELECTRIC(self, nomsGroupesMaillage) :
+ """Constitution du bloc DIELECTRIC du fichier PHYS"""
+ typeBloc = 'DIELECTRIC' # initialisation du type de bloc
+ dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s', \
+ {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_ZSURFACIC(self, nomsGroupesMaillage) :
+ """Constitution du bloc ZSURFACIC du fichier PHYS"""
+ typeBloc = 'ZSURFACIC' # initialisation du type de bloc
+ dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s', \
+ {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_EMISO(self) :
+ """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
+ for cle in self.dictMaterEmIso.keys():
+ self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
+ self.texteCarmel3D+= self.dictMaterEmIso[cle]
+ self.texteCarmel3D+=" ]\n"
+
+ def creaBLOC_EMANISO(self) :
+ """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
+ for cle in self.dictMaterEmAnIso.keys():
+ self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
+ self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
+ self.texteCarmel3D+=" ]\n"
+
+ def creaBLOC_ZINSULATOR(self, nomsGroupesMaillage) :
+ """Constitution du bloc ZINSULATOR du fichier PHYS"""
+ typeBloc = 'ZINSULATOR' # initialisation du type de bloc
+ dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
+ if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_NILMAT(self, nomsGroupesMaillage) :
+ """Constitution du bloc NILMAT du fichier PHYS"""
+ typeBloc = 'NILMAT' # initialisation du type de bloc
+ dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s', \
+ {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+#----------------------------------------------------------------------------------------
+ def generBLOC_SOURCES(self):
+ """constitution du bloc SOURCES du fichier PHYS"""
+ self.texteCarmel3D+="[SOURCES\n"
+ # tri alphabetique de tous les groupes de maillage associes a des sources
+ nomsGroupesMaillage = self.dictGroupesMaillage['ordreSourcesJdC'][:] # copie de l'original, qui est une liste
+ nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels
+ if self.debug:
+ print 'noms groupes de mailles associes a des sources \
+ (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s', \
+ {'g_maillage_orig': self.dictGroupesMaillage['ordreSourcesJdC'], \
+ 'g_maillage_trie': nomsGroupesMaillage}
+ if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupesMaillage)
+ if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupesMaillage)
+ if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupesMaillage)
+ # fin du bloc SOURCES du fichier PHYS
+ self.texteCarmel3D+="]\n"
+
+
+ def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupesMaillage) :
+ """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
+ if self.debug:
+ print 'cles sources STRANDED_INDUCTOR= %s', self.dictSourceStInd.keys()
+ typeBloc = 'STRANDED_INDUCTOR'
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
+ if self.dictGroupesMaillage[nom] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
+ # ecriture du bloc de l'inducteur bobine
+ self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupesMaillage[nom]] # ecriture des proprietes de l'inducteur bobine
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_EPORT(self, nomsGroupesMaillage) :
+ """constitution du bloc EPORT du fichier PHYS"""
+ if self.debug:
+ print 'cles sources EPORT= %s', self.dictSourceEport.keys()
+ typeBloc = 'EPORT'
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
+ if self.dictGroupesMaillage[nom] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
+ # ecriture du bloc du port electrique
+ self.texteCarmel3D+=" [EPORT\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceEport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port electrique
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_HPORT(self, nomsGroupesMaillage) :
+ """constitution du bloc HPORT du fichier PHYS"""
+ if self.debug:
+ print 'cles sources HPORT= %s', self.dictSourceHport.keys()
+ typeBloc = 'HPORT'
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
+ if self.dictGroupesMaillage[nom] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
+ # ecriture du bloc du port magnetique
+ self.texteCarmel3D+=" [HPORT\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceHport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port magnetique
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+#-------------------------------------
+# Methodes utilitaires
+# ------------------------------------
+ def formateCOMPLEX(self,nbC):
+ """prise en compte des differentes formes de description d un nombre complexe
+ 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
+ """
+ if self.debug:
+ print "formatage "
+ print "type : %(type_nb_c)s pour %(nb_c)s", \
+ {'type_nb_c': type(nbC), 'nb_c': nbC}
+ nbformate =""
+ if isinstance(nbC,(tuple,list)):
+ if nbC[0] == "'RI'" :
+ nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
+ if nbC[0] == "'MP'" :
+ nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
+ else:
+ nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
+ if self.debug:
+ print "nbformate : %s", nbformate
+ return nbformate
+
+ def nomReelGroupeMaillage(self, nom, typeBloc=None):
+ """Calcule et retourne le nom reel du groupe de maillage donne en entree,
+ en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
+ de bloc du fichier PHYS specifie.
+ Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
+ """
+ from string import join
+ if self.debug:
+ print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
+ {'nom': nom, 'use_prefix': str(usePrefix)}
+ nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
+ if usePrefix:
+ # suppression du prefixe si present
+ partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
+ # les tests suivants ne generent une erreur que si le prefixe est obligatoire
+ if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
+ print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
+ indiquant le type de materiau ou de source associee", nom)
+ elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
+ print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable", nom)
+ else:
+ # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
+ if typeBloc is not None:
+ if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
+ print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))
+ elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
+ print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \
+ le prefixe correct pour etre associe a un type %(type_bloc)s", \
+ {'nom': nom, 'type_bloc': str(typeBloc)})
+ else: # c'est bon
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
+ if self.debug:
+ print "ce groupe de maille (%(nom)s) a un prefixe qui \
+ est supprime automatiquement pour devenir : %(nom_reel)s", \
+ {'nom': nom, 'nom_reel': nomReel}
+ else: # c'est bon
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
+ if self.debug:
+ print "ce groupe de maille (%(nom)s) a un prefixe qui \
+ est supprime automatiquement pour devenir : %(nom_reel)s", \
+ {'nom': nom, 'nom_reel': nomReel}
+ if self.debug:
+ print "... %s", nomReel
+ return nomReel
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+import xml.etree.cElementTree as ET
+import traceback
+import types,string,re,os
+from Accas.extensions.eficas_translation import tr
+from generator_python import PythonGenerator
+
+# types de problemes
+HARMONIC = 'HARMONIC' # probleme frequentiel
+TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
+
+# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
+nomPlugin = 'CARMEL3DTV0'
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : nomPlugin,
+ # La factory pour creer une instance du plugin
+ 'factory' : CARMEL3DTV0Generator,
+ }
+
+
+
+class CARMEL3DTV0Generator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+#----------------------------------------------------------------------------------------
+ def gener(self,obj,format='brut',config=None):
+
+ self.initDico()
+
+ #self.debug = True
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+
+ if self.debug:
+ print "self.text = %s" % self.text
+
+ # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
+ # si le jdc est valide (sinon cela n a pas de sens)
+ if obj.isValid() :
+ try :
+ # constitution du bloc VERSION du fichier PHYS (existe toujours)
+ self.generBLOC_VERSION(obj)
+
+ except ValueError, err:
+ raise ValueError(str(err))
+
+ return self.text
+
+
+
+
+#----------------------------------------------------------------------------------------
+# initialisations
+#----------------------------------------------------------------------------------------
+
+ def initDico(self) :
+ self.texteCarmel3D=""
+ self.texteCarmel3D_SH=""
+ self.debug = True # affichage de messages pour deboguage (.true.) ou non
+ self.dicoEtapeCourant=None
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=None
+ self.dictGroupes = {} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
+ self.dictMacroGroupes = {} # macro-groupe et leurs propriétés
+ self.listSymetrie=[]
+ self.dictMouvement= {'ordre':[]} # dictionnaire contenant les mouvements, avec liste incluse pour l'ordre
+ self.nombreMouvements = 0 # nombre de mouvements définis, servant de compteur aussi
+ self.dictMaterial={}
+ self.dictSource={}
+ self.dictStrand={}
+ self.dictGroupeMilieux={"ordreSource":[], "ordreId":[]}
+ self.dictDomaine={}
+ # Parametre du maillage
+ self.identification = ""
+ self.fichierMaillage = ""
+ self.echelleMaillage = ""
+ # Parametre de Precision
+ self.precond=""
+ self.precisionLineaire=""
+ self.kEpsilonDistance=""
+ self.kdistanceRef=""
+ self.nbIterationMax=""
+ self.methodeNonLineaire = ""
+ self.kEpsilonNonLinearite=""
+ self.kCoefficientRelaxation=""
+ self.jauge=""
+ self.NBoucleTemps=""
+ self.dt=""
+ # Paramètres divers
+ self.typeSolveur = "" # type de solveur, linéaire (Solveur_lineaire) ou non-linéaire (Solveur_non_lineaire)
+ #Post traitement
+ self.carteChamp="" # liste des pas de temps demandés lors du post-traitement des cartes de champ
+ self.carteCourantInduit="" # liste des pas de temps demandés lors du post-traitement des cartes de courants induits
+ self.carteForce="" # liste des pas de temps demandés lors du post-traitement des cartes de force
+ self.post_global = [] # liste des grandeurs globales demandées lors du post-traitement
+
+ # on force le probleme a etre frequentiel, seul possible en l'etat des choses
+ self.problem = HARMONIC
+
+ def indent(self, elem, level=0, more_sibs=False, espace=4*' '):
+ """Transformation du XML créé par le module interne xml.etree.ElementTree afin d'écrire les indentations et retours à la ligne corrects.
+ D'après un script original de Fredrik Lundh en 2004 (http://effbot.org/zone/element-lib.htm#prettyprint),
+ modifié par Joshua Richardson en 2012 (http://stackoverflow.com/questions/749796/pretty-printing-xml-in-python)
+ et par Loic Chevallier en 2014 (ajout du reglage de l'indentation).
+ L'indentation est de 4 espaces par défaut (cf. argument optionel : espace)
+ Utilisation : self.indent(root), avant écriture dans un fichier de root = ET.Element("configuration") ou de tree = ET.ElementTree(root)
+ où ET = xml.etree.ElementTree
+ """
+ i = "\n"
+ if level:
+ i += (level-1) * espace
+ num_kids = len(elem)
+ if num_kids:
+ if not elem.text or not elem.text.strip():
+ elem.text = i + espace
+ if level:
+ elem.text += espace
+ count = 0
+ for kid in elem:
+ self.indent(kid, level+1, count < num_kids - 1)
+ count += 1
+ if not elem.tail or not elem.tail.strip():
+ elem.tail = i
+ if more_sibs:
+ elem.tail += espace
+ else:
+ if level and (not elem.tail or not elem.tail.strip()):
+ elem.tail = i
+ if more_sibs:
+ elem.tail += espace
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def writeDefault(self,fn) :
+ """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
+
+ file = fn[:fn.rfind(".")] # emplacement du ficher .comm (chemin complet)
+ namefile=os.path.basename(file) # nom du fichier.comm
+ repertory=os.path.dirname(file) # répertoire contenant le fichier .comm (emplacement absolu)
+
+ # correspondances globales
+ correspondance_booleen = {'oui':'true', 'non':'false'}
+
+ fileXML = os.path.join(repertory, 'configuration.xml') # nom du fichier de configuration XML (chemin complet)
+ if self.debug:
+ print "\necriture du fichier XML : ", fileXML
+ print "self.dictMaterial = ",self.dictMaterial
+ print "self.dictSource = ",self.dictSource
+ print "self.dictGroupes = ",self.dictGroupes
+ print "self.dictMacroGroupes = ",self.dictMacroGroupes
+
+ root = ET.Element("configuration")
+
+ #Bloc <Maillage></Maillage>
+ Maillage = ET.SubElement(root, "Maillage")
+ identification = ET.SubElement(Maillage, "identification")
+ identification.text = self.identification
+ fichierMaillage = ET.SubElement(Maillage, "fichierMaillage")
+ fichierMaillage.text = self.fichierMaillage
+ echelleMaillage = ET.SubElement(Maillage, "echelleMaillage")
+ correspondance_echelleMaillage = {"Metre":1.0, "Millimetre":1.0e-3}
+ echelleMaillage.text = "%f" % (correspondance_echelleMaillage[self.echelleMaillage], )
+
+ #Bloc <ParametrePrecision></ParametrePrecision>
+ ParametrePrecision = ET.SubElement(root, "ParametrePrecision")
+ TypeSolveurLineaire = ET.SubElement(ParametrePrecision, "TypeSolveurLineaire")
+ if self.precond=="Crout":
+ TypeSolveurLineaire.text = "1"
+ if self.precond=="Jacobi":
+ TypeSolveurLineaire.text = "2"
+ if self.precond=="MUMPS":
+ TypeSolveurLineaire.text = "3"
+ kEpsilonGCP = ET.SubElement(ParametrePrecision, "kEpsilonGCP")
+ kEpsilonGCP.text = "%s" %(self.kEpsilonGCP)
+ nbIterationMax = ET.SubElement(ParametrePrecision, "nbIterationMax")
+ nbIterationMax.text = "%s" %(self.nbIterationMax)
+ if self.typeSolveur == 'Solveur_non_lineaire': # écriture des paramètres du solveur non-linéaire seulement si défini dans l'étude
+ methodeNonLineaire = ET.SubElement(ParametrePrecision, "methodeNonLineaire")
+ methodeNonLineaire.text = "%s" %(self.methodeNonLineaire)
+ kEpsilonNonLinearite = ET.SubElement(ParametrePrecision, "kEpsilonNonLinearite")
+ kEpsilonNonLinearite.text = "%s" %(self.kEpsilonNonLinearite)
+ kCoefficientRelaxation = ET.SubElement(ParametrePrecision, "kCoefficientRelaxation")
+ kCoefficientRelaxation.text = "%s" %(self.kCoefficientRelaxation)
+ kEpsilonDistance = ET.SubElement(ParametrePrecision, "kEpsilonDistance")
+ kEpsilonDistance.text = "%s" %(self.kEpsilonDistance)
+ kdistanceRef = ET.SubElement(ParametrePrecision, "kdistanceRef")
+ kdistanceRef.text = "%s" %(self.kdistanceRef)
+ jauge = ET.SubElement(ParametrePrecision, "jauge")
+ jauge.text = "%s" %(correspondance_booleen[self.jauge], )
+ NBoucleTemps = ET.SubElement(ParametrePrecision, "NBoucleTemps")
+ NBoucleTemps.text = "%s" %(self.NBoucleTemps)
+ dt = ET.SubElement(ParametrePrecision, "dt")
+ dt.text = "%s" %(self.dt)
+
+ #Bloc <Milieux></Milieux>
+ i=0
+ j=0
+ p=0
+ k=0
+ listeMilieux = [] # liste des milieux, dans l'ordre de création
+ Milieux=ET.SubElement(root, "Milieux") # création du bloc <Milieux>...</Milieux>
+ for nom in self.dictGroupes: # on parcoure tous les groupes MESHGROUP
+ if self.dictGroupes[nom].has_key('MATERIAL') \
+ or self.dictGroupes[nom].has_key('SOURCE') \
+ or self.dictGroupes[nom].has_key('AIMANT') \
+ or self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY') : # si MESHGROUP ou MACRO_GROUPE associé à au moins un matériau, source ou géométrie d'inducteur bobiné, c'est un milieu
+ milieu=ET.SubElement(Milieux,"milieu" ) # création d'un nouveau milieu
+ listeMilieux.append(nom) # mise à jour de la liste des milieux
+ i = i+1 # incrément du numéro de milieu
+ self.dictGroupes[nom]['idMilieu'] = i # affectation de l'id à ce groupe
+ milieu.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ milieu.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
+ nomGroupeMaillage = ET.SubElement(milieu, "nomGroupeMaillage") # nom du groupe de maillage
+ nomGroupeMaillage.text = nom
+ if self.dictGroupes[nom].has_key('MATERIAL'): # matériau trouvé pour ce milieu
+ material = self.dictGroupes[nom]['MATERIAL'] # on récupère le nom de la propriété du matériau, clé de self.dictMaterial
+ permeabiliteLineaire=ET.SubElement(milieu, "permeabiliteLineaire")
+ permeabiliteLineaire.text="%s"%(self.dictMaterial[material]["PERMEABILITY"]["VALUE"])
+ if self.dictMaterial[material]["PERMEABILITY"]["LAW"]=="NONLINEAR":
+ coefficientsMarrocco=ET.SubElement(milieu, "coefficientsMarrocco")
+ epsilon = self.dictMaterial[material]["PERMEABILITY"]["EPSILON"]
+ c = self.dictMaterial[material]["PERMEABILITY"]["C"]
+ alpha = self.dictMaterial[material]["PERMEABILITY"]["ALPHA"]
+ tau = self.dictMaterial[material]["PERMEABILITY"]["TAU"]
+ coefficientsMarrocco.text = '%g, %g, %g, %g' % (epsilon, c, alpha, tau)
+ if self.dictMaterial[material].has_key('CONDUCTIVITY'):
+ conductivite=ET.SubElement(milieu, "conductivite")
+ conductivite.text="%s" %(self.dictMaterial[material]["CONDUCTIVITY"]["VALUE"])
+ if self.dictMaterial[material].has_key('AIMANT'):
+ norme=ET.SubElement(milieu, "norme")
+ norme.text="%s" %(self.dictMaterial[material]["AIMANT"]["VALUE"])
+ if self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY'): # géométrie d'inducteur bobiné trouvée pour ce milieu
+ strand=self.dictGroupes[nom]['STRANDED_INDUCTOR_GEOMETRY'] # on récupère le nom de la géométrie d'inducteur bobiné, clé de self.dictStrand
+ axe = ET.SubElement(milieu, "axe")
+ axe.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Direction"]))
+ if self.dictStrand[strand]["Forme"]=="Circulaire":
+ coordonneesPolaires=ET.SubElement(milieu, "coordonneesPolaires")
+ coordonneesPolaires.text="true"
+ origineReperePolaire=ET.SubElement(milieu, "origineReperePolaire")
+ origineReperePolaire.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Centre"]))
+ section=ET.SubElement(milieu, "section")
+ section.text="%g" %(self.dictStrand[strand]["Section"], )
+ if self.dictGroupes[nom].has_key('SOURCE'): # source trouvée pour ce milieu
+ Source = self.dictGroupes[nom]['SOURCE'] # on récupère le nom de la source, clé de self.dictSource
+ self.dictSource[Source]['milieux'].append(nom) # ajout du nom du groupe à cette source
+ if self.dictSource[Source].has_key('STRANDED_INDUCTOR'):
+ nbSpires=ET.SubElement(milieu, "nbSpires")
+ nbSpires.text="%g" %(self.dictSource[Source]["STRANDED_INDUCTOR"]["NTURNS"])
+
+ #Bloc <ConditionsLimitesChamps>...</ConditionsLimitesChamps>
+ ConditionsLimitesChamps = ET.SubElement(root, "ConditionsLimitesChamps")
+ for nomCondition in self.dictGroupes:
+ if self.dictGroupes[nomCondition].has_key('CONDITION_LIMITE'): # condition aux limites associée à ce groupe, hors symétrie et mouvement
+ if self.dictGroupes[nomCondition].has_key('LISTE'): # MACRO_GROUPE
+ for i in range(len(self.dictGroupes[nomCondition]['LISTE'])):
+ conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
+ Type=ET.SubElement(conditionLimite,"type" )
+ Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
+ GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
+ GroupeNoeud.text="%s" %(self.dictGroupes[nomCondition]['LISTE'][i])
+ else: # MESHGROUP
+ conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
+ Type=ET.SubElement(conditionLimite,"type" )
+ Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
+ GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
+ GroupeNoeud.text="%s" %(nomCondition)
+
+ for i in range(len(self.listSymetrie)): # symétries, définies dans le bloc des conditions aux limites
+ conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamp")
+ Type=ET.SubElement(conditionLimite,"type" )
+ Type.text="%s" %(self.listSymetrie[i]["Type"])
+ GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
+ GroupeNoeud.text="%s" %(self.listSymetrie[i]["Face1"])
+ if 'Face2' in self.listSymetrie[i] :
+ GroupeNoeud2=ET.SubElement(conditionLimite, "groupeNoeud2")
+ GroupeNoeud2.text="%s" %(self.listSymetrie[i]["Face2"])
+ if 'Mouvement_associe' in self.listSymetrie[i]:
+ MouvementAssocie=ET.SubElement(conditionLimite, "mouvementAssocie")
+ nomMouvementAssocie = self.listSymetrie[i]['Mouvement_associe'].nom # on récupère le nom du mouvement associé, car on a stocké le concept tout entier
+ MouvementAssocie.text="%i"%(self.dictMouvement[nomMouvementAssocie]['ordre'], )
+ if 'Groupe_Points' in self.listSymetrie[i] :
+ GroupePoints=ET.SubElement(conditionLimite, "groupePoints")
+ GroupePoints.text="%s" %(self.listSymetrie[i]['Groupe_Points'])
+
+ #Bloc <TermeSourceElectrique>...</TermeSourceElectrique>
+ TermeSourceElectrique=ET.SubElement(root, "TermeSourceElectrique")
+ i=0 # ?
+ if self.debug: print 'self.dictSource = ', self.dictSource
+ for source in self.dictSource.keys(): # parcours des sources
+ if len(self.dictSource[source]['milieux']) > 0: # on continue si au moins un groupe de maillage, i.e., milieux est associé à cette source
+ if self.dictSource[source].has_key('STRANDED_INDUCTOR'): # inducteur bobiné
+ inducteur=ET.SubElement(TermeSourceElectrique, "inducteur")
+ listeMilieux=ET.SubElement(inducteur, "listeMilieux") # création de la liste des milieux
+ idListeMilieux = [] # indices des milieux concernés
+ for milieu in self.dictSource[source]['milieux']: # construction de la liste des milieux
+ idListeMilieux.append(self.dictGroupes[milieu]['idMilieu'])
+ listeMilieux.text = "%s" % ','.join(map(str,idListeMilieux))
+ if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="CURRENT": # source de type courant imposé
+ couplageTension=ET.SubElement(inducteur, "couplageTension")
+ couplageTension.text = "false"
+ courant=ET.SubElement(inducteur, "courant")
+ if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
+ courant.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
+ if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
+ amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
+ frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
+ phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
+ courant.text="%g, %g, %g" % (amplitude, frequence, phase)
+ courant.set('forme', 'sinus') # attribut forme="sinus"
+ if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="VOLTAGE": # source de type tension imposée
+ couplageTension=ET.SubElement(inducteur, "couplageTension")
+ couplageTension.text = "true"
+ tension=ET.SubElement(inducteur, "tension")
+ if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
+ tension.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
+ if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
+ amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
+ frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
+ phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
+ tension.text="%g, %g, %g" % (amplitude, frequence, phase)
+ tension.set('forme', 'sinus') # attribut forme="sinus"
+ if self.dictSource[source]["STRANDED_INDUCTOR"].has_key('Resistance'):
+ resistance=ET.SubElement(inducteur, "resistance")
+ resistance.text="%g" %(self.dictSource[source]["STRANDED_INDUCTOR"]['Resistance'])
+
+ #definir Terme Source Magnetique
+ #definirTermeSourceMagnetique=ET.SubElement(root, "definirTermeSourceMagnetique")
+ #nombreTermeSourceMagnetique=ET.SubElement(definirTermeSourceMagnetique, "nombreTermeSourceMagnetique")
+ #nombreTermeSourceMagnetique.text="0"
+
+ #definir Aimants
+ #definirAimants=ET.SubElement(root, "definirAimants")
+ #nombreAimants=ET.SubElement(definirAimants, "nombreAimants")
+ #nombreAimants.text="0"
+
+ #Bloc <Mouvements>...</Mouvements>
+ i = 0
+ Mouvements=ET.SubElement(root, "Mouvements")
+ for nom in self.dictMouvement['ordre']: # parcours de la liste des noms de mouvement définis, dans l'ordre
+ i = i+1
+ mouvement = ET.SubElement(Mouvements, "mouvement") # création de ce mouvement
+ mouvement.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ mouvement.set("name", nom ) # ajout de l'attribut name, inutilisé
+ milieuGlissement = ET.SubElement(mouvement, "milieuGlissement")
+ nomMilieuGlissement = self.dictMouvement[nom]['valeurs']['Milieu_glissement'].nom # concept stocké -> nom du concept
+ milieuGlissement.text="%i" % (self.dictGroupes[nomMilieuGlissement]['idMilieu'], ) # numéro du milieu défini par son nom, selon tableaux remplis précédemment
+ surfaceGlissement = ET.SubElement(mouvement, "surfaceGlissement")
+ surfaceGlissement.text= self.dictMouvement[nom]['valeurs']['Surface_glissement'].nom # concept stocké -> nom du concept
+ deltaMaillage = ET.SubElement(mouvement, "deltaMaillage")
+ deltaMaillage.text="%g" % (self.dictMouvement[nom]['valeurs']['Delta_maillage'], )
+ nbPermutPas = ET.SubElement(mouvement, "nbPermutPas")
+ nbPermutPas.text="%i" % (self.dictMouvement[nom]['valeurs']['Nombre_pas_permutation'], )
+ axeRotation = ET.SubElement(mouvement, "axeRotation")
+ axeRotation.text= self.dictMouvement[nom]['valeurs']['Axe_rotation']
+
+ #definir Force Couple
+ #definirForceCouple=ET.SubElement(root, "definirForceCouple")
+ #nombreForceCouple=ET.SubElement(definirForceCouple, "nombreForceCouple")
+ #nombreForceCouple.text="0"
+
+ #bloc <SpiresExploratrices></SpiresExploratrices>
+ i = 0 # compteur de spires
+ spiresExploratrices = False # pas de spires exploratrices a priori
+ for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
+ spiresExploratrices = True
+ if spiresExploratrices: # on a trouvé au moins une spire exploratrice
+ SpiresExploratrices=ET.SubElement(root, "SpiresExploratrices") # création du bloc XML adéquat
+ for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
+ spire = ET.SubElement(SpiresExploratrices, "spireExploratrice") # création du bloc XML pour cette spire
+ spire.text = nom # le nom du groupe de noeud est directement écrit
+ i = i+1 # incrément du numéro de spire
+ spire.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ spire.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
+
+ #bloc <PotentielsFlottants></PotentielsFlottants>
+ i = 0 # compteur de potentiels flottants
+ potentielsFlottants = False # pas de potentiel flottant a priori
+ for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
+ potentielsFlottants = True
+ if potentielsFlottants: # on a trouvé au moins un potentiel flottant
+ PotentielsFlottants=ET.SubElement(root, "PotentielsFlottants") # création du bloc XML adéquat
+ for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
+ potentielFlottant = ET.SubElement(PotentielsFlottants, "potentielFlottant") # création du bloc XML pour ce potentiel flottant
+ potentielFlottant.text = nom # le nom du groupe de noeud est directement écrit
+ i = i+1 # incrément du numéro de spire
+ potentielFlottant.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ potentielFlottant.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
+
+
+ #Definir Post traitement
+ postraitement=ET.SubElement(root, "postraitement")
+ # Ecriture des cartes de champ
+ carteChamp=ET.SubElement(postraitement, "carteChamp")
+ if type(self.carteChamp)==float:
+ carteChamp.text="%s" %(self.carteChamp)
+ else:
+ carteChamp.text="%s" % ','.join(map(str,self.carteChamp))
+ # Ecriture des cartes de courants induits
+ carteCourantInduit=ET.SubElement(postraitement, "carteCourantInduit")
+ if type(self.carteCourantInduit)==float:
+ carteCourantInduit.text="%s" %(self.carteCourantInduit)
+ else:
+ carteCourantInduit.text="%s" % ','.join(map(str,self.carteCourantInduit))
+ # Ecriture des cartes de force
+ carteForce=ET.SubElement(postraitement, "carteForce")
+ if type(self.carteForce)==float:
+ carteForce.text="%s" %(self.carteForce)
+ else:
+ carteForce.text="%s" % ','.join(map(str,self.carteForce))
+ # Sortie des grandeurs globales, enregistrées dans self.post_global
+ # liste de correspondance entre la valeur du catalogue et le nom de la balise XML
+ # sous forme ordonnée (nomXML, valeur catalogue)
+ correspondance_global = (('energie', "Energie"),\
+ ('perteJoule', "Pertes Joules"),\
+ ('fluxInducteur', "Flux par inducteur"),\
+ ('courantInducteur', "Courants par inducteur"),\
+ ('tensionInducteur', "Tensions par inducteur"), \
+ ('forceCouple', "Force et couple"),\
+ ('fluxSpire', "Flux par spire exploratrice"),\
+ ('fluxGroupe', "Flux par groupe"),\
+ ('ddpElect', "Tensions electriques"),\
+ ('ddpMagn', "DDP magnetiques"), \
+ ('fluxMagn', "Flux magnetiques"),\
+ ('fluxJinduitTotal', "Flux J induit"),\
+ ('potFlottant', "Potentiel flottant"))
+ # Sortie des grandeurs demandées seulement (true)
+ for table in correspondance_global:
+ if table[1] in self.post_global:
+ post_global_item=ET.SubElement(postraitement, table[0])
+ post_global_item.text = "true"
+# # Sortie de toutes les grandeurs possibles, avec la valeur true pour celles demandées et false sinon
+# for table in correspondance_global:
+# post_global_item=ET.SubElement(postraitement, table[0])
+# if table[1] in self.post_global:
+# post_global_item.text = "true"
+# else:
+# post_global_item.text = "false"
+
+ self.indent(root) # indentations et retours à la ligne, à l'aide d'une fonction maison, car xml.etree.ElementTree ne sait pas faire et le module lxml n'est pas disponible dans Salomé
+
+ tree = ET.ElementTree(root)
+
+ tree.write(fileXML, encoding="UTF-8")
+
+ # print "le dico complet=%s" %(self.dictGroupes)
+
+ if self.debug:
+ print "ecriture du fichier d'execution (SH)"
+ RepCarmel=os.path.join(repertory,"lancer.sh")
+ f = open( RepCarmel, 'wb')
+ self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
+ self.texteCarmel3D_SH+='./carmel << FIN\n'
+ correspondance_resolution = {"(T-)Omega seulement":"1\n","A(-Phi) seulement":"2\n", "(T-)Omega puis A(-Phi)":"1\n2\n", "A(-Phi) puis (T-)Omega":"2\n1\n"}
+ self.texteCarmel3D_SH+= correspondance_resolution[self.formulation]
+ self.texteCarmel3D_SH+='0\nFIN\n'
+ f.write(self.texteCarmel3D_SH)
+ f.close()
+
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ if self.debug:
+ print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
+ s=PythonGenerator.generMCSIMP(self,obj)
+ try:
+ self.dicoCourant[obj.nom]=obj.valeurFormatee
+ except:
+ print "Oubli des messages texte homo='information'"
+ return s
+
+
+#----------------------------------------------------------------------------------------
+ def generMCFACT(self,obj) :
+ """recuperation de l objet MCFACT"""
+ dico={}
+ self.dicoMCFACTCourant=dico
+ self.dicoCourant=self.dicoMCFACTCourant
+ s=PythonGenerator.generMCFACT(self,obj)
+ self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=self.dicoEtapeCourant
+ return s
+
+
+#----------------------------------------------------------------------------------------
+ def generPROC_ETAPE(self,obj):
+ """analyse des PROC du catalogue ( VERSION )"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant
+
+ if self.debug:
+ print "PROC_ETAPE %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
+ if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
+ if obj.nom=="SYMETRIE" : self.generBLOC_SYMETRIE(obj)
+ if obj.nom=="POST_TRAITEMENT" : self.generPOST_TRAITEMENT(obj)
+ return s
+
+
+
+#----------------------------------------------------------------------------------------
+ def generETAPE(self,obj):
+ """analyse des OPER du catalogue"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant
+ if self.debug:
+ print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
+ if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
+ if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
+ if obj.nom=="SOURCE" : self.generSOURCE(obj)
+ if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
+ if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
+ if obj.nom=="MOUVEMENT" : self.generMOUVEMENT(obj)
+ s=PythonGenerator.generETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+ def generMACRO_ETAPE(self,obj):
+ """Utilisé par INCLUDE"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ import generator
+ monGenerateur=generator.plugins[nomPlugin]()
+ jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
+ if self.debug:
+ print "jdc_aux_texte : %s" % jdc_aux_texte
+
+ # sauvegarde de tous les matériaux trouvés dans les bibliothèques INCLUDE
+ for cle in monGenerateur.dictMaterial:
+ self.dictMaterial[cle] = monGenerateur.dictMaterial[cle]
+ # sauvegarde de toutes les sources trouvées dans les bibliothèques INCLUDE
+ for cle in monGenerateur.dictSource:
+ self.dictSource[cle] = monGenerateur.dictSource[cle]
+
+ print "________FIN MACRO______________________________________"
+ s=PythonGenerator.generMACRO_ETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+#----------------------------------------------------------------------------------------
+ def generMESHGROUP(self,obj):
+ """preparation de la ligne NAME referencant le groupe de mailles
+ associe le groupe de mailles au materiau ou a la source utilisateur
+ on sauvegarde aussi les noms des groupes de maillage
+ """
+ try:
+ nomGroupe = obj.getSdname() # nom du groupe de maillage, i.e. nom du concept
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
+
+ # on utilise le fait que obj.valeur est un dictionnaire
+ self.dictGroupes[nomGroupe] = {}
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ #if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ # raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupe)
+ # association a un materiau
+ if 'MATERIAL' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ # self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
+ # association a une source
+ if 'SOURCE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ # self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['STRANDED_INDUCTOR_GEOMETRY'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ # self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ if 'CONDITION_LIMITE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['CONDITION_LIMITE'] = obj.valeur['CONDITION_LIMITE']
+ # self.dictGroupes['ordreConditionJdC'].append(nomGroupe)
+ if 'Domaine' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
+ # self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
+ texte=""
+ texte+="%s"%(obj.valeur['Domaine'])
+ print"le texte=%s" %(texte)
+ self.dictDomaine[obj.getSdname()]=texte
+ print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
+ if 'Potentiel_Flottant' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['Potentiel_Flottant'] = True
+ if 'Spire_Exploratrice' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['Spire_Exploratrice'] = True
+
+# else:
+# raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
+ if self.debug:
+ print "self.dictGroupes= %s" % repr(self.dictGroupes)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMACRO_GROUPE(self, obj):
+ """preparation de la ligne NAME referencant le groupe de mailles
+ associe le groupe de mailles au materiau ou a la source utilisateur
+ on sauvegarde aussi les noms des macros groupes
+ """
+ try:
+ nomMacroGroupe = obj.getSdname() # nom du macro groupe
+ print "liste des noms sans prefixes %s" %(nomMacroGroupe)
+ self.dictMacroGroupes[nomMacroGroupe] = obj.valeur # sauvegarde des propriétés du macro-groupe
+
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ # association a une source
+ if 'LISTE_MESHGROUP' in obj.valeur.keys(): # test de liste définie dans la macro-groupe, sinon erreur
+ listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictMacroGroupes[nomMacroGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
+ groupe = groupe.replace("'", "") # suppression des guillement simples
+ groupe = groupe.replace('"', "") # suppression des guillement doubles
+ self.dictMacroGroupes[nomMacroGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
+ else:
+ raise ValueError, nomMacroGroupe + tr(" : ce MACRO_GROUPE doit contenir une liste de groupes LISTE_MESHGROUP.")
+
+ for nomGroupe in self.dictMacroGroupes[nomMacroGroupe]['LISTE']: # liste des groupes MESHGROUP de ce macro-groupe. On leur associe les propriétés du MACRO_GROUPE
+ for propriete in ('SOURCE', 'MATERIAL', 'STRANDED_INDUCTOR_GEOMETRY'): # liste des propriétés automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
+ if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
+ if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete].nom: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
+ print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP %s associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete].nom, nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
+ raise ValueError, propriete + ',' + obj.valeur[propriete].nom + ',' + nomMacroGroupe + ',' + self.dictGroupes[nomGroupe][propriete] + ',' + nomGroupe\
+ + tr(" : conflit entre la propriete (#1:#2) du MACRO_GROUPE (de nom #3) et celle (#4) du MESHGROUP (#5) associe a ce macro-groupe.")
+ else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
+ self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete].nom # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
+ for propriete in ('CONDITION_LIMITE', ): # liste des propriétés définies à l'avance automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
+ if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
+ if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete]: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
+ print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP %s associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete], nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
+ raise ValueError, propriete + ',' + obj.valeur[propriete].nom + ',' + nomMacroGroupe + ',' + self.dictGroupes[nomGroupe][propriete] + ',' + nomGroupe\
+ + tr(" : conflit entre la propriete (#1:#2) du MACRO_GROUPE (de nom #3) et celle (#4) du MESHGROUP (#5) associe a ce macro-groupe.")
+ else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
+ self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete] # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
+ except ValueError, err:
+ raise ValueError, str(err)
+
+
+ def generSOLVEUR(self, obj):
+ if self.debug:
+ print "generation solveur obj.valeur = %s" % obj.valeur
+ try :
+ self.typeSolveur = obj.valeur['Type']
+ if self.typeSolveur == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
+ if self.typeSolveur == "Solveur_non_lineaire" :
+ self.generSOLVEUR_LINEAIRE(obj)
+ self.generSOLVEUR_NON_LINEAIRE(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOLVEUR_LINEAIRE(self, obj):
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['Methode_lineaire']
+ if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
+ if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMETHODE_ITERATIVE_BICGCR(self, obj):
+ if self.debug:
+ print "generation methode iterative BICGCR obj.valeur = %s" % obj.valeur
+ self.kEpsilonGCP = obj.valeur["Precision"]
+ self.precond=obj.valeur["Preconditionneur"]
+ self.nbIterationMax=obj.valeur["Nombre_iterations_max"]
+
+
+ def generMETHODE_DIRECTE_MUMPS(self, obj):
+ texte=""
+ if self.debug:
+ print "_____________directe_____________"
+
+ def generSOLVEUR_NON_LINEAIRE(self, obj):
+ if self.debug:
+ print "generation solveur_non_lineaire obj.valeur = %s" % obj.valeur
+ correspondance_methodeNonLineaire = {"Methode de Newton":2,"Methode de substitution":1} # correspondance sur la méthode non-linéaire entre le catalogue et le XML
+ self.methodeNonLineaire = correspondance_methodeNonLineaire[obj.valeur["Methode_non_lineaire"]]
+ self.kEpsilonNonLinearite=obj.valeur["PrecisionNonLineaire"]
+ self.kCoefficientRelaxation=obj.valeur["Coefficient_de_Relaxation"]
+
+ def generMATERIAL(self,obj):
+ """preparation du bloc correspondant a un materiau du fichier PHYS"""
+ texte=""
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nomMaterial = obj.getSdname()
+ self.dictMaterial[nomMaterial]=obj.valeur
+ print"self.dictMaterial=%s" %(self.dictMaterial)
+ except ValueError, err:
+ raise ValueError, str(err)
+#-------------------------------------------------------------------
+
+ def generSOURCE(self,obj):
+ """preparation du bloc correspondant a une source du fichier PHYS"""
+ if self.debug:
+ print "generation source obj valeur = %s" % obj.valeur
+ texte=""
+ try :
+ nomSource = obj.getSdname()
+ self.dictSource[nomSource]=obj.valeur # dictionnaire
+ self.dictSource[nomSource]['milieux'] = [] # liste ordonnée des groupes associés à cette source
+ print"mon dico des sources=%s" %(self.dictSource)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+#---------------------------------------------------------------------------------------
+# traitement fichier PHYS
+#---------------------------------------------------------------------------------------
+ def generBLOC_VERSION(self,obj) :
+ # constitution du bloc VERSION du fichier PHYS
+ # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
+ # dans le du catalogue
+ version=obj.addEntite('VERSION',pos=None)
+ self.generPROC_ETAPE(obj.etapes[0])
+ self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
+ for cle in obj.etapes[0].valeur :
+ self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
+ self.texteCarmel3D+="]\n"
+ # destruction de l entite creee
+ obj.suppEntite(version)
+ #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
+ #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
+
+
+ def generBLOC_PARAMETERS(self,obj):
+ if self.debug:
+ print "generation parameters obj.valeur = %s" % obj.valeur
+
+ self.identification = obj.valeur["Identification_du_Modele"]
+ self.fichierMaillage = obj.valeur["Fichier_maillage"]
+ self.echelleMaillage = obj.valeur["Echelle_du_maillage"]
+
+ self.kEpsilonDistance=obj.valeur["kEpsilonDistance"]
+ self.kdistanceRef=obj.valeur["kdistanceRef"]
+ self.jauge=obj.valeur["Jauge"]
+ self.NBoucleTemps=obj.valeur["Nb_pas_de_temps"]
+ self.dt=obj.valeur["Pas_de_temps"]
+
+ self.repertory=obj.valeur["RepCarmel"]
+ self.fcarmel=obj.valeur["Resoudre_probleme"]
+ self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
+ self.formulation=obj.valeur["Formulation"]
+
+ def generBLOC_SYMETRIE(self, obj):
+ if self.debug:
+ print "generation de la symetrie obj.valeur = %s" % obj.valeur
+
+ try:
+ self.listSymetrie.append(obj.valeur)
+ print"ma liste symetrie =%s" %(self.listSymetrie)
+ except ValueError, err:
+ raise ValueError, str(err)
+#----------------------------------------------------------------------------------------
+
+ def generMOUVEMENT(self, obj):
+ if self.debug:
+ print "generation du mouvement obj.valeur = %s" % obj.valeur
+
+ try:
+ nom = obj.getSdname()
+ self.nombreMouvements = self.nombreMouvements+1
+ self.dictMouvement[nom] = {'ordre': self.nombreMouvements, 'valeurs': obj.valeur}
+ self.dictMouvement['ordre'].append(nom)
+ if self.debug:
+ print "self.dictMouvement =%s" %(self.dictMouvement)
+ print "self.nombreMouvements =%i" %(self.nombreMouvements)
+ except ValueError, err:
+ raise valueError, str(err)
+#----------------------------------------------------------------------------------------
+ def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
+ """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
+ if self.debug:
+ print "generation strand obj valeur = %s" % obj.valeur
+ try :
+ nomStrand = obj.getSdname()
+ self.dictStrand[nomStrand]=obj.valeur
+ print"mon dico des stranded inductor geometry=%s" %(self.dictStrand)
+
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generPOST_TRAITEMENT(self, obj):
+ if self.debug:
+ print "generation post traitement obj.valeur = %s" % obj.valeur
+ self.carteChamp=obj.valeur["Cartes_des_champs"]
+ self.carteCourantInduit=obj.valeur["Cartes_des_courants_induits"]
+ self.carteForce=obj.valeur["Cartes_des_forces"]
+ if obj.valeur.has_key('GLOBAL'):
+ self.post_global = obj.valeur['GLOBAL']
+ # sauvegarde de la liste au format correct, en supprimant les guillemets simples et doubles extra générés par Eficas
+ # car Eficas génère une liste ["'Energie'","'Flux par inducteur'","'Force et couple'"] enrichie
+ # à partir de l'instruction .comm correctement formatée : GLOBAL=('Energie','Flux par inducteur','Force et couple',)
+ for i in range(len(self.post_global)):
+ self.post_global[i] = self.post_global[i].replace("'", "") # suppression des guillement simples
+ self.post_global[i] = self.post_global[i].replace('"', "") # suppression des guillement doubles
+
+#-------------------------------------
+# Methodes utilitaires
+# ------------------------------------
+ def formateCOMPLEX(self,nbC):
+ """prise en compte des differentes formes de description d un nombre complexe
+ 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
+ """
+ if self.debug:
+ print "formatage"
+ print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
+ nbformate =""
+ if isinstance(nbC,(tuple,list)):
+ if nbC[0] == "'RI'" :
+ nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
+ if nbC[0] == "'MP'" :
+ nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
+ else:
+ nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
+ if self.debug:
+ print "nbformate : %s" % nbformate
+ return nbformate
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+import traceback
+import types,string,re,os
+from Accas.extensions.eficas_translation import tr
+from generator_python import PythonGenerator
+import Accas
+
+debutTextePhys ="[VERSION\n NUM 1\n FILETYPE PHYS\n]\n"
+debutTextePhys+="[MATERIALS\n"
+texteConductor =" [CONDUCTIVITY\n LAW LINEAR\n"
+texteConductor+=" HOMOGENEOUS TRUE\n"
+texteConductor+=" ISOTROPIC TRUE\n"
+texteConducto2 =" 0.0000000000000000E+00\n ]\n"
+texteConducto2+=" [PERMEABILITY\n LAW LINEAR\n"
+texteConducto2+=" HOMOGENEOUS TRUE\n"
+texteConducto2+=" ISOTROPIC TRUE\n"
+texteNoCond =" [PERMITTIVITY\n LAW LINEAR\n"
+texteNoCond+=" HOMOGENEOUS TRUE\n ISOTROPIC TRUE\n"
+texteNoCond+=" VALUE COMPLEX 0.1000000000000000E+01 0.0000000000000000E+00\n"
+texteNoCond+=" ]\n [PERMEABILITY\n LAW LINEAR\n"
+texteNoCond+=" HOMOGENEOUS TRUE\n ISOTROPIC TRUE\n"
+
+debutTexteParam ="[VERSION\n NUM 1\n FILETYPE PARAM\n]\n"
+debutTexteParam+="[PROBLEM\n NAME HARMONIC\n]\n"
+debutTexteParam+="[CAR_FILES\n NAME "
+
+debutTexteZs0 =" [ZSURFACIC\n NAME "
+debutTexteZs ="\n [CONDUCTIVITY\n"
+debutTexteZs+=" LAW LINEAR\n"
+debutTexteZs+=" HOMOGENEOUS TRUE\n"
+debutTexteZs+=" ISOTROPIC TRUE\n"
+debutTexteZs+=" VALUE COMPLEX "
+texteZs2 =" 0.0000000000000000E+00\n ]\n"
+texteZs2 +=" [PERMEABILITY\n LAW LINEAR\n"
+texteZs2 +=" HOMOGENEOUS TRUE\n"
+texteZs2 +=" ISOTROPIC TRUE\n VALUE COMPLEX "
+finTexteZs =" 0.0000000000000000E+00\n ]\n ]\n"
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'CARMELCND',
+ # La factory pour creer une instance du plugin
+ 'factory' : CARMELCNDGenerator,
+ }
+
+
+class CARMELCNDGenerator(PythonGenerator):
+ """
+ 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',)
+
+#----------------------------------------------------------------------------------------
+ def gener(self,obj,format='brut',config=None):
+
+ self.initDico()
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+ self.racine=obj
+ return self.text
+
+
+#----------------------------------------------------------------------------------------
+# initialisations
+#----------------------------------------------------------------------------------------
+
+ def initDico(self) :
+
+ self.dictMCVal={}
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def writeDefault(self,file) :
+#file ne sert pas
+
+ self.texteIngendof=""
+ self.texteParam=debutTexteParam
+ self.chercheFichier()
+ self.traiteSourceVCut()
+
+ fn=self.fnBase
+ fileIngendofDeb = fn[:fn.rfind(".")] + '.ingendof'
+ fileIngendof = os.path.join(self.sauveDirectory,fileIngendofDeb)
+ f = open( str(fileIngendof), 'wb')
+ f.write( self.texteIngendof )
+ f.close()
+
+ self.textePhys=debutTextePhys
+ self.traiteMateriaux()
+ filePhysDeb = fn[:fn.rfind(".")] + '.phys'
+ filePhys = os.path.join(self.sauveDirectory,filePhysDeb)
+ f = open( str(filePhys), 'wb')
+ f.write( self.textePhys )
+ f.close()
+
+ fileParamDeb = fn[:fn.rfind(".")] + '.param'
+ fileParam = os.path.join(self.sauveDirectory,fileParamDeb)
+ self.traiteParam()
+ f = open( str(fileParam), 'wb')
+ f.write( self.texteParam )
+ f.close()
+
+ self.texteCMD="[ \n GLOBAL \n] \n[ \nVISU \n"+self.fnBase.split(".med")[0]+"\nMED \nELEMENT \n] "
+ fileCMDDeb = fn[:fn.rfind(".")] + '.cmd'
+ fileCMD =os.path.join(self.sauveDirectory,fileCMDDeb)
+ f = open( str(fileCMD), 'wb')
+ f.write( self.texteCMD )
+ f.close()
+
+ nomBaseFichier=os.path.basename(fileParam).split(".med")[0]
+
+ self.texteInfcarmel=nomBaseFichier
+ fileInfcarmelDeb = fn[:fn.rfind(".")] + '.infcarmel'
+ fileInfcarmel=os.path.join(self.sauveDirectory,fileInfcarmelDeb)
+ f = open( str(fileInfcarmel), 'wb')
+ f.write( self.texteInfcarmel )
+ f.close()
+
+ self.texteInpostpro=nomBaseFichier+"\n"+nomBaseFichier.split(".param")[0]+'.xmat\n'+nomBaseFichier.split(".param")[0]+'.cmd'
+ fileInpostproDeb = fn[:fn.rfind(".")] + '.inpostprocess'
+ fileInpostpro = os.path.join(self.sauveDirectory,fileInpostproDeb)
+ f = open( str(fileInpostpro), 'wb')
+ f.write( self.texteInpostpro )
+ f.close()
+
+#----------------------------------------------------------------------------------------
+# analyse des commentaires pour trouver le nom du fichier
+#----------------------------------------------------------------------------------------
+
+ def chercheFichier(self) :
+ nomFichier="inconnu"
+ for e in self.racine.etapes:
+ if isinstance(e,Accas.COMMENTAIRE):
+ print 'ùmasdkfh=',e.valeur[0:17]
+ if e.valeur[0:17]=="Cree - fichier : ":
+ debut=e.valeur[17:]
+ liste=debut.split(" - ")
+ nomFichier=liste[0]
+ #print 'nom=',nomFichier
+ #print 'e.va=',e.valeur.split(" ")[-1]
+ #print 'liste=',liste
+ nomDomaine=e.valeur.split(" ")[-1]
+ break
+ self.sauveDirectory=os.path.dirname(nomFichier)
+ self.fnBase=os.path.basename(nomFichier)
+ self.texteIngendof =os.path.basename(nomFichier)+"\n"
+ self.texteParam += os.path.basename(nomFichier).split(".med")[0]+".car\n]\n"
+ self.texteParam +="[PHYS_FILES\n NAME "+os.path.basename(nomFichier).split(".med")[0]+".phys\n]\n"
+
+#----------------------------------------------------------------------------------------
+# analyse du dictionnaire pour trouver les sources et les VCut et les ZS
+#----------------------------------------------------------------------------------------
+
+ def traiteSourceVCut(self) :
+ listeSource=[]
+ listeVCut=[]
+ self.listeZS=[]
+ self.texteSourcePhys="[SOURCES\n"
+ for k in self.dictMCVal.keys():
+ if k.find ("______SOURCE__") > -1 :
+ noms=k.split("_____")
+ if noms[0] not in listeSource : listeSource.append(noms[0])
+ if k.find ("______VCUT__") > -1 :
+ noms=k.split("_____")
+ if noms[0] not in listeVCut : listeVCut.append(noms[0])
+ if k.find ("______ZS") > -1 :
+ noms=k.split("_____")
+ if noms[0] not in self.listeZS : self.listeZS.append(noms[0])
+ listeSource.sort()
+ for source in listeSource:
+ debutKey=source+"______SOURCE__"
+ texteSource=self.dictMCVal[debutKey+"EnveloppeConnexeInducteur"]+"\n"
+ texteSource+="2\n"
+ for val in self.dictMCVal[debutKey+"VecteurDirecteur"] :
+ texteSource+=str(val)+" "
+ texteSource+="\n"
+ for val in self.dictMCVal[debutKey+"Centre"] :
+ texteSource+=str(val)+" "
+ texteSource+="\n"
+ texteSource+=str(self.dictMCVal[debutKey+"SectionBobine"])+"\n"
+ self.texteIngendof+=texteSource
+ self.texteSourcePhys+=" [STRANDED_INDUCTOR\n"
+ self.texteSourcePhys+=" NAME "+source+"\n"
+ self.texteSourcePhys+=" NTURNS "+str(self.dictMCVal[debutKey+"NbdeTours"])+"\n"
+ self.texteSourcePhys+=" CURJ POLAR "+str(self.dictMCVal[debutKey+"Amplitude"])
+ self.texteSourcePhys+=" 0.0000000000000000E+00\n ]\n"
+
+ self.texteSourcePhys+="]\n"
+ for vcut in listeVCut:
+ self.texteIngendof+="1\n"
+ debutKey=vcut+"______VCUT__"
+ if self.dictMCVal[debutKey+"Orientation"] == "Oppose" :self.texteIngendof+="0\n"
+ else : self.texteIngendof+="1\n"
+ if self.dictMCVal["__PARAMETRES__TypedeFormule"]=="APHI" :self.texteIngendof+="1\n"
+ else : self.texteIngendof+="2\n"
+
+
+
+#----------------------------------------------------------------------------------------
+ def traiteMateriaux(self) :
+#----------------------------------------------------------------------------------------
+ listeCond=[]
+ listeNoCond=[]
+ for k in self.dictMCVal.keys():
+ if k.find ("______CONDUCTEUR") > -1 :
+ noms=k.split("_____")
+ if noms[0] not in listeCond : listeCond.append(noms[0])
+ if k.find ("______NOCOND") > -1 :
+ noms=k.split("_____")
+ if noms[0] not in listeNoCond : listeNoCond.append(noms[0])
+
+ for c in listeCond:
+ self.textePhys +=" [CONDUCTOR\n"
+ self.textePhys +=" NAME "+c+"\n"
+ self.textePhys +=texteConductor
+ self.textePhys+=" VALUE COMPLEX "
+ self.textePhys+=str(self.dictMCVal[c+"______CONDUCTEUR__Conductivite"])
+ self.textePhys+=texteConducto2
+ self.textePhys+=" VALUE COMPLEX "
+ self.textePhys+=str(self.dictMCVal[c+"______CONDUCTEUR__PermeabiliteRelative"])
+ self.textePhys+=" 0.0000000000000000E+00\n ]\n ]\n"
+
+ for c in listeNoCond:
+ self.textePhys+=" [DIELECTRIC\n"
+ self.textePhys +=" NAME "+c+"\n"
+ self.textePhys += texteNoCond
+ self.textePhys+=" VALUE COMPLEX "
+ self.textePhys+=str(self.dictMCVal[c+"______NOCOND__PermeabiliteRelative"])
+ self.textePhys+=" 0.0000000000000000E+00\n ]\n ]\n"
+
+ for zs in self.listeZS:
+ self.textePhys+=debutTexteZs0+zs
+ self.textePhys+=debutTexteZs
+ self.textePhys+=str(self.dictMCVal[zs+"______ZS__Conductivite"])
+ self.textePhys+=texteZs2
+ self.textePhys+=str(self.dictMCVal[zs+"______ZS__PermeabiliteRelative"])
+ self.textePhys+=finTexteZs
+
+ self.textePhys+="]\n"
+ self.textePhys+=self.texteSourcePhys
+
+#----------------------------------------------------------------------------------------
+# Creation du fichier Param
+#----------------------------------------------------------------------------------------
+ def traiteParam(self):
+ self.texteParam +="[FREQUENCY\n SINGLE "+str(self.dictMCVal["__PARAMETRES__Frequence"])+"\n]\n"
+ self.texteParam +="[SOLVER\n NAME BICGCR\n"
+ self.texteParam +=" [ITERATIVE_PARAM\n"
+ self.texteParam +=" NITERMAX "+str(self.dictMCVal["__PARAMETRES__Nb_Max_Iterations"])+"\n"
+ self.texteParam +=" EPSILON "+ str(self.dictMCVal["__PARAMETRES__Erreur_Max"])+"\n ]\n]"
+
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ s=PythonGenerator.generMCSIMP(self,obj)
+ if hasattr(obj.etape,'sdnom'): clef=obj.etape.sdnom+"____"
+ else: clef=""
+ for i in obj.getGenealogie() :
+ clef=clef+"__"+i
+ self.dictMCVal[clef]=obj.valeur
+
+ return s
+
+ def get_repExeCarmel(self) :
+ return self.dictMCVal["__PARAMETRES__RepCarmel"]
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+import traceback
+import types,string,re,os
+from Accas.extensions.eficas_translation import tr
+from generator_python import PythonGenerator
+import Accas
+
+
+
+
+#keys = ['Carmel3D_StudyDirectory','Syrthes_StudyDirectory']
+
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'CARMELCS',
+ # La factory pour creer une instance du plugin
+ 'factory' : CARMELCSGenerator,
+ }
+
+
+class CARMELCSGenerator(PythonGenerator):
+ """
+ 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',)
+
+#----------------------------------------------------------------------------------------
+ def gener(self,obj,format='brut',config=None):
+
+ self.initDico()
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+ self.racine=obj
+ return self.text
+
+ def generxml(self,obj,format='brut',config=None):
+
+ texte = self.gener(obj,format,config)
+# print 'self.dictMCVal = ',self.dictMCVal
+ textePourRun = self.update_XMLYacsSchemaForRunning()
+ return textePourRun
+
+#----------------------------------------------------------------------------------------
+# initialisations
+#----------------------------------------------------------------------------------------
+
+ def initDico(self) :
+
+ self.texteDico = ""
+ self.dictMCVal={}
+ self.dicoCS={}
+ self.debutKey = '__PARAM_CS__'
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def getdico(self) :
+ #print 'getdico : self.dictMCVal.keys() = ',self.dictMCVal.keys()
+ for k in self.dictMCVal.keys():
+ if k.find (self.debutKey) > -1 :
+ a,kproperty=k.split(self.debutKey)
+ self.dicoCS[kproperty] = self.dictMCVal[k]
+ #print "self.dicoCS = ",self.dicoCS
+ return self.dicoCS
+
+ def getXMLYacsSchemaFileTemplate(self) :
+
+ for k in self.dictMCVal.keys():
+ if k.find (self.debutKey) > -1 :
+ a,kproperty=k.split(self.debutKey)
+ if kproperty == 'XMLYacsFile' :
+ return self.dictMCVal[k]
+
+ def getXMLYacsSchemaFileRun(self) :
+ xmlYacsSchemaFilePath = self.getXMLYacsSchemaFileTemplate()
+ filename = os.path.basename(xmlYacsSchemaFilePath)
+ dirname = os.path.dirname(xmlYacsSchemaFilePath)
+ prefix = '_run_'
+ runxmlfile = os.path.join(dirname,prefix+filename)
+ return xmlYacsSchemaFilePath,runxmlfile
+
+ def update_XMLYacsSchemaForRunning(self) :
+ """
+ Creation du fichier _run_XXX.xml, a partir des elements donnes par l'utilisateur dans l'interface :
+ Carmel3D_StudyDirectory : YYY (path du repertoire de l'etude CARMEL3D de couplage)
+ Syrthes_StudyDirectory : YYY/THERMIQUE (path du repertoire de l'etude SYRTHES de couplage)
+ XMLYacsFile : PATH du fichier template du schema yacs d'execution du couplage
+ """
+ xmlYacsSchemaFilePath,runxmlfile = self.getXMLYacsSchemaFileRun()
+ f_xml = open( str(xmlYacsSchemaFilePath), 'r')
+ texte_template_xml = f_xml.read()
+ f_xml.close()
+ dicoCS = self.getdico()
+ print "dicoCS = ",dicoCS
+ # ajout dans dicoCS des elements pour SYRTHES qui sont deja sous cette forme la dans le fichier xml sinon ca pose pb
+ dicoCS['DEB']='%(DEB)s'
+ dicoCS['FIN']='%(FIN)s'
+ newTexteXml = texte_template_xml%dicoCS
+ f = open(runxmlfile,'w')
+ f.write(newTexteXml)
+ f.close()
+ return runxmlfile
+
+ def writeDefault(self,fn) :
+ fileDico = fn[:fn.rfind(".")] + '.py'
+ f = open( str(fileDico), 'wb')
+ f.write( self.texteDico )
+ f.close()
+ runxmlfile = self.update_XMLYacsSchemaForRunning()
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ s=PythonGenerator.generMCSIMP(self,obj)
+ self.texteDico+=obj.nom+ "=" + s[0:-1]+ "\n"
+# print 'generMCSIMP self.texteDico = ',self.texteDico
+ if hasattr(obj.etape,'sdnom'): clef=obj.etape.sdnom+"____"
+ else: clef=""
+ for i in obj.getGenealogie() :
+ clef=clef+"__"+i
+ self.dictMCVal[clef]=obj.valeur
+
+ return s
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+texte_debut="int main() \n{ \n init_var();\n"
+texte_debut+=' format="med";\n'
+import traceback
+import types,re,os
+from Accas.extensions.eficas_translation 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,
+ }
+
+
+class PSENGenerator(DicoImbriqueGenerator):
+ """
+ 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',)
+
+#----------------------------------------------------------------------------------------
+ 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'
+
+
+#----------------------------------------------------------------------------------------
+# 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()
+
+
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+## def generMCSIMP(self,obj) :
+## """recuperation de l objet MCSIMP"""
+## #print dir(obj)
+## self.dicoMCSIMP[obj.nom]=obj.val
+## self.dicoTemp[obj.nom]=obj.val
+## s=DicoImbriqueGenerator.generMCSIMP(self,obj)
+## return s
+##
+## def generETAPE(self,obj):
+## self.dicoTemp={}
+## s=DicoImbriqueGenerator.generETAPE(self,obj)
+## if obj.nom=="DISTRIBUTION" : self.dicoLois[obj.sd.nom]=self.dicoTemp
+## self.dicoTemp={}
+## return s
+
+
+# si repertoire on change tous les noms de fichier
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+from __future__ import absolute_import
+import types,re,os
+from Accas.extensions.eficas_translation import tr
+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,
+ }
+
+
+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
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+#----------------------------------------------------------------------------------------
+ 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
+
+ return self.text
+
+
+
+# si repertoire on change tous les noms de fichier
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ SEP pour EFICAS.
+
+"""
+import traceback
+import types,string,re,os
+
+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' : 'SEP',
+ # La factory pour creer une instance du plugin
+ 'factory' : SEPGenerator,
+ }
+
+
+class SEPGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format py
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+ def gener(self,obj,format='brut',config=None):
+ self.initDico()
+ # Cette instruction génère le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+ # Cette instruction génère le contenu du fichier de paramètres python
+ self.genereSEP()
+ return self.text
+
+ def getTubePy(self) :
+ return self.texteTubePy
+
+ def genereSEP(self) :
+ '''
+ Prépare le contenu du fichier de paramètres python. Le contenu
+ peut ensuite être obtenu au moyen de la fonction getTubePy().
+ '''
+ #self.__genereSEP_withVariables()
+ self.__genereSEP_withDico()
+
+ def __genereSEP_withVariables(self) :
+ '''
+ Les paramètres sont transcrits sous forme de variables nom=valeur.
+ '''
+ self.texteTubePy="# Parametres generes par Eficas \n"
+ for MC in self.dictMCVal.keys():
+ ligne = MC +"="+ repr(self.dictMCVal[MC])+'\n'
+ self.texteTubePy=self.texteTubePy+ligne
+
+ print self.texteTubePy
+
+ # __GBO__: Tester self.tube pour aiguiller en fonction du cas (au besoin)
+ fichier=os.path.join(os.path.dirname(__file__),"tube.py")
+ f=open(fichier,'r')
+ for ligne in f.readlines():
+ self.texteTubePy=self.texteTubePy+ligne
+ f.close
+
+ def __genereSEP_withDico(self) :
+ """
+ Les paramètres sont transcrits sous la forme d'un dictionnaire nom=valeur.
+ """
+ from Sep import properties
+ self.texteTubePy="# -*- coding: utf-8 -*-\n"
+ self.texteTubePy+="# ======================================================================================\n"
+ self.texteTubePy+="# FICHIER GENERE PAR EFICAS - OUTIL MÉTIER SOUS-EPAISSEUR - "
+ self.texteTubePy+="VERSION "+str(properties.version)+" du "+str(properties.date)+"\n"
+ self.texteTubePy+="# ======================================================================================\n"
+ self.texteTubePy+="\n"
+ self.texteTubePy+="# Parametres Utilisateur Eficas \n"
+ self.texteTubePy+="parameters={}\n"
+
+ for MC in self.dictMCVal.keys():
+ ligne = "parameters['"+MC+"']="+ repr(self.dictMCVal[MC])+'\n'
+ self.texteTubePy=self.texteTubePy+ligne
+
+ # On ajoute des paramètres de configuration pour contrôle de
+ # cohérence avec la procédure outil métier
+ self.texteTubePy+="# Parametres de Configuration Eficas \n"
+ ligne = "parameters['OMVERSION']="+str(properties.version)+"\n"
+ self.texteTubePy+=ligne
+
+ # __GBO__: Tester self.tube pour aiguiller en fonction du cas (au besoin)
+ self.texteTubePy+="\n"
+ self.texteTubePy+="# Exécution de la procédure outil métier \n"
+ self.texteTubePy+="import os,sys\n"
+ self.texteTubePy+="sys.path.insert(0,os.environ['OM_ROOT_DIR'])\n"
+ self.texteTubePy+="import om_data\n"
+ self.texteTubePy+="om_data.setParameters(parameters)\n"
+ self.texteTubePy+="def run():\n"
+ self.texteTubePy+=" import om_smeca\n"
+ self.texteTubePy+="\n"
+ self.texteTubePy+='if __name__ == "__main__":\n'
+ self.texteTubePy+=" run()\n"
+
+ # For debug only
+ print self.texteTubePy
+
+
+ def initDico(self) :
+ self.tube=0
+ self.coude=0
+ self.dictMCVal={}
+ self.texteTubePy=""
+
+ # __GBO__: surcharge de PythonGenerator:
+ # voir example generator_cuve2dg.py (genea)
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en texte python
+ Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
+ """
+ clef=""
+ for i in obj.getGenealogie() :
+ clef=clef+"__"+i
+ #self.dictMCVal[obj.nom]=obj.valeur
+ self.dictMCVal[clef]=obj.valeur
+
+ s=PythonGenerator.generMCSIMP(self,obj)
+ return s
+
+ # __GBO__: surcharge de PythonGenerator
+ def generMACRO_ETAPE(self,obj):
+ print obj.nom
+ if obj.nom == "S_EP_INTERNE" :
+ self.tube=1
+ if obj.nom == "M_COUDE" :
+ self.coude=1
+ s=PythonGenerator.generMACRO_ETAPE(self,obj)
+ return s
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+
+import pickle
+texte_debut="#include <Zcracks_base.z7p> \n int main() \n{ \n init_var();\n"
+texte_debut+=' format="med";\n'
+import traceback
+import types,re,os
+from Accas.extensions.eficas_translation import tr
+from .generator_python import PythonGenerator
+#ListeConcatene=('ridge_names','topo_names','geom_names','elsetNames','fasetNames','lisetNames','nsetNames','center','normal','dir')
+ListeConcatene=('ridge_names','topo_names','geom_names','elsetNames','fasetNames','lisetNames','nsetNames')
+ListeConcatene2=('center','normal','dir')
+ListeConcatene3=('ra','rb')
+if_ellipse=False
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'ZCRACKS',
+ # La factory pour creer une instance du plugin
+ 'factory' : ZCrackGenerator,
+ }
+
+
+class ZCrackGenerator(PythonGenerator):
+ """
+ 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',)
+
+#----------------------------------------------------------------------------------------
+ def gener(self,obj,format='brut',config=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.textePourRun = texte_debut
+
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def writeDefault(self,fn) :
+ fileZcrack = fn[:fn.rfind(".")] + '.z7p'
+ f = open( str(fileZcrack), 'wb')
+ print((self.textePourRun))
+
+ self.ajoutRun()
+ self.textePourRunAvecDouble=self.textePourRun.replace("'",'"')
+ f.write( self.textePourRunAvecDouble)
+ f.close()
+
+ def ajoutRun(self) :
+ self.textePourRun+=" write_mesh_crack();\n"
+ self.textePourRun+=" do_mesh_crack(0);\n"
+ self.textePourRun+=" write_refine_mesh();\n"
+ self.textePourRun+=" do_refine_mesh(0);\n"
+ self.textePourRun+=" write_cut_mesh();\n"
+ self.textePourRun+=" do_cut_mesh(0);\n"
+# self.textePourRun+=" nice_cut("+str(self.maximum_aspect_ratio)+");\n"
+ self.textePourRun+=' export_mesh("'+self.cracked_name+'","med");\n'
+ self.textePourRun+="}"
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ #print dir(obj)
+ s=PythonGenerator.generMCSIMP(self,obj)
+ if obj.nom=="sane_name" :
+ self.textePourRun+=' import_mesh("'+obj.val+'", "med");\n'
+ if obj.nom in ListeConcatene :
+# obj.val=obj.val+" "
+ stringListe=""
+ for val in obj.val:
+ stringListe+=val+""
+# pickle.dump( stringListe, open( "/home/H60874/test.pickle", "wb" ) )
+# self.textePourRun+=" "+obj.nom+ "='"+ stringListe[0:-1]+ "';\n"
+# self.textePourRun+=" "+obj.nom+ "='"+ stringListe+ "';\n"
+ return s
+ if obj.nom in ListeConcatene3 :
+ if (obj.nom=="ra") :
+ self.textePourRun+=" "+"if_ellipse=1;\n"
+ self.textePourRun+=" "+obj.nom+ "="+str(obj.val)+";\n"
+ if_ellipse_ellipse=True
+ return s
+
+ if obj.nom in ListeConcatene2 :
+ stringListe=""
+# self.textePourRun+="GGGGGGG%"+obj.nom+"\n"
+# if (len(val)>1) :
+ for val in obj.val:
+ stringListe+=str(val)+","
+ self.textePourRun+=" "+obj.nom+ "=set_vector3("+ stringListe[0:-1]+ ");\n"
+# else :
+# self.textePourRun+=" "+obj.nom+ str(obj.val+ ";\n"
+# stringListe+=str(val)+" "
+# self.textePourRun+=" "+obj.nom+ "=set_vector3("+stringListe[0]+","+stringListe[1]+","+stringListe[2]+");\n"
+# self.textePourRun+=" "+obj.nom+ "=set_vector3("+obj.val+","+");\n"
+ return s
+# if obj.nom=="center" :
+# self.textePourRun+=" set_vector3("+obj.val+'");\n"
+# if obj.nom=="center" :
+# self.textePourRun+=" set_vector3("+obj.val+'");\n"
+# if obj.nom=="normal" :
+# self.textePourRun+=" set_vector3("+obj.val+'");\n"
+# if obj.nom=="dir" :
+# self.textePourRun+=" set_vector3("+obj.val+'");\n"
+ if obj.nom=="elset_radius" :
+ self.textePourRun+=" if_must_define_elset=1;\n"
+
+
+ if obj.nom=="cracked_name" : self.cracked_name=obj.val
+ if obj.nom=="maximum_aspect_ratio" : self.maximum_aspect_ratio=obj.val
+ if obj.nom=="repertoire" :
+ print ("PNPNPN a traiter")
+ return s
+ self.textePourRun+=" "+obj.nom+ "=" + s[0:-1]+ ";\n"
+ return s
+
+
+# si repertoire on change tous les noms de fichier
+# exple repertoire='/home' __> fichier='/home/crack.med
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format asterv5 pour EFICAS.
+
+
+"""
+import traceback
+import types,string
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+from Accas.processing import P_CR
+from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
+from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
+from Accas import GEOM,ASSD
+from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
+from Formatage import Formatage
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'asterv5',
+ # La factory pour creer une instance du plugin
+ 'factory' : AsterGenerator,
+ }
+
+
+class AsterGenerator:
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un fichier au format asterv5
+
+ L'acquisition et le parcours sont realises par la methode
+ generator.gener(objet_jdc,format)
+
+ L'ecriture du fichier au format asterv5 est realisee 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=P_CR.CR(debut='CR generateur format asterv5',
+ fin='fin CR format asterv5')
+ # Le texte au format asterv5 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'):
+ """
+ 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
+ """
+ liste= self.generator(obj)
+ if format == 'brut':
+ self.text=liste
+ elif format == 'standard':
+ self.text=string.join(liste)
+ elif format == 'beautifie':
+ jdc_formate = Formatage(liste,sep=':',l_max=72)
+ self.text=jdc_formate.formateJdc()
+ 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 à 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)
+ else:
+ raise EficasException(tr("Type d'objet non prevu : %s", repr(obj)))
+
+ def generJDC(self,obj):
+ """
+ Cette methode convertit un objet JDC en une liste de chaines de
+ caracteres à la syntaxe asterv5
+ """
+ l=[]
+ 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])==types.ListType:
+ l[-1][-1] = l[-1][-1]+'\n'
+ elif type(l[-1])==types.StringType:
+ l[-1] = l[-1]+'\n'
+ return l
+
+ def generCOMMANDE_COMM(self,obj):
+ """
+ Cette methode convertit un COMMANDE_COMM
+ en une liste de chaines de caracteres à la syntaxe asterv5
+ """
+ l_lignes = string.split(obj.valeur,'\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 à la syntaxe asterv5
+ """
+ return 'EVAL(u"'+ obj.valeur +'")'
+
+ def generCOMMENTAIRE(self,obj):
+ """
+ Cette methode convertit un COMMENTAIRE
+ en une liste de chaines de caracteres à la syntaxe asterv5
+ """
+ l_lignes = string.split(obj.valeur,'\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 liste de chaines de caracteres à la syntaxe asterv5
+ """
+ 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 liste de chaines de caracteres à la syntaxe asterv5
+ """
+ if type(obj.valeur) == types.StringType:
+ 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 liste de chaines de caracteres à la syntaxe asterv5
+ """
+ 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 à la syntaxe asterv5
+ """
+ try:
+ if obj.reuse != None:
+ sdname= "&" + self.generator(obj.reuse)
+ else:
+ sdname= self.generator(obj.sd)
+ except:
+ sdname='sansnom'
+ l=[]
+ label=sdname + '='+obj.definition.nom+'('
+ l.append(label)
+ for v in obj.mc_liste:
+ if isinstance(v,MCBLOC) or isinstance(v,MCList):
+ liste=self.generator(v)
+ for mocle in liste :
+ l.append(mocle)
+ else:
+ l.append(self.generator(v))
+ if len(l) == 1:
+ l[0]=label+');'
+ else :
+ l.append(');')
+ return l
+
+ def generFORM_ETAPE(self,obj):
+ """
+ Methode particuliere pour les objets de type FORMULE
+ """
+ l=[]
+ nom = obj.getNom()
+ if nom == '' : nom = 'sansnom'
+ if len(obj.mc_liste)>0:
+ l.append(nom + ' = FORMULE(')
+ s=obj.type_retourne + ' = ' + "'''" + obj.arguments + ' = ' + obj.corps+"'''"
+ l.append(s)
+ l.append(');')
+ else:
+ l.append(nom+' = FORMULE();')
+ return l
+
+ def generMACRO_ETAPE(self,obj):
+ """
+ Cette methode convertit une macro-etape
+ en une liste de chaines de caracteres à la syntaxe asterv5
+ """
+ if obj.definition.nom == 'FORMULE' : return self.gen_ast_formule(obj)
+ try:
+ if obj.reuse != None:
+ sdname= "&" + self.generator(obj.reuse)+'='
+ elif obj.sd == None:
+ sdname=''
+ else:
+ sdname= self.generator(obj.sd)+'='
+ except:
+ sdname='sansnom='
+ l=[]
+ label = sdname + obj.definition.nom+'('
+ l.append(label)
+ for v in obj.mc_liste:
+ if isinstance(v,MCBLOC) or isinstance(v,MCList):
+ liste=self.generator(v)
+ for mocle in liste :
+ l.append(mocle)
+ else:
+ # MCFACT ou MCSIMP
+ l.append(self.generator(v))
+ if len(l) == 1:
+ l[0]=label+');'
+ else :
+ l.append(');')
+ return l
+
+ def gen_ast_formule(self,obj):
+ """
+ Methode gen_ast particuliere aux objets de type FORMULE
+ """
+ label='!FORMULE('
+ try:
+ sdname= self.generator(obj.sd)
+ except:
+ sdname='sansnom'
+ l=[]
+ l.append(label)
+ for v in obj.mc_liste:
+ s=''
+ s= v.nom+':'+sdname+'('+v.valeur+')'
+ l.append(s)
+ if len(l) == 1:
+ l[0]=label+');'
+ else :
+ l.append(');')
+ return l
+
+ def generPROC_ETAPE(self,obj):
+ """
+ Cette methode convertit une etape
+ en une liste de chaines de caracteres à la syntaxe asterv5
+ """
+ l=[]
+ label=obj.definition.nom+'('
+ l.append(label)
+ for v in obj.mc_liste:
+ if isinstance(v,MCBLOC) or isinstance(v,MCList):
+ liste=self.generator(v)
+ for mocle in liste :
+ l.append(mocle)
+ else:
+ l.append(self.generator(v))
+ if len(l) == 1:
+ l[0]=label+');'
+ else :
+ l.append(');')
+ return l
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en une liste de chaines de caracteres à la
+ syntaxe asterv5
+ """
+ if type(obj.valeur) == types.TupleType :
+ s = '('
+ for val in obj.valeur :
+ if s != '(': s = s + ','
+ if type(val) == types.InstanceType :
+ if isinstance(val,PARAMETRE):
+ # il ne faut pas prendre la string que retourne gen_ast
+ # mais seulement le nom dans le cas d'un parametre
+ s = s + val.nom
+ else:
+ s = s + self.generator(val)
+ elif self.wait_geom(obj):
+ s = s + val
+ elif type(val) == types.FloatType :
+ #s = s + self.repr_float(val)
+ s = s + str(val)
+ else :
+ s = s + `val`
+ s = s + ')'
+ s=obj.nom+':'+s+' '
+ return s
+ else :
+ if type(obj.valeur) == types.InstanceType :
+ if isinstance(obj.valeur,PARAMETRE):
+ # il ne faut pas prendre la string que retourne gen_ast
+ # mais seulement str dans le cas d'un parametre
+ s = obj.valeur.nom
+ else:
+ s = self.generator(obj.valeur)
+ elif self.wait_geom(obj):
+ s = obj.valeur
+ elif type(obj.valeur) == types.FloatType :
+ #s = self.repr_float(obj.valeur)
+ s = str(obj.valeur)
+ else :
+ s = `obj.valeur`
+ s=obj.nom+':'+s+' '
+ return s
+
+ def wait_geom(self,obj):
+ for typ in obj.definition.type:
+ if type(typ) == types.ClassType :
+ if issubclass(typ,GEOM) : return 1
+ return 0
+
+ def repr_float(self,valeur):
+ """
+ Cette fonction represente le reel valeur comme une chaîne de caracteres
+ sous forme mantisse exposant si necessaire cad si le nombre contient plus de 5 caracteres
+ NB : valeur est un reel au format Python ou une chaîne de caracteres representant un reel
+ """
+ if type(valeur) == types.StringType : valeur = eval(valeur)
+ if valeur == 0. : return '0.0'
+ if abs(valeur) > 1. :
+ if abs(valeur) < 10000. : return repr(valeur)
+ else :
+ if abs(valeur) > 0.01 : return repr(valeur)
+ t=repr(valeur)
+ if string.find(t,'e') != -1 or string.find(t,'E') != -1 :
+ # le reel est dejà sous forme mantisse exposant !
+ # --> on remplace e par E
+ t=string.replace(t,'e','E')
+ # --> on doit encore verifier que la mantisse contient bien un '.'
+ if string.find(t,'.')!= -1:
+ return t
+ else:
+ # -->il faut rajouter le point avant le E
+ t=string.replace(t,'E','.E')
+ return t
+ s=''
+ neg = 0
+ if t[0]=='-':
+ s=s+t[0]
+ t=t[1:]
+ cpt = 0
+ if string.atof(t[0]) == 0.:
+ # reel plus petit que 1
+ neg = 1
+ t=t[2:]
+ cpt=1
+ while string.atof(t[0]) == 0. :
+ cpt = cpt+1
+ t=t[1:]
+ s=s+t[0]+'.'
+ for c in t[1:]:
+ s=s+c
+ else:
+ # reel plus grand que 1
+ s=s+t[0]+'.'
+ if string.atof(t[1:]) == 0.:
+ l=string.split(t[1:],'.')
+ cpt = len(l[0])
+ else:
+ r=0
+ pt=0
+ for c in t[1:]:
+ r=r+1
+ if c != '.' :
+ if pt != 1 : cpt = cpt + 1
+ s=s+c
+ else:
+ pt = 1
+ if r+1 == len(t) or string.atof(t[r+1:]) == 0.:break
+ s=s+'E'+neg*'-'+repr(cpt)
+ return s
+
+ def generASSD(self,obj):
+ """
+ Convertit un objet derive d'ASSD en une chaine de caracteres à la
+ syntaxe asterv5
+ """
+ return obj.getName()
+
+ def generMCFACT(self,obj):
+ """
+ Convertit un objet MCFACT en une liste de chaines de caracteres à la
+ syntaxe asterv5
+ """
+ l=[]
+ label=obj.nom + ':('
+ l.append(label)
+ for v in obj.mc_liste:
+ if isinstance(v,MCBLOC) or isinstance(v,MCList):
+ liste=self.generator(v)
+ for mocle in liste :
+ l.append(mocle)
+ else:
+ l.append(self.generator(v))
+ l.append(')')
+ return l
+
+ def generMCList(self,obj):
+ """
+ Convertit un objet MCList en une liste de chaines de caracteres à la
+ syntaxe asterv5
+ """
+ l=[]
+ for mcfact in obj.data:
+ l.append(self.generator(mcfact))
+ return l
+
+ def generMCBLOC(self,obj):
+ """
+ Convertit un objet MCBLOC en une liste de chaines de caracteres à la
+ syntaxe asterv5
+ """
+ l=[]
+ for v in obj.mc_liste:
+ if isinstance(v,MCBLOC) or isinstance(v,MCList):
+ liste=self.generator(v)
+ for mocle in liste :
+ l.append(mocle)
+ else:
+ l.append(self.generator(v))
+ return l
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ DefaillCUVE pour EFICAS.
+
+"""
+import traceback
+import types,string,re
+
+from Accas.processing import P_CR
+from Accas import MCSIMP
+from generator_python import PythonGenerator
+
+def entryPoint():
+ """
+ Retourne les informations nécessaires pour le chargeur de plugins
+
+ Ces informations sont retournées dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'cuve2dg',
+ # La factory pour créer une instance du plugin
+ 'factory' : Cuve2dgGenerator,
+ }
+
+
+class Cuve2dgGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format DefaillCUVE
+
+ """
+ # Les extensions de fichier préconisées
+ 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=P_CR.CR(debut='CR generateur format DefaillCUVE pour DefaillCUVE',
+ fin='fin CR format DefaillCUVE pour DefaillCUVE')
+ # Le texte au format DefaillCUVE est stocké dans l'attribut textCuve
+ self.textCuve=''
+
+ # Ce dictionnaire liste le nom des variables utilisees dans le script
+ self.variable = {
+ "NiveauImpression" : "MESSAGE_LEVEL",
+ "FichierDataIn" : "DATARESUME_FILE",
+ "FichierTempSigma" : "TEMPSIG_FILE",
+ "FichierCSV" : "CSV_FILE",
+ "FichierRESTART" : "RESTART_FILE",
+ "FichierEXTR" : "EXTR_FILE",
+ "ChoixPlugin" : "CHOIPLUG",
+ "GrandeurEvaluee" : "GRANDEUR",
+ "IncrementTemporel" : "INCRTPS",
+ "IncrementMaxTemperature" : "DTPREC",
+ "ChoixExtractionTransitoires" : "CHOIEXTR",
+ "IncrementMaxTempsAffichage" : "DTARCH",
+ "traitementGeometrie" : "TYPEGEOM",
+ "RayonInterne" : "RINT",
+ "RayonInterne_mess" : "RINT_MESSAGE",
+ "RayonExterne" : "REXT",
+ "RayonExterne_mess" : "REXT_MESSAGE",
+ "EpaisseurRevetement" : "LREV",
+ "EpaisseurRevetement_mess" : "LREV_MESSAGE",
+ "LigamentExterneMin" : "LIGMIN",
+ "LigamentExterneMin_mess" : "LIGMIN_MESSAGE",
+ "NombreNoeudsMaillage" : "NBNO",
+ "TypeInitial" : "TYPEDEF",
+ "Orientation" : "ORIEDEF",
+ "Position" : "POSDEF",
+ "ProfondeurRadiale" : "PROFDEF",
+ "ProfondeurRadiale_mess" : "PROFDEF_MESSAGE",
+ "ModeCalculLongueur" : "OPTLONG",
+ "Longueur" : "LONGDEF",
+ "Longueur_mess" : "LONGDEF_MESSAGE",
+ "CoefDirecteur" : "PROFSURLONG",
+ "CoefDirecteur_mess" : "PROFSURLONG_MESSAGE",
+ "Constante" : "LONGCONST",
+ "ModeCalculDecalage" : "DECATYP",
+ "DecalageNormalise" : "DECANOR",
+ "DecalageNormalise_mess" : "DECANOR_MESSAGE",
+ "DecalageRadial" : "DECADEF",
+ "DecalageRadial_mess" : "DECADEF_MESSAGE",
+ "Azimut" : "ANGLDEF",
+ "Azimut_mess" : "ANGLDEF_MESSAGE",
+ "Altitude_mess" : "ANGLDEF_MESSAGE",
+ "Altitude" : "ALTIDEF",
+ "Altitude_mess" : "ALTIDEF_MESSAGE",
+ "Pointe" : "POINDEF",
+ "ModeleFluence" : "MODELFLUENCE",
+ "ZoneActiveCoeur_AltitudeSup" : "H1COEUR",
+ "ZoneActiveCoeur_AltitudeInf" : "H2COEUR",
+ "FluenceMax" : "fmax",
+ "KPFrance" : "KPFRANCE",
+ "KPUS" : "KPUS",
+ "Azimut_0deg" : "COEFFLUENCE1",
+ "Azimut_5deg" : "COEFFLUENCE2",
+ "Azimut_10deg" : "COEFFLUENCE3",
+ "Azimut_15deg" : "COEFFLUENCE4",
+ "Azimut_20deg" : "COEFFLUENCE5",
+ "Azimut_25deg" : "COEFFLUENCE6",
+ "Azimut_30deg" : "COEFFLUENCE7",
+ "Azimut_35deg" : "COEFFLUENCE8",
+ "Azimut_40deg" : "COEFFLUENCE9",
+ "Azimut_45deg" : "COEFFLUENCE10",
+ "TypeIrradiation" : "TYPEIRR",
+ "RTNDT" : "RTNDT",
+ "ModeleIrradiation" : "MODELIRR",
+ "TeneurCuivre" : "CU",
+ "TeneurCuivre_mess" : "CU_MESSAGE",
+ "TeneurNickel" : "NI",
+ "TeneurNickel_mess" : "NI_MESSAGE",
+ "TeneurPhosphore" : "P",
+ "TeneurPhosphore_mess" : "P_MESSAGE",
+ "MoyenneRTndt" : "RTimoy",
+ "MoyenneRTndt_mess" : "RTimoy_MESSAGE",
+ "CoefVariationRTndt" : "RTicov",
+ "CoefVariationRTndt_mess" : "RTicov_MESSAGE",
+ "EcartTypeRTndt" : "USectDRT",
+ "EcartTypeRTndt_mess" : "USectDRT_MESSAGE",
+ "NombreEcartTypeRTndt" : "nbectDRTNDT",
+ "NombreEcartTypeRTndt_mess" : "nbectDRTNDT_MESSAGE",
+ "ModeleTenacite" : "MODELKIC",
+ "NombreCaracteristique" : "NBCARAC",
+ "NbEcartType_MoyKIc" : "nbectKIc",
+ "NbEcartType_MoyKIc_mess" : "nbectKIc_MESSAGE",
+ "PalierDuctile_KIc" : "KICPAL",
+ "CoefficientVariation_KIc" : "KICCDV",
+ "Fractile_KIc" : "fractKIc",
+ "Fractile_KIc_mess" : "fractKIc_MESSAGE",
+ "Temperature_KIc100" : "T0WALLIN",
+ "A1" : "A1",
+ "A2" : "A2",
+ "A3" : "A3",
+ "B1" : "B1",
+ "B2" : "B2",
+ "B3" : "B3",
+ "C1" : "C1",
+ "C2" : "C2",
+ "C3" : "C3",
+ "ChoixCorrectionLongueur" : "CHOIXCL",
+ "AttnCorrBeta" : "ATTNCORRBETA",
+ "CorrIrwin" : "CORRIRWIN",
+ "ArretDeFissure" : "ARRETFISSURE",
+ "IncrementTailleFissure" : "INCRDEF",
+ "IncrementTailleFissure_mess" : "INCRDEF_MESSAGE",
+ "NbEcartType_MoyKIa" : "nbectKIa",
+ "PalierDuctile_KIa" : "KIAPAL",
+ "CoefficientVariation_KIa" : "KIACDV",
+ "ChoixCoefficientChargement" : "CHOIXSIGM",
+ "CoefficientDuctile" : "COEFSIGM1",
+ "CoefficientFragile" : "COEFSIGM2",
+ "InstantInitialisation" : "INSTINIT",
+ "ConditionLimiteThermiqueREV" : "KTHREV",
+ "TemperatureDeformationNulleREV" : "TREFREV",
+ "TemperaturePourCoefDilatThermREV" : "TDETREV",
+ "CoefficientPoissonREV" : "NUREV",
+ "ConditionLimiteThermiqueMDB" : "KTHMDB",
+ "TemperatureDeformationNulleMDB" : "TREFMDB",
+ "TemperaturePourCoefDilatThermMDB" : "TDETMDB",
+ "CoefficientPoissonMDB" : "NUMDB",
+ "TypeConditionLimiteThermique" : "TYPCLTH",
+ "Instant_1" : "INSTANT1",
+ "Instant_2" : "INSTANT2",
+ "Instant_3" : "INSTANT3",
+ "DebitAccumule" : "QACCU",
+ "DebitInjectionSecurite" : "QIS",
+ "TempInjectionSecurite" : "TIS",
+ "TempInjectionSecurite_mess" : "TIS_MESSAGE",
+ "DiametreHydraulique" : "DH",
+ "DiametreHydraulique_mess" : "DH_MESSAGE",
+ "SectionEspaceAnnulaire" : "SECTION",
+ "SectionEspaceAnnulaire_mess" : "SECTION_MESSAGE",
+ "HauteurCaracConvectionNaturelle" : "DELTA",
+ "HauteurCaracConvectionNaturelle_mess" : "DELTA_MESSAGE",
+ "CritereConvergenceRelative" : "EPS",
+ "CoefficientsVestale" : "COEFVESTALE",
+ "VolumeMelange_CREARE" : "VMTAB",
+ "TemperatureInitiale_CREARE" : "T0",
+ "TemperatureInitiale_CREARE_mess" : "T0_MESSAGE",
+ "SurfaceEchange_FluideStructure" : "SE",
+ "SurfaceEchange_FluideStructure_mess" : "SE_MESSAGE",
+ "InstantPerteCirculationNaturelle" : "INST_PCN",
+ }
+
+ # Ce dictionnaire liste le nom des valeurs proposées utilisees dans le script
+ self.valeurproposee = {
+ "Aucune impression" : "0",
+ "Temps total" : "1",
+ "Temps intermediaires" : "2",
+ "Facteur de marge KIc/KCP" : "FM_KICSURKCP",
+ "Marge KIc-KI" : "MARGE_KI",
+ "Marge KIc-KCP" : "MARGE_KCP",
+ "Topologie" : "GEOMETRIE",
+ "Maillage" : "MAILLAGE",
+ "Defaut Sous Revetement" : "DSR",
+ "Defaut Decale" : "DECALE",
+ "Defaut Debouchant" : "DEBOUCHANT",
+ "Longitudinale" : "LONGITUD",
+ "Circonferentielle" : "CIRCONF",
+ "Virole" : "VIROLE",
+ "Joint soude" : "JSOUDE",
+ "Valeur" : "VALEUR",
+ "Fonction affine de la profondeur" : "FCTAFFINE",
+ "Valeur normalisee" : "NORMALISE",
+ "A" : "A",
+ "B" : "B",
+ "A et B" : "BOTH",
+ "Exponentiel sans revetement k=9.7 (Reglementaire)" : "Reglementaire",
+ "Exponentiel sans revetement k=12.7 (France)" : "France",
+ "Exponentiel sans revetement k=0. (ValeurImposee)" : "ValeurImposee",
+ "Donnees francaises du palier CPY (SDM)" : "SDM",
+ "Regulatory Guide 1.99 rev 2 (USNRC)" : "USNRC",
+ "Dossier 900 MWe AP9701 rev 2 (REV_2)" : "REV_2",
+ "Lissage du modele ajuste (SDM_Lissage)" : "SDM_Lissage",
+ "Donnees francaises du palier CPY ajustees par secteur angulaire (GrandeDev)" : "GrandeDev",
+ "Grand developpement (GD_Cuve)" : "GD_Cuve",
+ "Exponentiel sans revetement k=9.7 (Reglementaire CUVE1D)" : "Cuve1D",
+ "RTndt de la cuve a l instant de l analyse" : "RTNDT",
+ "Modele d irradiation" : "FLUENCE",
+ "Formule de FIM/FIS Lefebvre modifiee" : "LEFEBnew",
+ "Metal de Base : formule de FIM/FIS Houssin" : "HOUSSIN",
+ "Metal de Base : formule de FIM/FIS Persoz" : "PERSOZ",
+ "Metal de Base : formule de FIM/FIS Lefebvre" : "LEFEBVRE",
+ "Metal de Base : Regulatory Guide 1.00 rev 2" : "USNRCmdb",
+ "Joint Soude : formulation de FIM/FIS Brillaud" : "BRILLAUD",
+ "Joint Soude : Regulatory Guide 1.00 rev 2" : "USNRCsoud",
+ "RCC-M/ASME coefficient=2" : "RCC-M",
+ "RCC-M/ASME coefficient=2 CUVE1D" : "RCC-M_simpl",
+ "RCC-M/ASME coefficient=2.33 (Houssin)" : "Houssin_RC",
+ "RCC-M/ASME avec KI=KIpalier" : "RCC-M_pal",
+ "RCC-M/ASME avec KI~exponentiel" : "RCC-M_exp",
+ "Weibull basee sur la master cuve" : "Wallin",
+ "Weibull basee sur la master cuve (REME)" : "REME",
+ "Weibull n\xb01 (etude ORNL)" : "ORNL",
+ "Weibull n\xb02" : "WEIB2",
+ "Weibull n\xb03" : "WEIB3",
+ "Weibull generalisee" : "WEIB-GEN",
+ "Exponentielle n\xb01 (Frama)" : "Frama",
+ "Exponentielle n\xb02 (LOGWOLF)" : "LOGWOLF",
+ "Quantile" : "QUANTILE",
+ "Ordre" : "ORDRE",
+ "Enthalpie" : "ENTHALPIE",
+ "Chaleur" : "CHALEUR",
+ "Temperature imposee en paroi" : "TEMP_IMPO",
+ "Flux de chaleur impose en paroi" : "FLUX_REP",
+ "Temperature imposee du fluide et coefficient echange" : "ECHANGE",
+ "Debit massique et temperature d injection de securite" : "DEBIT",
+ "Temperature imposee du fluide et debit d injection de securite" : "TEMP_FLU",
+ "Courbe APRP" : "APRP",
+ "Calcul TEMPFLU puis DEBIT" : "TFDEBIT",
+ }
+
+ # Ce dictionnaire liste le commentaire des variables utilisees dans le script
+ self.comment = {
+ "NiveauImpression" : "Niveau d impression des messages a l ecran (=0 : rien, =1 : temps calcul total, =2 : temps intermediaires)",
+ "FichierDataIn" : "sortie du fichier recapitulatif des donnees d entree {OUI ; NON}",
+ "FichierTempSigma" : "sortie des fichiers temperature et contraintes {OUI ; NON}",
+ "FichierCSV" : "sortie du fichier resultat template_DEFAILLCUVE.CSV {OUI ; NON}",
+ "FichierRESTART" : "sortie du fichier de re-demarrage",
+ "FichierEXTR" : "sortie du fichier d extraction des transitoires",
+ "ChoixPlugin" : "choix d'un repertoire de plug-in",
+ "GrandeurEvaluee" : "choix de la grandeur sous critere evaluee {FM_KICSURKCP ; MARGE_KI ; MARGE_KCP}",
+ "IncrementTemporel" : "increment temporel pour l analyse PROBABILISTE (si DETERMINISTE, fixer a 1)",
+ "IncrementMaxTemperature" : "increment max de temp/noeud/instant (degC)",
+ "ChoixExtractionTransitoires" : "choix d'extraction de transitoires de temp et contraintes",
+ "IncrementMaxTempsAffichage" : "increment max de temps pour affichage (s)",
+ "traitementGeometrie" : "traitement de la geometrie de la cuve : {GEOMETRIE, MAILLAGE}",
+ "RayonInterne" : "rayon interne (m)",
+ "RayonInterne_mess" : "affichage ecran du rayon interne (m)",
+ "RayonExterne" : "rayon externe (m)",
+ "RayonExterne_mess" : "affichage ecran du rayon externe (m)",
+ "EpaisseurRevetement" : "epaisseur revetement (m)",
+ "EpaisseurRevetement_mess" : "affichage ecran de l epaisseur revetement (m)",
+ "LigamentExterneMin" : "ligament externe minimal avant rupture (% de l'epaisseur de cuve)",
+ "LigamentExterneMin_mess" : "affichage ecran du ligament externe minimal avant rupture (% de l'epaisseur de cuve)",
+ "NombreNoeudsMaillage" : "nbre de noeuds dans l'epaisseur de la cuve",
+ "TypeInitial" : "type initial du defaut : DEBOUCHANT=Defaut Debouchant, DSR=Defaut Sous Revetement, DECALE=Defaut Decale",
+ "Orientation" : "orientation (LONGITUD / CIRCONF)",
+ "Position" : "Position du defaut (VIROLE / JSOUDE)",
+ "ProfondeurRadiale" : "profondeur radiale ou encore hauteur (m)",
+ "ProfondeurRadiale_mess" : "affichage ecran de la profondeur radiale ou encore hauteur (m)",
+ "ModeCalculLongueur" : "option pour definir la longueur du defaut (VALEUR pour une valeur fixe, FCTAFFINE pour une fct affine de la profondeur)",
+ "Longueur" : "longueur (m) pour defaut Sous Revetement",
+ "Longueur_mess" : "affichage ecran de la longueur (m) pour defaut Sous Revetement",
+ "CoefDirecteur" : "pente de la fonction affine l = h/profsurlong + a0",
+ "CoefDirecteur_mess" : "affichage ecran de la pente de la fonction affine l = h/profsurlong + a0",
+ "Constante" : "constante de la fonction affine a0",
+ "ModeCalculDecalage" : "type de decalage : normalise (NORMALISE) ou reel (VALEUR)",
+ "DecalageNormalise" : "decalage radial normalise (valeur comprise entre 0. et 1.) pour defaut Sous Revetement",
+ "DecalageNormalise_mess" : "affichage ecran du decalage radial normalise (valeur comprise entre 0. et 1.) pour defaut Sous Revetement",
+ "DecalageRadial" : "decalage radial reel (m) pour defaut decale",
+ "DecalageRadial_mess" : "affichage ecran du decalage radial reel (m) pour defaut decale",
+ "Azimut" : "coordonnee angulaire (degre)",
+ "Azimut_mess" : "affichage ecran de la coordonnee angulaire (degre)",
+ "Altitude" : "altitude (m) : valeur negative",
+ "Altitude_mess" : "affichage ecran de l altitude (m) : valeur negative",
+ "Pointe" : "choix du(des) point(s) du defaut considere {'A','B','BOTH'} pour DSR et DECALE (pour DEBOUCHANT : automatiquement 'B')",
+ "ModeleFluence" : "modele de fluence : {Reglementaire, France, ValeurImposee, SDM, USNRC, REV_2, SDM_Lissage, GrandeDev, GD_Cuve, Cuve1D}",
+ "ZoneActiveCoeur_AltitudeSup" : "cote superieure de la zone active de coeur (ici pour cuve palier 900Mw)",
+ "ZoneActiveCoeur_AltitudeInf" : "cote inferieure de la zone active de coeur (ici pour cuve palier 900Mw)",
+ "FluenceMax" : "fluence maximale assimilee par la cuve (n/cm2)",
+ "KPFrance" : "parametre exponentiel du modele France",
+ "KPUS" : "parametre exponentiel du modele US",
+ "Azimut_0deg" : "fluence a l'azimut 0 (10^19 n/cm)",
+ "Azimut_5deg" : "fluence a l'azimut 5 (10^19 n/cm)",
+ "Azimut_10deg" : "fluence a l'azimut 10 (10^19 n/cm)",
+ "Azimut_15deg" : "fluence a l'azimut 15 (10^19 n/cm)",
+ "Azimut_20deg" : "fluence a l'azimut 20 (10^19 n/cm)",
+ "Azimut_25deg" : "fluence a l'azimut 25 (10^19 n/cm)",
+ "Azimut_30deg" : "fluence a l'azimut 30 (10^19 n/cm)",
+ "Azimut_35deg" : "fluence a l'azimut 35 (10^19 n/cm)",
+ "Azimut_40deg" : "fluence a l'azimut 40 (10^19 n/cm)",
+ "Azimut_45deg" : "fluence a l'azimut 45 (10^19 n/cm)",
+ "TypeIrradiation" : "type irradiation : {RTNDT, FLUENCE}",
+ "RTNDT" : "RTNDT finale (degC)",
+ "ModeleIrradiation" : "modele d irradiation : LEFEBnew, ou {HOUSSIN, PERSOZ, LEFEBVRE, USNRCmdb} pour virole et {BRILLAUD,USNRCsoud} pour jointsoude",
+ "TeneurCuivre" : "teneur en cuivre (%)",
+ "TeneurCuivre_mess" : "affichage ecran de la teneur en cuivre (%)",
+ "TeneurNickel" : "teneur en nickel (%)",
+ "TeneurNickel_mess" : "affichage ecran de la teneur en nickel (%)",
+ "TeneurPhosphore" : "teneur en phosphore (%)",
+ "TeneurPhosphore_mess" : "affichage ecran de la teneur en phosphore (%)",
+ "MoyenneRTndt" : "moyenne de la RTNDT initiale : virole C1 de cuve Chinon : mdb=>-17.degC et js=>42.degC (HT-56/05/038 : p.52)",
+ "MoyenneRTndt_mess" : "affichage ecran de la moyenne de la RTNDT initiale",
+ "CoefVariationRTndt" : "coef de variation de la RTNDT initiale",
+ "CoefVariationRTndt_mess" : "affichage ecran du coef de variation de la RTNDT initiale",
+ "EcartTypeRTndt" : "pour modeles USNRCsoud ou USNRCmdb, ecart-type du decalage de RTNDT (°F) (28. pour js et 17. pour mdb)",
+ "EcartTypeRTndt_mess" : "affichage ecran, pour modeles USNRCsoud ou USNRCmdb, ecart-type du decalage de RTNDT (°F) (28. pour js et 17. pour mdb)",
+ "NombreEcartTypeRTndt" : "Nbre d ecart-type par rapport a la moyenne de DRTNDT si analyse PROBABILISTE (en DETERMINISTE, fixer a 2.)",
+ "NombreEcartTypeRTndt_mess" : "affichage ecran du nbre d ecart-type par rapport a la moyenne de DRTNDT si analyse PROBABILISTE",
+ "ModeleTenacite" : "modele de tenacite : {RCC-M, RCC-M_pal, RCC-M_exp, RCC-M_simpl, Houssin_RC, Wallin, REME, ORNL, Frama, WEIB3, WEIB2, LOGWOLF, WEIB-GEN}",
+ "NombreCaracteristique" : "Nb caracteristique : ORDRE ou QUANTILE",
+ "NbEcartType_MoyKIc" : "Nbre d ecart-type par rapport a la moyenne de KIc si analyse PROBABILISTE (en DETERMINISTE, fixer a -2.)",
+ "NbEcartType_MoyKIc_mess" : "affichage ecran du nbre d ecart-type par rapport a la moyenne de KIc si analyse PROBABILISTE",
+ "PalierDuctile_KIc" : "palier deterministe de K1c (MPa(m^0.5))",
+ "CoefficientVariation_KIc" : "coef de variation de la loi normale de K1c",
+ "Fractile_KIc" : "valeur caracteristique de KIc exprimee en ordre de fractile (%)",
+ "Fractile_KIc_mess" : "affichage ecran de la valeur caracteristique de KIc exprimee en ordre de fractile (%)",
+ "Temperature_KIc100" : "parametre T0 du modele Wallin (degC)",
+ "A1" : "coef des coefs d une WEIBULL generale",
+ "A2" : "",
+ "A3" : "",
+ "B1" : "",
+ "B2" : "",
+ "B3" : "",
+ "C1" : "",
+ "C2" : "",
+ "C3" : "",
+ "ChoixCorrectionLongueur" : "Activation ou non de la correction de longueur {OUI ; NON}",
+ "AttnCorrBeta" : "Attenuation de la correction plastique : {OUI, NON} ==> uniquement pour DSR ou DECALE",
+ "CorrIrwin" : "Correction plastique IRWIN : {OUI, NON} ==> uniquement pour DEBOUCHANT",
+ "ArretDeFissure" : "prise en compte de l arret de fissure {OUI, NON} (en PROBABILISTE, fixer a NON)",
+ "IncrementTailleFissure" : "increment de la taille de fissure (m)",
+ "IncrementTailleFissure_mess" : "affichage ecran de l increment de la taille de fissure (m)",
+ "NbEcartType_MoyKIa" : "Nbre d ecart-type par rapport a la moyenne de KIa (nb sigma)",
+ "PalierDuctile_KIa" : "palier deterministe de K1a quand modele RCC-M (MPa(m^0.5))",
+ "CoefficientVariation_KIa" : "coef de variation de la loi normale de K1a",
+ "ChoixCoefficientChargement" : "prise en compte de coefficients sur le chargement (OUI/NON)",
+ "CoefficientDuctile" : "coefficient multiplicateur pour rupture ductile",
+ "CoefficientFragile" : "coefficient multiplicateur pour rupture fragile",
+ "InstantInitialisation" : "instant initial (s)",
+ "ConditionLimiteThermiqueREV" : "Option 'ENTHALPIE' ou 'CHALEUR'",
+ "TemperatureDeformationNulleREV" : "temperature de deformation nulle (degC)",
+ "TemperaturePourCoefDilatThermREV" : "temperature de definition du coefficient de dilatation thermique (degC)",
+ "CoefficientPoissonREV" : "coefficient de Poisson",
+ "ConditionLimiteThermiqueMDB" : "Option 'ENTHALPIE' ou 'CHALEUR'",
+ "TemperatureDeformationNulleMDB" : "temperature de deformation nulle (degC)",
+ "TemperaturePourCoefDilatThermMDB" : "temperature de definition du coefficient de dilatation thermique (degC)",
+ "CoefficientPoissonMDB" : "coefficient de Poisson",
+ "TypeConditionLimiteThermique" : "Type de condition thermique en paroi interne {TEMP_IMPO,FLUX_REP,ECHANGE,DEBIT,TEMP_FLU,APRP}",
+ "Instant_1" : "Borne superieure de l intervalle de temps du 1er palier TACCU",
+ "Instant_2" : "Borne superieure de l intervalle de temps du 2nd palier T1",
+ "Instant_3" : "Borne superieure de l intervalle de temps du 3eme palier TIS",
+ "DebitAccumule" : "Debit accumule (en m3/h)",
+ "DebitInjectionSecurite" : "Debit injection de securite (en m3/h)",
+ "TempInjectionSecurite" : "Temperature injection de securite (en degC)",
+ "TempInjectionSecurite_mess" : "affichage ecran de la temperature injection de securite",
+ "DiametreHydraulique" : "Diametre hydraulique (m)",
+ "DiametreHydraulique_mess" : "affichage ecran du diametre hydraulique (m)",
+ "SectionEspaceAnnulaire" : "Section espace annulaire (m2)",
+ "SectionEspaceAnnulaire_mess" : "affichage ecran de la section espace annulaire (m2)",
+ "HauteurCaracConvectionNaturelle" : "Hauteur caracteristique convection naturelle (m)",
+ "HauteurCaracConvectionNaturelle_mess" : "affichage ecran de la hauteur caracteristique convection naturelle (m)",
+ "CritereConvergenceRelative" : "Critere convergence relative (-)",
+ "CoefficientsVestale" : "Application des coefs de Vestale {OUI;NON}",
+ "VolumeMelange_CREARE" : "Transitoire de volume de melange CREARE (m3)",
+ "TemperatureInitiale_CREARE" : "Temperature initiale CREARE (degC)",
+ "TemperatureInitiale_CREARE_mess" : "affichage ecran de la temperature initiale CREARE (degC)",
+ "SurfaceEchange_FluideStructure" : "Surface d'echange fluide/structure (m2)",
+ "SurfaceEchange_FluideStructure_mess" : "affichage ecran de la surface d'echange fluide/structure (m2)",
+ "InstantPerteCirculationNaturelle" : "Instant de perte de circulation naturelle",
+ }
+
+ # Ce dictionnaire liste la valeur par defaut des variables utilisees dans le script
+ self.default = {
+ "NiveauImpression" : "1",
+ "FichierDataIn" : "NON",
+ "FichierTempSigma" : "NON",
+ "FichierCSV" : "NON",
+ "FichierRESTART" : "NON",
+ "FichierEXTR" : "NON",
+ "ChoixPlugin" : "NON",
+ "GrandeurEvaluee" : "FM_KICSURKCP",
+ "IncrementTemporel" : "1",
+ "IncrementMaxTemperature" : "0.1",
+ "ChoixExtractionTransitoires" : "NON",
+ "IncrementMaxTempsAffichage" : "1000.",
+ "traitementGeometrie" : "GEOMETRIE",
+ "RayonInterne" : "1.994",
+ "RayonInterne_mess" : "NON",
+ "RayonExterne" : "2.2015",
+ "RayonExterne_mess" : "NON",
+ "EpaisseurRevetement" : "0.0075",
+ "EpaisseurRevetement_mess" : "NON",
+ "LigamentExterneMin" : "0.75",
+ "LigamentExterneMin_mess" : "NON",
+ "NombreNoeudsMaillage" : "300",
+ "TypeInitial" : "DSR",
+ "Position" : "VIROLE",
+ "ProfondeurRadiale" : "0.006",
+ "ProfondeurRadiale_mess" : "NON",
+ "ModeCalculLongueur" : "VALEUR",
+ "Longueur" : "0.060",
+ "Longueur_mess" : "NON",
+ "CoefDirecteur" : "10.",
+ "CoefDirecteur_mess" : "NON",
+ "Constante" : "0.",
+ "ModeCalculDecalage" : "VALEUR",
+ "DecalageNormalise" : "0.1",
+ "DecalageNormalise_mess" : "NON",
+ "DecalageRadial" : "0.",
+ "DecalageRadial_mess" : "NON",
+ "Azimut" : "0.",
+ "Azimut_mess" : "NON",
+ "Altitude" : "-4.",
+ "Altitude_mess" : "NON",
+ "Pointe" : "B",
+ "ModeleFluence" : "Reglementaire",
+ "ZoneActiveCoeur_AltitudeSup" : "-3.536",
+ "ZoneActiveCoeur_AltitudeInf" : "-7.194",
+ "FluenceMax" : "6.5",
+ "KPFrance" : "12.7",
+ "KPUS" : "9.4488",
+ "Azimut_0deg" : "5.8",
+ "Azimut_5deg" : "5.48",
+ "Azimut_10deg" : "4.46",
+ "Azimut_15deg" : "3.41",
+ "Azimut_20deg" : "3.37",
+ "Azimut_25deg" : "3.16",
+ "Azimut_30deg" : "2.74",
+ "Azimut_35deg" : "2.25",
+ "Azimut_40deg" : "1.89",
+ "Azimut_45deg" : "1.78",
+ "TypeIrradiation" : "RTNDT",
+ "RTNDT" : "64.",
+ "ModeleIrradiation" : "HOUSSIN",
+ "TeneurCuivre" : "0.0972",
+ "TeneurCuivre_mess" : "NON",
+ "TeneurNickel" : "0.72",
+ "TeneurNickel_mess" : "NON",
+ "TeneurPhosphore" : "0.00912",
+ "TeneurPhosphore_mess" : "NON",
+ "MoyenneRTndt" : "-12.0",
+ "MoyenneRTndt_mess" : "NON",
+ "CoefVariationRTndt" : "0.1",
+ "CoefVariationRTndt_mess" : "NON",
+ "EcartTypeRTndt" : "-2.",
+ "EcartTypeRTndt_mess" : "NON",
+ "NombreEcartTypeRTndt" : "2.",
+ "NombreEcartTypeRTndt_mess" : "NON",
+ "ModeleTenacite" : "RCC-M",
+ "NombreCaracteristique" : "Quantile",
+ "NbEcartType_MoyKIc" : "-2.",
+ "NbEcartType_MoyKIc_mess" : "NON",
+ "PalierDuctile_KIc" : "195.",
+ "CoefficientVariation_KIc" : "0.15",
+ "Fractile_KIc" : "5.",
+ "Fractile_KIc_mess" : "NON",
+ "Temperature_KIc100" : "-27.",
+ "A1" : "21.263",
+ "A2" : "9.159",
+ "A3" : "0.04057",
+ "B1" : "17.153",
+ "B2" : "55.089",
+ "B3" : "0.0144",
+ "C1" : "4.",
+ "C2" : "0.",
+ "C3" : "0.",
+ "ChoixCorrectionLongueur" : "OUI",
+ "AttnCorrBeta" : "NON",
+ "CorrIrwin" : "NON",
+ "ArretDeFissure" : "NON",
+ "IncrementTailleFissure" : "0.",
+ "IncrementTailleFissure_mess" : "NON",
+ "NbEcartType_MoyKIa" : "0.",
+ "PalierDuctile_KIa" : "0.",
+ "CoefficientVariation_KIa" : "0.",
+ "ChoixCoefficientChargement" : "NON",
+ "CoefficientDuctile" : "1.0",
+ "CoefficientFragile" : "1.0",
+ "InstantInitialisation" : "-1.",
+ "ConditionLimiteThermiqueREV" : "CHALEUR",
+ "TemperatureDeformationNulleREV" : "20.",
+ "TemperaturePourCoefDilatThermREV" : "287.",
+ "CoefficientPoissonREV" : "0.3",
+ "ConditionLimiteThermiqueMDB" : "CHALEUR",
+ "TemperatureDeformationNulleMDB" : "20.",
+ "TemperaturePourCoefDilatThermMDB" : "287.",
+ "CoefficientPoissonMDB" : "0.3",
+ "TypeConditionLimiteThermique" : "TEMP_IMPO",
+ "Instant_1" : "21.",
+ "Instant_2" : "45.",
+ "Instant_3" : "5870.",
+ "DebitAccumule" : "2.3",
+ "DebitInjectionSecurite" : "0.375",
+ "TempInjectionSecurite" : "9.",
+ "TempInjectionSecurite_mess" : "NON",
+ "DiametreHydraulique" : "0.3816",
+ "DiametreHydraulique_mess" : "NON",
+ "SectionEspaceAnnulaire" : "0.21712",
+ "SectionEspaceAnnulaire_mess" : "NON",
+ "HauteurCaracConvectionNaturelle" : "6.",
+ "HauteurCaracConvectionNaturelle_mess" : "NON",
+ "CritereConvergenceRelative" : "0.00001",
+ "CoefficientsVestale" : "NON",
+# "VolumeMelange_CREARE" : "14.9",
+ "TemperatureInitiale_CREARE" : "250.",
+ "TemperatureInitiale_CREARE_mess" : "NON",
+ "SurfaceEchange_FluideStructure" : "0.",
+ "SurfaceEchange_FluideStructure_mess" : "NON",
+ "InstantPerteCirculationNaturelle" : "400.",
+ }
+
+ # Ce dictionnaire liste la rubrique d'appartenance des variables utilisees dans le script
+ self.bloc = {
+ "NiveauImpression" : "OPTIONS",
+ "FichierDataIn" : "OPTIONS",
+ "FichierTempSigma" : "OPTIONS",
+ "FichierCSV" : "OPTIONS",
+ "FichierRESTART" : "OPTIONS",
+ "FichierEXTR" : "OPTIONS",
+ "ChoixPlugin" : "OPTIONS",
+ "GrandeurEvaluee" : "OPTIONS",
+ "IncrementTemporel" : "OPTIONS",
+ "IncrementMaxTemperature" : "OPTIONS",
+ "ChoixExtractionTransitoires" : "OPTIONS",
+ "IncrementMaxTempsAffichage" : "OPTIONS",
+ "traitementGeometrie" : "DONNEES DE LA CUVE",
+ "RayonInterne" : "DONNEES DE LA CUVE",
+ "RayonInterne_mess" : "DONNEES DE LA CUVE",
+ "RayonExterne" : "DONNEES DE LA CUVE",
+ "RayonExterne_mess" : "DONNEES DE LA CUVE",
+ "EpaisseurRevetement" : "DONNEES DE LA CUVE",
+ "EpaisseurRevetement_mess" : "DONNEES DE LA CUVE",
+ "LigamentExterneMin" : "DONNEES DE LA CUVE",
+ "LigamentExterneMin_mess" : "DONNEES DE LA CUVE",
+ "NombreNoeudsMaillage" : "DONNEES DE LA CUVE",
+ "TypeInitial" : "CARACTERISTIQUES DU DEFAUT",
+ "Orientation" : "CARACTERISTIQUES DU DEFAUT",
+ "Position" : "CARACTERISTIQUES DU DEFAUT",
+ "ProfondeurRadiale" : "CARACTERISTIQUES DU DEFAUT",
+ "ProfondeurRadiale_mess" : "CARACTERISTIQUES DU DEFAUT",
+ "ModeCalculLongueur" : "CARACTERISTIQUES DU DEFAUT",
+ "Longueur" : "CARACTERISTIQUES DU DEFAUT",
+ "Longueur_mess" : "CARACTERISTIQUES DU DEFAUT",
+ "CoefDirecteur" : "CARACTERISTIQUES DU DEFAUT",
+ "CoefDirecteur_mess" : "CARACTERISTIQUES DU DEFAUT",
+ "Constante" : "CARACTERISTIQUES DU DEFAUT",
+ "ModeCalculDecalage" : "CARACTERISTIQUES DU DEFAUT",
+ "DecalageNormalise" : "CARACTERISTIQUES DU DEFAUT",
+ "DecalageNormalise_mess" : "CARACTERISTIQUES DU DEFAUT",
+ "DecalageRadial" : "CARACTERISTIQUES DU DEFAUT",
+ "DecalageRadial_mess" : "CARACTERISTIQUES DU DEFAUT",
+ "Azimut" : "CARACTERISTIQUES DU DEFAUT",
+ "Azimut_mess" : "CARACTERISTIQUES DU DEFAUT",
+ "Altitude" : "CARACTERISTIQUES DU DEFAUT",
+ "Altitude_mess" : "CARACTERISTIQUES DU DEFAUT",
+ "Pointe" : "CARACTERISTIQUES DU DEFAUT",
+ "ModeleFluence" : "MODELES",
+ "ZoneActiveCoeur_AltitudeSup" : "MODELES",
+ "ZoneActiveCoeur_AltitudeInf" : "MODELES",
+ "FluenceMax" : "MODELES",
+ "KPFrance" : "MODELES",
+ "KPUS" : "MODELES",
+ "Azimut_0deg" : "MODELES",
+ "Azimut_5deg" : "MODELES",
+ "Azimut_10deg" : "MODELES",
+ "Azimut_15deg" : "MODELES",
+ "Azimut_20deg" : "MODELES",
+ "Azimut_25deg" : "MODELES",
+ "Azimut_30deg" : "MODELES",
+ "Azimut_35deg" : "MODELES",
+ "Azimut_40deg" : "MODELES",
+ "Azimut_45deg" : "MODELES",
+ "TypeIrradiation" : "MODELES",
+ "RTNDT" : "MODELES",
+ "ModeleIrradiation" : "MODELES",
+ "TeneurCuivre" : "MODELES",
+ "TeneurCuivre_mess" : "MODELES",
+ "TeneurNickel" : "MODELES",
+ "TeneurNickel_mess" : "MODELES",
+ "TeneurPhosphore" : "MODELES",
+ "TeneurPhosphore_mess" : "MODELES",
+ "MoyenneRTndt" : "MODELES",
+ "MoyenneRTndt_mess" : "MODELES",
+ "CoefVariationRTndt" : "MODELES",
+ "CoefVariationRTndt_mess" : "MODELES",
+ "EcartTypeRTndt" : "MODELES",
+ "EcartTypeRTndt_mess" : "MODELES",
+ "NombreEcartTypeRTndt" : "MODELES",
+ "NombreEcartTypeRTndt_mess" : "MODELES",
+ "ModeleTenacite" : "MODELES",
+ "NombreCaracteristique" : "MODELES",
+ "NbEcartType_MoyKIc" : "MODELES",
+ "NbEcartType_MoyKIc_mess" : "MODELES",
+ "PalierDuctile_KIc" : "MODELES",
+ "CoefficientVariation_KIc" : "MODELES",
+ "Fractile_KIc" : "MODELES",
+ "Fractile_KIc_mess" : "MODELES",
+ "Temperature_KIc100" : "MODELES",
+ "A1" : "MODELES",
+ "A2" : "MODELES",
+ "A3" : "MODELES",
+ "B1" : "MODELES",
+ "B2" : "MODELES",
+ "B3" : "MODELES",
+ "C1" : "MODELES",
+ "C2" : "MODELES",
+ "C3" : "MODELES",
+ "ChoixCorrectionLongueur" : "MODELES",
+ "AttnCorrBeta" : "MODELES",
+ "CorrIrwin" : "MODELES",
+ "ArretDeFissure" : "MODELES",
+ "IncrementTailleFissure" : "MODELES",
+ "IncrementTailleFissure_mess" : "MODELES",
+ "NbEcartType_MoyKIa" : "MODELES",
+ "PalierDuctile_KIa" : "MODELES",
+ "CoefficientVariation_KIa" : "MODELES",
+ "ChoixCoefficientChargement" : "ETAT INITIAL",
+ "CoefficientDuctile" : "ETAT INITIAL",
+ "CoefficientFragile" : "ETAT INITIAL",
+ "InstantInitialisation" : "ETAT INITIAL",
+ "ConditionLimiteThermiqueREV" : "CARACTERISTIQUES DU REVETEMENT",
+ "TemperatureDeformationNulleREV" : "CARACTERISTIQUES DU REVETEMENT",
+ "TemperaturePourCoefDilatThermREV" : "CARACTERISTIQUES DU REVETEMENT",
+ "CoefficientPoissonREV" : "CARACTERISTIQUES DU REVETEMENT",
+ "ConditionLimiteThermiqueMDB" : "CARACTERISTIQUES DU MDB",
+ "TemperatureDeformationNulleMDB" : "CARACTERISTIQUES DU MDB",
+ "TemperaturePourCoefDilatThermMDB" : "CARACTERISTIQUES DU MDB",
+ "CoefficientPoissonMDB" : "CARACTERISTIQUES DU MDB",
+ "TypeConditionLimiteThermique" : "TRANSITOIRE",
+ "Instant_1" : "TRANSITOIRE",
+ "Instant_2" : "TRANSITOIRE",
+ "Instant_3" : "TRANSITOIRE",
+ "DebitAccumule" : "TRANSITOIRE",
+ "DebitInjectionSecurite" : "TRANSITOIRE",
+ "TempInjectionSecurite" : "TRANSITOIRE",
+ "TempInjectionSecurite_mess" : "TRANSITOIRE",
+ "DiametreHydraulique" : "TRANSITOIRE",
+ "DiametreHydraulique_mess" : "TRANSITOIRE",
+ "SectionEspaceAnnulaire" : "TRANSITOIRE",
+ "SectionEspaceAnnulaire_mess" : "TRANSITOIRE",
+ "HauteurCaracConvectionNaturelle" : "TRANSITOIRE",
+ "HauteurCaracConvectionNaturelle_mess" : "TRANSITOIRE",
+ "CritereConvergenceRelative" : "TRANSITOIRE",
+ "CoefficientsVestale" : "TRANSITOIRE",
+ "VolumeMelange_CREARE" : "TRANSITOIRE",
+ "TemperatureInitiale_CREARE" : "TRANSITOIRE",
+ "TemperatureInitiale_CREARE_mess" : "TRANSITOIRE",
+ "SurfaceEchange_FluideStructure" : "TRANSITOIRE",
+ "SurfaceEchange_FluideStructure_mess" : "TRANSITOIRE",
+ "InstantPerteCirculationNaturelle" : "TRANSITOIRE",
+ }
+
+ def gener(self,obj,format='brut'):
+ self.text=''
+ self.textCuve=''
+ self.texteTFDEBIT=''
+ self.dico_mot={}
+ self.dico_genea={}
+ self.text=PythonGenerator.gener(self,obj,format)
+ return self.text
+
+ def generMCSIMP(self,obj) :
+ self.dico_mot[obj.nom]=obj.valeur
+ clef=""
+ for i in obj.getGenealogie() :
+ clef=clef+"_"+i
+ self.dico_genea[clef]=obj.valeur
+ s=PythonGenerator.generMCSIMP(self,obj)
+ return s
+
+ def writeCuve2DG(self, filename, file2):
+ print "je passe dans writeCuve2DG"
+ self.genereTexteCuve()
+ f = open( filename, 'wb')
+ print self.texteCuve
+ f.write( self.texteCuve )
+ f.close()
+ ftmp = open( "/tmp/data_template", 'wb')
+ ftmp.write( self.texteCuve )
+ ftmp.close()
+
+ self.genereTexteTFDEBIT()
+ f2 = open( file2, 'wb')
+ print self.texteTFDEBIT
+ f2.write( self.texteTFDEBIT )
+ f2.close()
+
+
+ def entete(self):
+ '''
+ Ecrit l'entete du fichier data_template
+ '''
+ texte = "############################################################################################"+"\n"
+ texte += "#"+"\n"
+ texte += "# OUTIL D'ANALYSE PROBABILISTE DE LA DUREE DE VIE DES CUVES REP"+"\n"
+ texte += "# ---------------"+"\n"
+ texte += "# FICHIER DE MISE EN DONNEES"+"\n"
+ texte += "#"+"\n"
+ texte += "# SI CALCUL DETERMINISTE :"+"\n"
+ texte += "# - fixer INCRTPS=1, nbectDRTNDT=2., nbectKIc=-2."+"\n"
+ texte += "# - les calculs ne sont possibles qu'en une seule pointe du defaut (POINDEF<>BOTH)"+"\n"
+ texte += "# SI CALCUL PROBABILISTE :"+"\n"
+ texte += "# - fixer ARRETFISSURE=NON"+"\n"
+ texte += "#"+"\n"
+ texte += "############################################################################################"+"\n"
+ texte += "#"+"\n"
+ return texte
+
+ def rubrique(self, titre):
+ '''
+ Rubrique
+ '''
+ texte = "#"+"\n"
+ texte += "############################################################################################"+"\n"
+ texte += "# " + titre + "\n"
+ texte += "############################################################################################"+"\n"
+ texte += "#"+"\n"
+ return texte
+
+ def sousRubrique(self, soustitre, numtitre):
+ '''
+ Sous-rubrique
+ '''
+ texte = "#"+"\n"
+ texte += "# " + numtitre + soustitre + "\n"
+ texte += "#==========================================================================================="+"\n"
+ texte += "#"+"\n"
+ return texte
+
+ def ecritLigne(self, variablelue):
+ '''
+ Ecrit l'affectation d'une valeur a sa variable, suivie d'un commentaire
+ '''
+ texte = "%s = %s # %s\n" % (self.variable[variablelue], str(self.dico_mot[variablelue]), self.comment[variablelue])
+ return texte
+
+ def affecteValeurDefaut(self, variablelue):
+ '''
+ Affecte une valeur par defaut a une variable, suivie d'un commentaire
+ '''
+ print "Warning ==> Dans la rubrique",self.bloc[variablelue],", valeur par defaut pour ",variablelue," = ",self.default[variablelue]
+ texte = "%s = %s # %s\n" % (self.variable[variablelue], self.default[variablelue], self.comment[variablelue])
+ return texte
+
+ def affecteValeur(self, variablelue, valeuraffectee):
+ '''
+ Affecte une valeur a une variable, suivie d'un commentaire
+ '''
+ texte = "%s = %s # %s\n" % (self.variable[variablelue], valeuraffectee, self.comment[variablelue])
+ return texte
+
+ def ecritVariable(self, variablelue):
+ if self.dico_mot.has_key(variablelue):
+ texte = self.ecritLigne(variablelue)
+ else :
+ texte = self.affecteValeurDefaut(variablelue)
+ return texte
+
+ def amontAval(self, amont, aval):
+ if str(self.dico_mot[amont])=='Continu':
+ if str(self.dico_mot[aval])=='Continu':
+ texte = 'CC'+"\n"
+ if str(self.dico_mot[aval])=='Lineaire':
+ texte = 'CL'+"\n"
+ if str(self.dico_mot[aval])=='Exclu':
+ texte = 'CE'+"\n"
+ if str(self.dico_mot[amont])=='Lineaire':
+ if str(self.dico_mot[aval])=='Continu':
+ texte = 'LC'+"\n"
+ if str(self.dico_mot[aval])=='Lineaire':
+ texte = 'LL'+"\n"
+ if str(self.dico_mot[aval])=='Exclu':
+ texte = 'LE'+"\n"
+ if str(self.dico_mot[amont])=='Exclu':
+ if str(self.dico_mot[aval])=='Continu':
+ texte = 'EC'+"\n"
+ if str(self.dico_mot[aval])=='Lineaire':
+ texte = 'EL'+"\n"
+ if str(self.dico_mot[aval])=='Exclu':
+ texte = 'EE'+"\n"
+ return texte
+
+ def genereTexteCuve(self):
+ self.texteCuve = ""
+ self.texteCuve += self.entete()
+
+ # Rubrique OPTIONS
+ self.texteCuve += self.rubrique('OPTIONS')
+
+ self.texteCuve += self.sousRubrique('Impression a l ecran', '')
+ if self.dico_mot.has_key('NiveauImpression'):
+ self.texteCuve += self.affecteValeur('NiveauImpression', self.valeurproposee[str(self.dico_mot["NiveauImpression"])])
+
+ self.texteCuve += self.sousRubrique('Generation de fichiers', '')
+ self.texteCuve += self.ecritVariable('FichierDataIn')
+ self.texteCuve += self.ecritVariable('FichierTempSigma')
+ self.texteCuve += self.ecritVariable('FichierCSV')
+ self.texteCuve += self.ecritVariable('FichierRESTART')
+ self.texteCuve += self.ecritVariable('FichierEXTR')
+ self.texteCuve += self.ecritVariable('ChoixPlugin')
+
+ self.texteCuve += self.sousRubrique('Grandeur evaluee', '')
+ if self.dico_mot.has_key('GrandeurEvaluee'):
+ self.texteCuve += self.affecteValeur('GrandeurEvaluee', self.valeurproposee[str(self.dico_mot["GrandeurEvaluee"])])
+
+ self.texteCuve += self.sousRubrique('Divers', '')
+ self.texteCuve += self.ecritVariable('IncrementTemporel')
+ self.texteCuve += self.ecritVariable('IncrementMaxTemperature')
+
+ #self.texteCuve += self.ecritVariable('ChoixExtractionTransitoires')
+ if self.dico_mot.has_key('ChoixExtractionTransitoires'):
+ self.texteCuve += self.ecritVariable('ChoixExtractionTransitoires')
+ if str(self.dico_mot["ChoixExtractionTransitoires"])=='OUI':
+ if self.dico_mot.has_key('ListeAbscisses'):
+ self.texteCuve += "# liste des abscisses pour ecriture des transitoires de T et SIG (5 ou moins)"+"\n"
+ self.imprime(1,(self.dico_mot["ListeAbscisses"]))
+ self.texteCuve+="#"+"\n"
+ else :
+ print "Warning ==> Dans la rubrique OPTIONS, fournir ListeAbscisses."
+ self.texteCuve += "# liste des abscisses pour ecriture des transitoires de T et SIG (5 ou moins)"+"\n"
+ self.texteCuve += " 1.994\n"
+ self.texteCuve += " 2.000\n"
+ self.texteCuve+="#"+"\n"
+ else :
+ self.texteCuve+="#"+"\n"
+
+ self.texteCuve += self.ecritVariable('IncrementMaxTempsAffichage')
+ if self.dico_mot.has_key('ListeInstants'):
+ self.texteCuve += "# liste des instants pour ecriture des resultats (s)"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ self.imprime(1,(self.dico_mot["ListeInstants"]))
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ self.texteCuve+="#"+"\n"
+ else :
+ print "Warning ==> Dans la rubrique OPTIONS, fournir ListeInstants."
+ self.texteCuve += "# liste des instants pour ecriture des resultats (s)"+"\n"
+ self.texteCuve += " 0.\n"
+ self.texteCuve += " 1.\n"
+ self.texteCuve+="#"+"\n"
+
+
+ # Rubrique DONNEES DE LA CUVE
+ self.texteCuve += self.rubrique('DONNEES DE LA CUVE')
+ if self.dico_mot.has_key('traitementGeometrie'):
+ self.texteCuve += self.affecteValeur('traitementGeometrie', self.valeurproposee[str(self.dico_mot["traitementGeometrie"])])
+ if str(self.dico_mot["traitementGeometrie"])=='Topologie':
+ self.texteCuve+="# - si MAILLAGE, fournir NBNO et liste des abscisses (m)"+"\n"
+ self.texteCuve+="# - si GEOMETRIE, fournir (RINT, RINT_MESSAGE),"+"\n"
+ self.texteCuve+="# (REXT, REXT_MESSAGE),"+"\n"
+ self.texteCuve+="# (LREV, LREV_MESSAGE),"+"\n"
+ self.texteCuve+="# (LIGMIN, LIGMIN_MESSAGE),"+"\n"
+ self.texteCuve+="# NBNO"+"\n"
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('RayonInterne')
+ self.texteCuve += self.ecritVariable('RayonInterne_mess')
+ self.texteCuve += self.ecritVariable('RayonExterne')
+ self.texteCuve += self.ecritVariable('RayonExterne_mess')
+ self.texteCuve += self.ecritVariable('EpaisseurRevetement')
+ self.texteCuve += self.ecritVariable('EpaisseurRevetement_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('LigamentExterneMin')
+ self.texteCuve += self.ecritVariable('LigamentExterneMin_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('NombreNoeudsMaillage')
+ if str(self.dico_mot["traitementGeometrie"])=='Maillage':
+ self.texteCuve+="# - si MAILLAGE, fournir NBNO et liste des abscisses (m)"+"\n"
+ self.texteCuve+="# - si GEOMETRIE, fournir (RINT, RINT_MESSAGE),"+"\n"
+ self.texteCuve+="# (REXT, REXT_MESSAGE),"+"\n"
+ self.texteCuve+="# (LREV, LREV_MESSAGE),"+"\n"
+ self.texteCuve+="# (LIGMIN, LIGMIN_MESSAGE),"+"\n"
+ self.texteCuve+="# NBNO"+"\n"
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('NombreNoeudsMaillage')
+ self.imprime(1,(self.dico_mot["ListeAbscisses"]))
+ else :
+ self.texteCuve += self.affecteValeurDefaut('traitementGeometrie')
+ self.texteCuve+="# - si MAILLAGE, fournir NBNO et liste des abscisses (m)"+"\n"
+ self.texteCuve+="# - si GEOMETRIE, fournir (RINT, RINT_MESSAGE),"+"\n"
+ self.texteCuve+="# (REXT, REXT_MESSAGE),"+"\n"
+ self.texteCuve+="# (LREV, LREV_MESSAGE),"+"\n"
+ self.texteCuve+="# (LIGMIN, LIGMIN_MESSAGE),"+"\n"
+ self.texteCuve+="# NBNO"+"\n"
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.affecteValeurDefaut('RayonInterne')
+ self.texteCuve += self.affecteValeurDefaut('RayonInterne_mess')
+ self.texteCuve += self.affecteValeurDefaut('RayonExterne')
+ self.texteCuve += self.affecteValeurDefaut('RayonExterne_mess')
+ self.texteCuve += self.affecteValeurDefaut('EpaisseurRevetement')
+ self.texteCuve += self.affecteValeurDefaut('EpaisseurRevetement_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.affecteValeurDefaut('LigamentExterneMin')
+ self.texteCuve += self.affecteValeurDefaut('LigamentExterneMin_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.affecteValeurDefaut('NombreNoeudsMaillage')
+
+
+ # Rubrique CARACTERISTIQUES DU DEFAUT
+ self.texteCuve += self.rubrique('CARACTERISTIQUES DU DEFAUT')
+
+ if self.dico_mot.has_key('TypeInitial'):
+ self.texteCuve += self.affecteValeur('TypeInitial', self.valeurproposee[str(self.dico_mot["TypeInitial"])])
+ else :
+ self.texteCuve += self.affecteValeurDefaut('TypeInitial')
+
+ self.texteCuve+="# Fournir ORIEDEF, (PROFDEF, PROFDEF_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si DSR, fournir OPTLONG, (LONGDEF,LONGDEF_MESSAGE) ou (PROFSURLONG,PROFSURLONG_MESSAGE,LONGCONST)"+"\n"
+ self.texteCuve+="# - Si DECALE, fournir OPTLONG, (LONGDEF,LONGDEF_MESSAGE) ou (PROFSURLONG,PROFSURLONG_MESSAGE,LONGCONST), DECATYP, (DECANOR,DECANOR_MESSAGE) ou (DECADEF,DECADEF_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si DEBOUCHANT, fournir IRWIN"+"\n"
+ self.texteCuve+="# Fournir (ANGLDEF, ANGLDEF_MESSAGE), (ALTIDEF, ALTIDEF_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si DSR ou DECALE, fournir POINDEF"+"\n"
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Remarque :"+"\n"
+ self.texteCuve+="# - si DSR ou DECALE, dans la rubrique 'Modele de tenacite', fournir ATTNCORRBETA (ne pas fournir CORRIRWIN)"+"\n"
+ self.texteCuve+="# - si DEBOUCHANT, dans la rubrique 'Modele de tenacite', fournir CORRIRWIN (ne pas fournir ATTNCORRBETA)"+"\n"
+
+ self.texteCuve+="#"+"\n"
+
+ if self.dico_mot.has_key('Orientation'):
+ self.texteCuve += self.affecteValeur('Orientation', self.valeurproposee[str(self.dico_mot["Orientation"])])
+ else :
+ self.texteCuve += self.affecteValeurDefaut('Orientation')
+
+ if self.dico_mot.has_key('Position'):
+ self.texteCuve += self.affecteValeur('Position', self.valeurproposee[str(self.dico_mot["Position"])])
+ else :
+ self.texteCuve += self.affecteValeurDefaut('Position')
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('ProfondeurRadiale')
+ self.texteCuve += self.ecritVariable('ProfondeurRadiale_mess')
+
+ self.texteCuve+="#"+"\n"
+ if self.dico_mot.has_key('TypeInitial'):
+ if str(self.dico_mot["TypeInitial"])!='Defaut Debouchant':
+ if self.dico_mot.has_key('ModeCalculLongueur'):
+ self.texteCuve += self.affecteValeur('ModeCalculLongueur', self.valeurproposee[str(self.dico_mot["ModeCalculLongueur"])])
+ if str(self.dico_mot["ModeCalculLongueur"])=='Valeur':
+ self.texteCuve+="# - Si VALEUR, fournir (LONGDEF, LONGDEF_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si FCTAFFINE, fournir (PROFSURLONG, PROFSURLONG_MESSAGE) et LONGCONST : LONGDEF=PROFDEF/PROFSURLONG + LONGCONST"+"\n"
+ self.texteCuve += self.ecritVariable('Longueur')
+ self.texteCuve += self.ecritVariable('Longueur_mess')
+ if str(self.dico_mot["ModeCalculLongueur"])=='Fonction affine de la profondeur':
+ self.texteCuve+="# - Si VALEUR, fournir (LONGDEF, LONGDEF_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si FCTAFFINE, fournir (PROFSURLONG, PROFSURLONG_MESSAGE) et LONGCONST : LONGDEF=PROFDEF/PROFSURLONG + LONGCONST"+"\n"
+ self.texteCuve += self.ecritVariable('CoefDirecteur')
+ self.texteCuve += self.ecritVariable('CoefDirecteur_mess')
+ self.texteCuve += self.ecritVariable('Constante')
+ else :
+ self.texteCuve += self.affecteValeurDefaut('ModeCalculLongueur')
+ self.texteCuve+="# - Si VALEUR, fournir (LONGDEF, LONGDEF_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si FCTAFFINE, fournir (PROFSURLONG, PROFSURLONG_MESSAGE) et LONGCONST : LONGDEF=PROFDEF/PROFSURLONG + LONGCONST"+"\n"
+ self.texteCuve += self.affecteValeurDefaut('Longueur')
+ self.texteCuve += self.affecteValeurDefaut('Longueur_mess')
+
+ if self.dico_mot.has_key('TypeInitial'):
+ if str(self.dico_mot["TypeInitial"])=='Defaut Decale':
+ self.texteCuve+="#"+"\n"
+ if self.dico_mot.has_key('ModeCalculDecalage'):
+ self.texteCuve += self.affecteValeur('ModeCalculDecalage', self.valeurproposee[str(self.dico_mot["ModeCalculDecalage"])])
+ if str(self.dico_mot["ModeCalculDecalage"])=='Valeur normalisee':
+ self.texteCuve+="# - Si NORMALISE, fournir (DECANOR, DECANOR_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si VALEUR, fournir (DECADEF, DECADEF_MESSAGE)"+"\n"
+ self.texteCuve += self.ecritVariable('DecalageNormalise')
+ self.texteCuve += self.ecritVariable('DecalageNormalise_mess')
+ if str(self.dico_mot["ModeCalculDecalage"])=='Valeur':
+ self.texteCuve+="# - Si NORMALISE, fournir (DECANOR, DECANOR_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si VALEUR, fournir (DECADEF, DECADEF_MESSAGE)"+"\n"
+ self.texteCuve += self.ecritVariable('DecalageRadial')
+ self.texteCuve += self.ecritVariable('DecalageRadial_mess')
+ else :
+ self.texteCuve += self.affecteValeurDefaut('ModeCalculDecalage')
+ self.texteCuve+="# - Si NORMALISE, fournir (DECANOR, DECANOR_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si VALEUR, fournir (DECADEF, DECADEF_MESSAGE)"+"\n"
+ self.texteCuve += self.affecteValeurDefaut('DecalageRadial')
+ self.texteCuve += self.affecteValeurDefaut('DecalageRadial_mess')
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('Azimut')
+ self.texteCuve += self.ecritVariable('Azimut_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('Altitude')
+ self.texteCuve += self.ecritVariable('Altitude_mess')
+ self.texteCuve+="#"+"\n"
+ if self.dico_mot.has_key('Pointe'):
+ self.texteCuve += self.affecteValeur('Pointe', self.valeurproposee[str(self.dico_mot["Pointe"])])
+ #else :
+ # self.texteCuve += self.affecteValeurDefaut('Pointe')
+
+ # Rubrique MODELES FLUENCE, IRRADIATION, TENACITE
+ self.texteCuve += self.rubrique('MODELES FLUENCE, IRRADIATION, TENACITE')
+ self.texteCuve += self.sousRubrique('Modele d attenuation de la fluence dans l epaisseur','A.')
+
+ if self.dico_mot.has_key('ModeleFluence'):
+ self.texteCuve += self.affecteValeur('ModeleFluence', self.valeurproposee[str(self.dico_mot["ModeleFluence"])])
+ else :
+ self.texteCuve += self.affecteValeurDefaut('ModeleFluence')
+
+ self.texteCuve+="# - si France, fournir KPFRANCE"+"\n"
+ self.texteCuve+="# - si USNRC, fournir KPUS"+"\n"
+ self.texteCuve+="# - si modele GD_Cuve, fournir COEFFLUENCE1, COEFFLUENCE2, ..., COEFFLUENCE9, COEFFLUENCE10"+"\n"
+ self.texteCuve+="#"+"\n"
+
+ self.texteCuve += self.ecritVariable('ZoneActiveCoeur_AltitudeSup')
+ self.texteCuve += self.ecritVariable('ZoneActiveCoeur_AltitudeInf')
+ self.texteCuve += self.ecritVariable('FluenceMax')
+ if self.dico_mot.has_key('ModeleFluence'):
+ if str(self.dico_mot["ModeleFluence"])=='Exponentiel sans revetement k=12.7 (France)':
+ self.texteCuve += self.ecritVariable('KPFrance')
+ if str(self.dico_mot["ModeleFluence"])=='Regulatory Guide 1.99 rev 2 (USNRC)':
+ self.texteCuve += self.ecritVariable('KPUS')
+ if str(self.dico_mot["ModeleFluence"])=='Grand developpement (GD_Cuve)':
+ self.texteCuve += self.ecritVariable('Azimut_0deg')
+ self.texteCuve += self.ecritVariable('Azimut_5deg')
+ self.texteCuve += self.ecritVariable('Azimut_10deg')
+ self.texteCuve += self.ecritVariable('Azimut_15deg')
+ self.texteCuve += self.ecritVariable('Azimut_20deg')
+ self.texteCuve += self.ecritVariable('Azimut_25deg')
+ self.texteCuve += self.ecritVariable('Azimut_30deg')
+ self.texteCuve += self.ecritVariable('Azimut_35deg')
+ self.texteCuve += self.ecritVariable('Azimut_40deg')
+ self.texteCuve += self.ecritVariable('Azimut_45deg')
+
+ self.texteCuve += self.sousRubrique('Irradiation','B.')
+
+ if self.dico_mot.has_key('TypeIrradiation'):
+ self.texteCuve += self.affecteValeur('TypeIrradiation', self.valeurproposee[str(self.dico_mot["TypeIrradiation"])])
+
+ if str(self.dico_mot["TypeIrradiation"])=='RTndt de la cuve a l instant de l analyse':
+ self.texteCuve+="# - si RTNDT, fournir RTNDT"+"\n"
+ self.texteCuve+="# - si FLUENCE, fournir MODELIRR, et autres parametres selon MODELIRR (voir ci-dessous)"+"\n"
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('RTNDT')
+
+ if str(self.dico_mot["TypeIrradiation"])=='Modele d irradiation':
+ self.texteCuve+="# - si RTNDT, fournir RTNDT"+"\n"
+ self.texteCuve+="# - si FLUENCE, fournir MODELIRR, et autres parametres selon MODELIRR (voir ci-dessous)"+"\n"
+ self.texteCuve+="#"+"\n"
+ if self.dico_mot.has_key('ModeleIrradiation'):
+ self.texteCuve += self.affecteValeur('ModeleIrradiation', self.valeurproposee[str(self.dico_mot["ModeleIrradiation"])])
+ else :
+ self.texteCuve += self.affecteValeurDefaut('ModeleIrradiation')
+ self.texteCuve+="# - pour tout modele, fournir (CU, CU_MESSAGE),"+"\n"
+ self.texteCuve+="# (NI, NI_MESSAGE),"+"\n"
+ self.texteCuve+="# - si HOUSSIN, PERSOZ, LEFEBVRE, BRILLAUD, LEFEBnew, fournir (P, P_MESSAGE)"+"\n"
+ self.texteCuve+="# - pour tout modele, fournir (RTimoy, RTimoy_MESSAGE),"+"\n"
+ self.texteCuve+="# - si USNRCsoud ou USNRCmdb, fournir (RTicov, RTicov_MESSAGE)"+"\n"
+ self.texteCuve+="# (USectDRT, USectDRT_MESSAGE)"+"\n"
+ self.texteCuve+="# - pour tout modele, fournir (nbectDRTNDT, nbectDRTNDT_MESSAGE)"+"\n"
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('TeneurCuivre')
+ self.texteCuve += self.ecritVariable('TeneurCuivre_mess')
+ self.texteCuve += self.ecritVariable('TeneurNickel')
+ self.texteCuve += self.ecritVariable('TeneurNickel_mess')
+ if str(self.dico_mot["ModeleIrradiation"])=='Metal de Base : formule de FIM/FIS Houssin' or str(self.dico_mot["ModeleIrradiation"])=='Metal de Base : formule de FIM/FIS Persoz' or str(self.dico_mot["ModeleIrradiation"])=='Metal de Base : formule de FIM/FIS Lefebvre' or str(self.dico_mot["ModeleIrradiation"])=='Joint Soude : formulation de FIM/FIS Brillaud' or str(self.dico_mot["ModeleIrradiation"])=='Formule de FIM/FIS Lefebvre modifiee':
+ self.texteCuve += self.ecritVariable('TeneurPhosphore')
+ self.texteCuve += self.ecritVariable('TeneurPhosphore_mess')
+ self.texteCuve += self.ecritVariable('MoyenneRTndt')
+ self.texteCuve += self.ecritVariable('MoyenneRTndt_mess')
+ if str(self.dico_mot["ModeleIrradiation"])=='Metal de Base : Regulatory Guide 1.00 rev 2' or str(self.dico_mot["ModeleIrradiation"])=='Joint Soude : Regulatory Guide 1.00 rev 2':
+ self.texteCuve += self.ecritVariable('CoefVariationRTndt')
+ self.texteCuve += self.ecritVariable('CoefVariationRTndt_mess')
+ self.texteCuve += self.ecritVariable('EcartTypeRTndt')
+ self.texteCuve += self.ecritVariable('EcartTypeRTndt_mess')
+ self.texteCuve += self.ecritVariable('NombreEcartTypeRTndt')
+ self.texteCuve += self.ecritVariable('NombreEcartTypeRTndt_mess')
+ else :
+ self.texteCuve += self.affecteValeurDefaut('TypeIrradiation')
+ self.texteCuve+="# - si RTNDT, fournir RTNDT"+"\n"
+ self.texteCuve+="# - si FLUENCE, fournir MODELIRR, et autres parametres selon MODELIRR (voir ci-dessous)"+"\n"
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.affecteValeurDefaut('RTNDT')
+
+ self.texteCuve += self.sousRubrique('Modele de tenacite','C.')
+ self.texteCuve+="# tenacite d amorcage"+"\n"
+
+ if self.dico_mot.has_key('ModeleTenacite'):
+ self.texteCuve += self.affecteValeur('ModeleTenacite', self.valeurproposee[str(self.dico_mot["ModeleTenacite"])])
+ else :
+ self.texteCuve += self.affecteValeurDefaut('ModeleTenacite')
+ self.texteCuve+="# - si RCC-M, RCC-M_pal, Houssin_RC, fournir (nbectKIc, nbectKIc_MESSAGE), KICPAL, KICCDV"+"\n"
+ self.texteCuve+="# - si RCC-M_exp, fournir (nbectKIc, nbectKIc_MESSAGE), KICCDV"+"\n"
+ self.texteCuve+="# - si RCC-M_simpl, ne rien fournir"+"\n"
+ self.texteCuve+="# - si Frama, LOGWOLF, fournir (nbectKIc, nbectKIc_MESSAGE)"+"\n"
+ self.texteCuve+="# - si REME, ORNL, WEIB3, WEIB2, fournir NBCARAC, puis (nbectKIc, nbectKIc_MESSAGE) ou (fractKIc, fractKIc_MESSAGE) selon valeur de NBCARAC"+"\n"
+ self.texteCuve+="# - si Wallin, fournir NBCARAC, puis (nbectKIc, nbectKIc_MESSAGE) ou (fractKIc, fractKIc_MESSAGE) selon valeur de NBCARAC,"+"\n"
+ self.texteCuve+="# puis T0WALLIN"+"\n"
+ self.texteCuve+="# - si WEIB-GEN, fournir NBCARAC, puis (nbectKIc, nbectKIc_MESSAGE) ou (fractKIc, fractKIc_MESSAGE) selon valeur de NBCARAC,"+"\n"
+ self.texteCuve+="# puis A1, A2, A3, B1, B2, B3, C1, C2, C3"+"\n"
+ self.texteCuve+="# loi de Weibull P(K<x) = 1 - exp{-[ (x-a(T)) / b(T) ]^c(T) }"+"\n"
+ self.texteCuve+="# avec a(T) = A1 + A2*exp[A3*(T-RTNDT)]"+"\n"
+ self.texteCuve+="# b(T) = B1 + B2*exp[B3*(T-RTNDT)]"+"\n"
+ self.texteCuve+="# c(T) = C1 + C2*exp[C3*(T-RTNDT)]"+"\n"
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Correction de la longueur"+"\n"
+ self.texteCuve += self.ecritVariable('ChoixCorrectionLongueur')
+ self.texteCuve+="#"+"\n"
+ if self.dico_mot.has_key('ModeleTenacite'):
+ if str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve' or str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve (REME)' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb01 (etude ORNL)' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb03' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb02' or str(self.dico_mot["ModeleTenacite"])=='Weibull generalisee' :
+ if self.dico_mot.has_key('NombreCaracteristique'):
+ self.texteCuve += self.affecteValeur('NombreCaracteristique', self.valeurproposee[str(self.dico_mot["NombreCaracteristique"])])
+ else :
+ self.texteCuve += self.affecteValeurDefaut('NombreCaracteristique')
+ self.texteCuve+="# - Si NBCARAC = QUANTILE, fournir (nbectKIc, nbectKIc_MESSAGE)"+"\n"
+ self.texteCuve+="# - Si NBCARAC = ORDRE, fournir (fractKIc, fractKIc_MESSAGE)"+"\n"
+
+ if str(self.dico_mot["ModeleTenacite"])=='RCC-M/ASME coefficient=2' or str(self.dico_mot["ModeleTenacite"])=='RCC-M/ASME avec KI=KIpalier' or str(self.dico_mot["ModeleTenacite"])=='RCC-M/ASME coefficient=2.33 (Houssin)' :
+ self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc')
+ self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc_mess')
+ self.texteCuve += self.ecritVariable('PalierDuctile_KIc')
+ self.texteCuve += self.ecritVariable('CoefficientVariation_KIc')
+
+ if str(self.dico_mot["ModeleTenacite"])=='Exponentielle n\xb01 (Frama)' or str(self.dico_mot["ModeleTenacite"])=='Exponentielle n\xb02 (LOGWOLF)' :
+ self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc')
+ self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc_mess')
+
+ if str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve (REME)' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb01 (etude ORNL)' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb03' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb02' or str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve' or str(self.dico_mot["ModeleTenacite"])=='Weibull generalisee':
+ if str(self.dico_mot["NombreCaracteristique"])=='Quantile' :
+ self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc')
+ self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc_mess')
+ if str(self.dico_mot["NombreCaracteristique"])=='Ordre' :
+ self.texteCuve += self.ecritVariable('Fractile_KIc')
+ self.texteCuve += self.ecritVariable('Fractile_KIc_mess')
+
+ if str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve' :
+ self.texteCuve += self.ecritVariable('Temperature_KIc100')
+
+ if str(self.dico_mot["ModeleTenacite"])=='Weibull generalisee' :
+ self.texteCuve += self.ecritVariable('A1')
+ self.texteCuve += self.ecritVariable('A2')
+ self.texteCuve += self.ecritVariable('A3')
+ self.texteCuve += self.ecritVariable('B1')
+ self.texteCuve += self.ecritVariable('B2')
+ self.texteCuve += self.ecritVariable('B3')
+ self.texteCuve += self.ecritVariable('C1')
+ self.texteCuve += self.ecritVariable('C2')
+ self.texteCuve += self.ecritVariable('C3')
+ else :
+ self.texteCuve += self.affecteValeurDefaut('NbEcartType_MoyKIc')
+ self.texteCuve += self.affecteValeurDefaut('NbEcartType_MoyKIc_mess')
+ self.texteCuve += self.affecteValeurDefaut('PalierDuctile_KIc')
+ self.texteCuve += self.affecteValeurDefaut('CoefficientVariation_KIc')
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Correction plastique"+"\n"
+
+ #DTV if self.dico_mot.has_key('TypeInitial'):
+ #DTV if str(self.dico_mot["TypeInitial"])!='Defaut Debouchant':
+ if self.dico_mot.has_key('CorrectionPlastique'):
+ if str(self.dico_mot["CorrectionPlastique"])=='Correction plastique BETA (pour DSR et defaut decale)':
+ self.texteCuve += self.affecteValeur('AttnCorrBeta','NON')
+ if str(self.dico_mot["CorrectionPlastique"])=='Correction plastique BETA attenuee (pour DSR et defaut decale)':
+ self.texteCuve += self.affecteValeur('AttnCorrBeta','OUI')
+ if str(self.dico_mot["CorrectionPlastique"])=='Correction plastique IRWIN (pour defaut debouchant)':
+ self.texteCuve += self.affecteValeur('CorrIrwin','OUI')
+ else :
+ self.texteCuve += self.affecteValeurDefaut('AttnCorrBeta')
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Prise en compte de l'arret de fissure si DETERMINISTE"+"\n"
+
+ self.texteCuve += self.ecritVariable('ArretDeFissure')
+ self.texteCuve+="# - si ARRETFISSURE=OUI, fournir (INCRDEF, INCRDEF_MESSAGE), nbectKIa, KIAPAL, KIACDV"+"\n"
+ if self.dico_mot.has_key('ArretDeFissure'):
+ if str(self.dico_mot["ArretDeFissure"])=='OUI':
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('IncrementTailleFissure')
+ self.texteCuve += self.ecritVariable('IncrementTailleFissure_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Parametres pour le calcul de la tenacite a l arret"+"\n"
+ self.texteCuve += self.ecritVariable('NbEcartType_MoyKIa')
+ self.texteCuve += self.ecritVariable('PalierDuctile_KIa')
+ self.texteCuve += self.ecritVariable('CoefficientVariation_KIa')
+
+ # Rubrique Etat initial
+ self.texteCuve += self.rubrique('ETAT INITIAL')
+
+ self.texteCuve+="# Profil radial de la temperature initiale dans la cuve"+"\n"
+ self.texteCuve+="# abscisse (m) / temp initiale dans la cuve"+"\n"
+ self.texteCuve+="# Prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ if self.dico_mot.has_key('ProfilRadial_TemperatureInitiale'):
+ self.imprime(2,(self.dico_mot["ProfilRadial_TemperatureInitiale"]))
+ self.texteCuve += self.amontAval('Amont_TemperatureInitiale','Aval_TemperatureInitiale')
+ else :
+ self.texteCuve+=" 1.9940 287."+"\n"
+ self.texteCuve+="CC"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Profils radiaux des contraintes residuelles dans la cuve"+"\n"
+ self.texteCuve+="# abscisse (m) / sigma rr / sigma tt / sigma zz"+"\n"
+ self.texteCuve+="# Prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
+ if self.dico_mot.has_key('ProfilRadial_ContraintesInitiales'):
+ self.imprime(4,(self.dico_mot["ProfilRadial_ContraintesInitiales"]))
+ self.texteCuve += self.amontAval('Amont_ContraintesInitiales','Aval_ContraintesInitiales')
+ else :
+ self.texteCuve+="1.994 0. 0. 0."+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Prise en compte de coefficients sur les contraintes"+"\n"
+ self.texteCuve += self.ecritVariable('ChoixCoefficientChargement')
+ if str(self.dico_mot["ChoixCoefficientChargement"])=='OUI':
+ self.texteCuve += self.ecritVariable('CoefficientDuctile')
+ self.texteCuve += self.ecritVariable('CoefficientFragile')
+ else :
+ self.texteCuve+="#"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Instant initial"+"\n"
+ self.texteCuve += self.ecritVariable('InstantInitialisation')
+
+ # Rubrique CARACTERISTIQUES DU REVETEMENT
+ self.texteCuve += self.rubrique('CARACTERISTIQUES DU REVETEMENT')
+
+ if self.dico_mot.has_key('ConditionLimiteThermiqueREV'):
+ self.texteCuve += self.affecteValeur('ConditionLimiteThermiqueREV', self.valeurproposee[str(self.dico_mot["ConditionLimiteThermiqueREV"])])
+ else :
+ self.texteCuve += self.affecteValeurDefaut('ConditionLimiteThermiqueREV')
+ self.texteCuve+="# - si CHALEUR, fournir Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
+ self.texteCuve+="# - si ENTHALPIE, fournir Temperature (degC) / enthalpie (J/kg)"+"\n"
+ self.texteCuve+="# Finir chacune des listes par la prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
+ self.texteCuve+="#"+"\n"
+ if self.dico_mot.has_key('ChaleurREV_Fct_Temperature'):
+ self.texteCuve+="# Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
+ self.imprime(2,(self.dico_mot["ChaleurREV_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_ChaleurREV','Aval_ChaleurREV')
+ elif self.dico_mot.has_key('EnthalpieREV_Fct_Temperature'):
+ self.texteCuve+="# Temperature (degC) / enthalpie (J/kg)"+"\n"
+ self.imprime(2,(self.dico_mot["EnthalpieREV_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_EnthalpieREV','Aval_EnthalpieREV')
+ else :
+ self.texteCuve+="# Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
+ self.texteCuve+="0. 36.03E5 "+"\n"
+ self.texteCuve+="20. 36.03E5 "+"\n"
+ self.texteCuve+="200. 41.65E5 "+"\n"
+ self.texteCuve+="350. 43.47E5 "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Temperature (degC) / conductivite thermique (W/m/degC)"+"\n"
+ if self.dico_mot.has_key('ConductiviteREV_Fct_Temperature'):
+ self.imprime(2,(self.dico_mot["ConductiviteREV_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_ConductiviteREV','Aval_ConductiviteREV')
+ else :
+ self.texteCuve+="0. 14.7 "+"\n"
+ self.texteCuve+="20. 14.7 "+"\n"
+ self.texteCuve+="200. 17.2 "+"\n"
+ self.texteCuve+="350. 19.3 "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Temperature (degC) / module d'Young (MPa)"+"\n"
+ if self.dico_mot.has_key('ModuleYoungREV_Fct_Temperature'):
+ self.imprime(2,(self.dico_mot["ModuleYoungREV_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_ModuleYoungREV','Aval_ModuleYoungREV')
+ else :
+ self.texteCuve+="0. 198500. "+"\n"
+ self.texteCuve+="20. 197000. "+"\n"
+ self.texteCuve+="200. 184000. "+"\n"
+ self.texteCuve+="350. 172000. "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Temperature (degC) / coefficient de dilatation thermique (degC-1)"+"\n"
+ if self.dico_mot.has_key('CoeffDilatThermREV_Fct_Temperature'):
+ self.imprime(2,(self.dico_mot["CoeffDilatThermREV_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_CoeffDilatThermREV','Aval_CoeffDilatThermREV')
+ else :
+ self.texteCuve+="0. 16.40E-6 "+"\n"
+ self.texteCuve+="20. 16.40E-6 "+"\n"
+ self.texteCuve+="200. 17.20E-6 "+"\n"
+ self.texteCuve+="350. 17.77E-6 "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Temperature (degC) / limite d'elasticite (MPa)"+"\n"
+ if self.dico_mot.has_key('LimiteElasticiteREV_Fct_Temperature'):
+ self.imprime(2,(self.dico_mot["LimiteElasticiteREV_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_LimiteElasticiteREV','Aval_LimiteElasticiteREV')
+ else :
+ self.texteCuve+="0. 380. "+"\n"
+ self.texteCuve+="20. 370. "+"\n"
+ self.texteCuve+="100. 330. "+"\n"
+ self.texteCuve+="300. 270. "+"\n"
+ self.texteCuve+="LL"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('TemperatureDeformationNulleREV')
+ self.texteCuve += self.ecritVariable('TemperaturePourCoefDilatThermREV')
+ self.texteCuve += self.ecritVariable('CoefficientPoissonREV')
+
+ # Rubrique CARACTERISTIQUES DU METAL DE BASE
+ self.texteCuve += self.rubrique('CARACTERISTIQUES DU METAL DE BASE')
+
+ if self.dico_mot.has_key('ConditionLimiteThermiqueMDB'):
+ self.texteCuve += self.affecteValeur('ConditionLimiteThermiqueMDB', self.valeurproposee[str(self.dico_mot["ConditionLimiteThermiqueMDB"])])
+ else :
+ self.texteCuve += self.affecteValeurDefaut('ConditionLimiteThermiqueMDB')
+
+ self.texteCuve+="# - si CHALEUR, fournir Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
+ self.texteCuve+="# - si ENTHALPIE, fournir Temperature (degC) / enthalpie (J/kg)"+"\n"
+ self.texteCuve+="# Finir chacune des listes par la prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
+ self.texteCuve+="#"+"\n"
+
+ if self.dico_mot.has_key('ChaleurMDB_Fct_Temperature'):
+ self.texteCuve+="# Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
+ self.imprime(2,(self.dico_mot["ChaleurMDB_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_ChaleurMDB','Aval_ChaleurMDB')
+ elif self.dico_mot.has_key('EnthalpieMDB_Fct_Temperature'):
+ self.texteCuve+="# Temperature (degC) / enthalpie (J/kg)"+"\n"
+ self.imprime(2,(self.dico_mot["EnthalpieMDB_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_EnthalpieMDB','Aval_EnthalpieMDB')
+ else :
+ self.texteCuve+="# Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
+ self.texteCuve+="0. 34.88E+05 "+"\n"
+ self.texteCuve+="20. 34.88E+05 "+"\n"
+ self.texteCuve+="200. 40.87E+05 "+"\n"
+ self.texteCuve+="350. 46.02E+05 "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Temperature (degC) / conductivite thermique (W/m/degC)"+"\n"
+ if self.dico_mot.has_key('ConductiviteMDB_Fct_Temperature'):
+ self.imprime(2,(self.dico_mot["ConductiviteMDB_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_ConductiviteMDB','Aval_ConductiviteMDB')
+ else :
+ self.texteCuve+="0. 37.7 "+"\n"
+ self.texteCuve+="20. 37.7 "+"\n"
+ self.texteCuve+="200. 40.5 "+"\n"
+ self.texteCuve+="350. 38.7 "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Temperature (degC) / module d'Young (MPa)"+"\n"
+ if self.dico_mot.has_key('ModuleYoungMDB_Fct_Temperature'):
+ self.imprime(2,(self.dico_mot["ModuleYoungMDB_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Aval_ModuleYoungMDB','Aval_ModuleYoungMDB')
+ else :
+ self.texteCuve+="0. 205000. "+"\n"
+ self.texteCuve+="20. 204000. "+"\n"
+ self.texteCuve+="200. 193000. "+"\n"
+ self.texteCuve+="350. 180000. "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Temperature (degC) / coefficient de dilatation thermique (degC-1)"+"\n"
+ if self.dico_mot.has_key('CoeffDilatThermMDB_Fct_Temperature'):
+ self.imprime(2,(self.dico_mot["CoeffDilatThermMDB_Fct_Temperature"]))
+ self.texteCuve += self.amontAval('Amont_CoeffDilatThermMDB','Aval_CoeffDilatThermMDB')
+ else :
+ self.texteCuve+="0. 11.22E-6 "+"\n"
+ self.texteCuve+="20. 11.22E-6 "+"\n"
+ self.texteCuve+="200. 12.47E-6 "+"\n"
+ self.texteCuve+="350. 13.08E-6 "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('TemperatureDeformationNulleMDB')
+ self.texteCuve += self.ecritVariable('TemperaturePourCoefDilatThermMDB')
+ self.texteCuve += self.ecritVariable('CoefficientPoissonMDB')
+
+ # Rubrique CARACTERISTIQUES DU TRANSITOIRE MECANIQUE-THERMOHYDRAULIQUE
+ self.texteCuve += self.rubrique('CARACTERISTIQUES DU TRANSITOIRE MECANIQUE-THERMOHYDRAULIQUE')
+ self.texteCuve += self.sousRubrique('Chargement mecanique : transitoire de pression','')
+
+ self.texteCuve+="# instant (s) / pression (MPa)"+"\n"
+ self.texteCuve+="# Prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ if self.dico_mot.has_key('ProfilTemporel_Pression'):
+ self.imprime(2,(self.dico_mot["ProfilTemporel_Pression"]))
+ self.texteCuve += self.amontAval('Amont_Pression','Aval_Pression')
+ else :
+ self.texteCuve+="0. 15.5 "+"\n"
+ self.texteCuve+="20. 0.1 "+"\n"
+ self.texteCuve+="200. 0.1 "+"\n"
+ self.texteCuve+="1000. 0.1 "+"\n"
+ self.texteCuve+="CC"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+
+ self.texteCuve += self.sousRubrique('Chargement thermo-hydraulique','')
+ if self.dico_mot.has_key('TypeConditionLimiteThermique'):
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ self.texteCuve += self.affecteValeur('TypeConditionLimiteThermique', self.valeurproposee[str(self.dico_mot["TypeConditionLimiteThermique"])])
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ else :
+ self.texteCuve += self.affecteValeurDefaut('TypeConditionLimiteThermique')
+
+ self.texteCuve+="# - si TEMP_IMPO, fournir Instant (s) / Temperature imposee (degC)"+"\n"
+ self.texteCuve+="# - si FLUX_REP, fournir Instant (s) / Flux de chaleur impose (W/m2)"+"\n"
+ self.texteCuve+="# - si ECHANGE, fournir Instant (s) / Temperature impose (degC)"+"\n"
+ self.texteCuve+="# puis Instant (s) / Coefficient d echange (W/m2/K)"+"\n"
+ self.texteCuve+="# - si DEBIT, fournir Instant (s) / Debit massique (kg/s)"+"\n"
+ self.texteCuve+="# puis Instant (s) / Temperature d injection de securite (degC)"+"\n"
+ self.texteCuve+="# puis Modele VESTALE : (DH, DH_MESSAGE), (SECTION, SECTION_MESSAGE), (DELTA, DELTA_MESSAGE), EPS, COEFVESTALE"+"\n"
+ self.texteCuve+="# puis Modele CREARE : "+"\n"
+ self.texteCuve+="# Instants(s) / Volume de melange CREARE (m3)"+"\n"
+ self.texteCuve+="# puis (T0, T0_MESSAGE), (SE, SE_MESSAGE)"+"\n"
+ self.texteCuve+="# - si TEMP_FLU, fournir Instant (s) / Temperature du fluide (degC)"+"\n"
+ self.texteCuve+="# puis Instant (s) / Debit d injection de securite (kg/s)"+"\n"
+ self.texteCuve+="# puis Modele VESTALE : (DH, DH_MESSAGE), (SECTION, SECTION_MESSAGE), (DELTA, DELTA_MESSAGE), EPS, COEFVESTALE"+"\n"
+ self.texteCuve+="# - si TFDEBIT, fournir INST_PCN et TIS"+"\n"
+ self.texteCuve+="# fournir Instant (s) / Temperature du fluide (degC)"+"\n"
+ self.texteCuve+="# puis Instant (s) / Debit d injection de securite (kg/s)"+"\n"
+ self.texteCuve+="# puis Modele VESTALE : (DH, DH_MESSAGE), (SECTION, SECTION_MESSAGE), (DELTA, DELTA_MESSAGE), EPS, COEFVESTALE"+"\n"
+ self.texteCuve+="# puis Modele CREARE : "+"\n"
+ self.texteCuve+="# Instants(s) / Volume de melange CREARE (m3)"+"\n"
+ self.texteCuve+="# puis (T0, T0_MESSAGE), (SE, SE_MESSAGE)"+"\n"
+ self.texteCuve+="# - si APRP, fournir INSTANT1, INSTANT2, INSTANT3, QACCU, QIS, (TIS, TIS_MESSAGE)"+"\n"
+ self.texteCuve+="# puis Instant (s) / Temperature du fluide (degC) tel que dans l'exemple ci-dessous"+"\n"
+ self.texteCuve+="# 0. 286."+"\n"
+ self.texteCuve+="# 12. 20. # 1er palier à T=TACCU"+"\n"
+ self.texteCuve+="# 20. 20. # idem que ci-dessus : T=TACCU"+"\n"
+ self.texteCuve+="# 21. 999999. # 2nd palier à T=T1 : sera remplace par nouvelle valeur calculee par fonction idoine"+"\n"
+ self.texteCuve+="# 45. 999999. # idem que ci-dessus : T=T1"+"\n"
+ self.texteCuve+="# 46. 9. # 3eme palier à T=TIS, temperature d injection de securite : sa valeur est reactualisee avec la donnee de TIS ci-dessous"+"\n"
+ self.texteCuve+="# 1870. 9. # idem que ci-dessus : T=TIS"+"\n"
+ self.texteCuve+="# 1871. 80."+"\n"
+ self.texteCuve+="# 3871. 80."+"\n"
+ self.texteCuve+="# CC # C pour Constant, E pour Exclu, L pour Lineaire"+"\n"
+ self.texteCuve+="# puis Instant (s) / Debit d injection de securite (kg/s)"+"\n"
+ self.texteCuve+="# puis Modele VESTALE : (DH, DH_MESSAGE), (SECTION, SECTION_MESSAGE), (DELTA, DELTA_MESSAGE), EPS, COEFVESTALE"+"\n"
+ self.texteCuve+="# Finir chacune des listes par la prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
+ self.texteCuve+="#"+"\n"
+
+ if self.dico_mot.has_key('TypeConditionLimiteThermique'):
+
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ self.texteCuve += self.ecritVariable('InstantPerteCirculationNaturelle')
+ self.texteCuve += self.ecritVariable('TempInjectionSecurite')
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Courbe APRP':
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Definition de parametres pour le cas d un transitoire APRP"+"\n"
+ self.texteCuve += self.ecritVariable('Instant_1')
+ self.texteCuve += self.ecritVariable('Instant_2')
+ self.texteCuve += self.ecritVariable('Instant_3')
+ self.texteCuve += self.ecritVariable('DebitAccumule')
+ self.texteCuve += self.ecritVariable('DebitInjectionSecurite')
+ self.texteCuve += self.ecritVariable('TempInjectionSecurite')
+ self.texteCuve += self.ecritVariable('TempInjectionSecurite_mess')
+
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee en paroi' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et coefficient echange' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et debit d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Courbe APRP' :
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# instant (s) / temperature imposee du fluide (degC)"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ if self.dico_mot.has_key('ProfilTemporel_TemperatureImposeeFluide'):
+ self.imprime(2,(self.dico_mot["ProfilTemporel_TemperatureImposeeFluide"]))
+ self.texteCuve += self.amontAval('Amont_TemperatureImposeeFluide','Aval_TemperatureImposeeFluide')
+ else :
+ self.texteCuve+="0. 286. "+"\n"
+ self.texteCuve+="20. 20. "+"\n"
+ self.texteCuve+="200. 7. "+"\n"
+ self.texteCuve+="1000. 80. "+"\n"
+ self.texteCuve+="CC"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Flux de chaleur impose en paroi':
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# instant (s) / flux de chaleur impose (W/m2)"+"\n"
+ if self.dico_mot.has_key('ProfilTemporel_FluxChaleur'):
+ self.imprime(2,(self.dico_mot["ProfilTemporel_FluxChaleur"]))
+ self.texteCuve += self.amontAval('Amont_FluxChaleur','Aval_FluxChaleur')
+ self.texteCuve+="#"+"\n"
+ else :
+ self.texteCuve+="0. -0. "+"\n"
+ self.texteCuve+="20. -366290. "+"\n"
+ self.texteCuve+="200. -121076. "+"\n"
+ self.texteCuve+="1000. -56372."+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et debit d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Courbe APRP':
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# instant (s) / Debit d injection de securite (kg/s)"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ if self.dico_mot.has_key('ProfilTemporel_DebitInjection'):
+ self.imprime(2,(self.dico_mot["ProfilTemporel_DebitInjection"]))
+ self.texteCuve += self.amontAval('Amont_DebitInjection','Aval_DebitInjection')
+ else :
+ self.texteCuve+="0. 4590. "+"\n"
+ self.texteCuve+="20. 4590. "+"\n"
+ self.texteCuve+="200. 340. "+"\n"
+ self.texteCuve+="1000. 31.1 "+"\n"
+ self.texteCuve+="CC"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et coefficient echange' :
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# instant (s) / Coefficient d echange (W/m2/K)"+"\n"
+ if self.dico_mot.has_key('ProfilTemporel_CoefficientEchange'):
+ self.imprime(2,(self.dico_mot["ProfilTemporel_CoefficientEchange"]))
+ self.texteCuve += self.amontAval('Amont_CoefficientEchange','Aval_CoefficientEchange')
+ else :
+ self.texteCuve+="0. 138454. "+"\n"
+ self.texteCuve+="20. 19972. "+"\n"
+ self.texteCuve+="200. 2668. "+"\n"
+ self.texteCuve+="1000. 2668. "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Debit massique et temperature d injection de securite' :
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# instant (s) / Debit massique (kg/s)"+"\n"
+ if self.dico_mot.has_key('ProfilTemporel_DebitMassique'):
+ self.imprime(2,(self.dico_mot["ProfilTemporel_DebitMassique"]))
+ self.texteCuve += self.amontAval('Amont_DebitMassique','Aval_DebitMassique')
+ else :
+ self.texteCuve+="0. 18.4 "+"\n"
+ self.texteCuve+="20. 18.4 "+"\n"
+ self.texteCuve+="200. 31.1 "+"\n"
+ self.texteCuve+="1000. 31.1 "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# instant (s) / Temperature d injection de securite (degC)"+"\n"
+ if self.dico_mot.has_key('ProfilTemporel_TemperatureInjection'):
+ self.imprime(2,(self.dico_mot["ProfilTemporel_TemperatureInjection"]))
+ self.texteCuve += self.amontAval('Amont_TemperatureInjection','Aval_TemperatureInjection')
+ else :
+ self.texteCuve+="0. 7.0 "+"\n"
+ self.texteCuve+="20. 7.0 "+"\n"
+ self.texteCuve+="200. 7.0 "+"\n"
+ self.texteCuve+="1000. 7.0 "+"\n"
+ self.texteCuve+="CC"+"\n"
+
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Debit massique et temperature d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et debit d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Courbe APRP' :
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Transitoire des coefficients d echange : modele VESTALE"+"\n"
+ self.texteCuve+="#"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ self.texteCuve += self.ecritVariable('DiametreHydraulique')
+ self.texteCuve += self.ecritVariable('DiametreHydraulique_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('SectionEspaceAnnulaire')
+ self.texteCuve += self.ecritVariable('SectionEspaceAnnulaire_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('HauteurCaracConvectionNaturelle')
+ self.texteCuve += self.ecritVariable('HauteurCaracConvectionNaturelle_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('CritereConvergenceRelative')
+ self.texteCuve += self.ecritVariable('CoefficientsVestale')
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Debit massique et temperature d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' :
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# Transitoire de temperature fluide locale : modele CREARE"+"\n"
+ self.texteCuve+="#"+"\n"
+ #self.texteCuve += self.ecritVariable('VolumeMelange_CREARE')
+ self.texteCuve+="# instant (s) / Volume de melange CREARE (m3)"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ if self.dico_mot.has_key('ProfilTemporel_VolumeMelange_CREARE'):
+ self.imprime(2,(self.dico_mot["ProfilTemporel_VolumeMelange_CREARE"]))
+ self.texteCuve += self.amontAval('Amont_VolumeMelange_CREARE','Aval_VolumeMelange_CREARE')
+ else :
+ self.texteCuve+="0. 14.3 "+"\n"
+ self.texteCuve+="20. 14.2 "+"\n"
+ self.texteCuve+="CC"+"\n"
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ else :
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('TemperatureInitiale_CREARE')
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ self.texteCuve += self.ecritVariable('TemperatureInitiale_CREARE_mess')
+ self.texteCuve+="#"+"\n"
+ self.texteCuve += self.ecritVariable('SurfaceEchange_FluideStructure')
+ self.texteCuve += self.ecritVariable('SurfaceEchange_FluideStructure_mess')
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
+ self.texteCuve+="#BLOC_TFDEBIT"+"\n"
+ else :
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="# instant (s) / temperature imposee du fluide (degC)"+"\n"
+ self.texteCuve+="0. 286. "+"\n"
+ self.texteCuve+="20. 20. "+"\n"
+ self.texteCuve+="200. 7. "+"\n"
+ self.texteCuve+="1000. 80. "+"\n"
+ self.texteCuve+="CC"+"\n"
+ self.texteCuve+="#"+"\n"
+ self.texteCuve+="############################################################################################"+"\n"
+
+
+ def genereTexteTFDEBIT(self):
+
+ self.texteTFDEBIT = ""
+
+ if self.dico_mot.has_key('TypeConditionLimiteThermique'):
+ if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' :
+ self.texteTFDEBIT+="# instant (s) / pression (MPa)"+"\n"
+ self.texteTFDEBIT+=" "+"\n"
+ self.imprime2(2,(self.dico_mot["ProfilTemporel_Pression"]))
+ self.texteTFDEBIT += self.amontAval('Amont_Pression','Aval_Pression')
+
+ # self.texteTFDEBIT+=" "+"\n"
+ # self.texteTFDEBIT += self.affecteValeur('TypeConditionLimiteThermique', self.valeurproposee[str(self.dico_mot["TypeConditionLimiteThermique"])])
+
+ self.texteTFDEBIT+=" "+"\n"
+ self.imprime2(2,(self.dico_mot["ProfilTemporel_TemperatureImposeeFluide"]))
+ self.texteTFDEBIT += self.amontAval('Amont_TemperatureImposeeFluide','Aval_TemperatureImposeeFluide')
+
+ self.texteTFDEBIT+=" "+"\n"
+ self.imprime2(2,(self.dico_mot["ProfilTemporel_DebitInjection"]))
+ self.texteTFDEBIT += self.amontAval('Amont_DebitInjection','Aval_DebitInjection')
+
+ self.texteTFDEBIT+=" "+"\n"
+ self.texteTFDEBIT += self.ecritVariable('DiametreHydraulique')
+ self.texteTFDEBIT += self.ecritVariable('DiametreHydraulique_mess')
+ self.texteTFDEBIT+="#"+"\n"
+ self.texteTFDEBIT += self.ecritVariable('SectionEspaceAnnulaire')
+ self.texteTFDEBIT += self.ecritVariable('SectionEspaceAnnulaire_mess')
+ self.texteTFDEBIT+="#"+"\n"
+ self.texteTFDEBIT += self.ecritVariable('HauteurCaracConvectionNaturelle')
+ self.texteTFDEBIT += self.ecritVariable('HauteurCaracConvectionNaturelle_mess')
+ self.texteTFDEBIT+="#"+"\n"
+ self.texteTFDEBIT += self.ecritVariable('CritereConvergenceRelative')
+ self.texteTFDEBIT += self.ecritVariable('CoefficientsVestale')
+
+ self.texteTFDEBIT+=" "+"\n"
+ self.imprime2(2,(self.dico_mot["ProfilTemporel_VolumeMelange_CREARE"]))
+ self.texteTFDEBIT += self.amontAval('Amont_VolumeMelange_CREARE','Aval_VolumeMelange_CREARE')
+
+ self.texteTFDEBIT+=" "+"\n"
+ self.texteTFDEBIT += self.ecritVariable('SurfaceEchange_FluideStructure')
+ self.texteTFDEBIT += self.ecritVariable('SurfaceEchange_FluideStructure_mess')
+ self.texteTFDEBIT += self.ecritVariable('InstantPerteCirculationNaturelle')
+ self.texteTFDEBIT += self.ecritVariable('TempInjectionSecurite')
+ else :
+ self.texteTFDEBIT+="Fichier inutile"+"\n"
+
+
+ def imprime(self,nbdeColonnes,valeur):
+ self.liste=[]
+ self.transforme(valeur)
+ i=0
+ while i < len(self.liste):
+ for k in range(nbdeColonnes) :
+ self.texteCuve+=str(self.liste[i+k]) +" "
+ self.texteCuve+="\n"
+ i=i+k+1
+
+ def imprime2(self,nbdeColonnes,valeur):
+ self.liste=[]
+ self.transforme(valeur)
+ i=0
+ while i < len(self.liste):
+ for k in range(nbdeColonnes) :
+ self.texteTFDEBIT+=str(self.liste[i+k]) +" "
+ self.texteTFDEBIT+="\n"
+ i=i+k+1
+
+
+ def transforme(self,valeur):
+ for i in valeur :
+ if type(i) == tuple :
+ self.transforme(i)
+ else :
+ self.liste.append(i)
+
+
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+import os
+
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+from .generator_python import PythonGenerator
+import six
+
+def entryPoint():
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {'name' : 'file_from_template',
+ 'factory' : FileFromTemplateGenerator}
+
+
+class FileFromTemplateGenerator(PythonGenerator):
+ """
+ This generator creates an output file from a template (file with holes) in
+ addition to Eficas .comm file. The parts to replace in the template must be
+ in the form %KEYWORD%, where KEYWORD may be either the name of the Eficas
+ element (short form, for instance MY_MCSIMP) or the "path" to the Eficas
+ element (long form, for instance MYPROC.MYBLOC.MY_MCSIMP).
+
+ To use this generator, the configuration of the code must implement two
+ methods: get_extension() that must return the extension of the output file
+ and get_template_file() that must return the path of the template file. Be
+ sure also that your catalog is coherent with your template file.
+ """
+
+ def gener(self, obj, format = 'brut', config = None):
+ self.config = config
+ self.kw_dict = {}
+ self.text = PythonGenerator.gener(self, obj, format)
+ return self.text
+
+ def generate_output_from_template(self) :
+ """
+ Generate the output text from the template file and the keywords
+ """
+ templateFileName = self.config.get_template_file()
+ if not os.path.isfile(templateFileName):
+ raise EficasException(tr("Fichier patron %s n'existe pas.",
+ str( templateFileName)))
+ f = open(templateFileName, "r")
+ template = f.read()
+ f.close()
+ self.output_text = self.replace_keywords(template)
+
+ def generMCSIMP(self, obj) :
+ """
+ Save object value in the keyword dict for further use, then generate
+ the text corresponding to the MCSIMP element.
+ """
+ short_keyword = obj.nom.strip()
+ long_keyword = ""
+ for i in obj.getGenealogie()[:-1]:
+ long_keyword += i + "."
+ long_keyword += short_keyword
+ self.kw_dict[short_keyword] = obj.valeur
+ self.kw_dict[long_keyword] = obj.valeur
+ return PythonGenerator.generMCSIMP(self, obj)
+
+ def replace_keywords(self, template_string):
+ result = template_string
+ for item in six.iteritems(self.kw_dict):
+ replace_str = "%" + item[0] + "%"
+ result = result.replace(replace_str, str(item[1]))
+ return result
+
+ def writeDefault(self, basefilename):
+ self.generate_output_from_template()
+ output_filename = os.path.splitext(basefilename)[0] + \
+ self.config.get_extension()
+ f = open(output_filename, 'w')
+ f.write(self.output_text)
+ f.close()
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ homard pour EFICAS.
+
+"""
+import traceback
+import types,string,re
+
+from Accas.processing import P_CR
+from Accas.processing.P_utils import repr_float
+from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
+from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
+from Accas import GEOM,ASSD,MCNUPLET
+from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
+from Formatage import Formatage
+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' : 'homard',
+ # La factory pour creer une instance du plugin
+ 'factory' : HomardGenerator,
+ }
+
+
+class HomardGenerator(PythonGenerator):
+ """
+ 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 preconis�es
+ 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=P_CR.CR(debut='CR generateur format homard pour homard',
+ fin='fin CR format homard pour homard')
+ # Le texte au format homard est stock� dans l'attribut text
+ self.dico_mot_clef={}
+ self.assoc={}
+ self.init_assoc()
+ self.text=''
+ self.textehomard=[]
+
+ def init_assoc(self):
+ self.lmots_clef_calcules = ('SuivFron','TypeBila','ModeHOMA','CCAssoci', 'CCNoChaI','HOMaiN__','HOMaiNP1','CCNumOrI', 'CCNumPTI')
+ self.lmot_clef = ('CCMaiN__', 'CCNoMN__', 'CCIndica', 'CCSolN__', 'CCFronti', 'CCNoMFro', 'CCMaiNP1',
+ 'CCNoMNP1', 'CCSolNP1', 'TypeRaff', 'TypeDera', 'NiveauMa', 'SeuilHau', 'SeuilHRe',
+ 'SeuilHPE', 'NiveauMi', 'SeuilBas', 'SeuilBRe', 'SeuilBPE', 'ListeStd', 'NumeIter',
+ 'Langue ', 'CCGroFro', 'CCNoChaI', 'CCNumOrI', 'CCNumPTI', 'SuivFron', 'TypeBila',
+ 'ModeHOMA', 'HOMaiN__', 'HOMaiNP1','CCCoChaI')
+
+# Bizarre demander a Gerald :
+# CVSolNP1
+ self.assoc['CCMaiN__']='FICHIER_MED_MAILLAGE_N'
+ self.assoc['CCNoMN__']='NOM_MED_MAILLAGE_N'
+ self.assoc['CCIndica']='FICHIER_MED_MAILLAGE_N'
+ self.assoc['CCSolN__']='FICHIER_MED_MAILLAGE_N'
+ self.assoc['CCFronti']='FIC_FRON'
+ self.assoc['CCNoMFro']='NOM_MED_MAILLAGE_FRONTIERE'
+ self.assoc['CCMaiNP1']='FICHIER_MED_MAILLAGE_NP1'
+ self.assoc['CCNoMNP1']='NOM_MED_MAILLAGE_NP1'
+ self.assoc['CCSolNP1']='FICHIER_MED_MAILLAGE_NP1'
+ self.assoc['TypeRaff']='RAFFINEMENT'
+ self.assoc['TypeDera']='DERAFFINEMENT'
+ self.assoc['NiveauMa']='NIVE_MAX'
+ self.assoc['SeuilHau']='CRIT_RAFF_ABS'
+ self.assoc['SeuilHRe']='CRIT_RAFF_REL'
+ self.assoc['SeuilHPE']='CRIT_RAFF_PE'
+ self.assoc['NiveauMi']='NIVE_MIN'
+ self.assoc['SeuilBas']='CRIT_DERA_ABS'
+ self.assoc['SeuilBRe']='CRIT_DERA_REL'
+ self.assoc['SeuilBPE']='CRIT_DERA_PE'
+ self.assoc['ListeStd']='MESSAGES'
+ self.assoc['NumeIter']='NITER'
+ self.assoc['Langue ']='LANGUE'
+ self.assoc['CCGroFro']='GROUP_MA'
+# self.assoc['CCNoChaI']='NOM_MED' (on doit aussi ajouter 'COMPOSANTE')
+ self.assoc['CCNumOrI']='NUME_ORDRE'
+ self.assoc['CCNumPTI']='NUME_PAS_TEMPS'
+ self.assoc['CCCoChaI']='COMPOSANTE'
+
+ self.dico_mot_depend={}
+
+ # Attention a la synthaxe
+ self.dico_mot_depend['CCIndica'] ='self.dico_mot_clef["RAFFINEMENT"] == "LIBRE" or self.dico_mot_clef["DERAFFINEMENT"] == "LIBRE"'
+ self.dico_mot_depend['CCSolN__'] ='self.dico_mot_clef.has_key("NITER")'
+ self.dico_mot_depend['CCSolNP1'] ='self.dico_mot_clef.has_key("NITER")'
+
+ def gener(self,obj,format='brut',config=None):
+ self.text=PythonGenerator.gener(self,obj,format)
+ self.genereConfiguration()
+ return self.text
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en une liste de chaines de caract�res � la
+ syntaxe homard
+ """
+ s=PythonGenerator.generMCSIMP(self,obj)
+ clef=obj.nom
+ self.dico_mot_clef[clef]=obj.val
+ return s
+
+ def cherche_dependance(self,mot):
+ b_eval = 0
+ a_eval=self.dico_mot_depend[mot]
+ try :
+ b_eval=eval(self.dico_mot_depend[mot])
+ except :
+ for l in a_eval.split(" or "):
+ try:
+ b_eval=eval(l)
+ if not (b_eval == 0 ):
+ break
+ except :
+ pass
+ return b_eval
+
+
+ def genereConfiguration(self):
+ ligbla=31*' '
+ self.textehomard=[]
+ for mot in self.lmot_clef:
+
+# on verifie d'abord que le mot clef doit bien etre calcule
+ if self.dico_mot_depend.has_key(mot) :
+ if self.cherche_dependance(mot) == 0 :
+ continue
+
+ if mot not in self.lmots_clef_calcules :
+ clef_eficas=self.assoc[mot]
+ if self.dico_mot_clef.has_key(clef_eficas):
+ val=self.dico_mot_clef[clef_eficas]
+ if val != None:
+ try :
+ ligne=mot+' '+val
+ except:
+ ligne=mot+' '+repr(val)
+ ligne.rjust(32)
+ self.textehomard.append(ligne)
+ else:
+ val=apply(HomardGenerator.__dict__[mot],(self,))
+ if val != None:
+ mot.rjust(8)
+ ligne=mot+' '+val
+ ligne.rjust(32)
+ self.textehomard.append(ligne)
+
+ def get_homard(self):
+ return self.textehomard
+
+ def SuivFron(self):
+ val="non"
+ if self.dico_mot_clef.has_key('NOM_MED_MAILLAGE_FRONTIERE'):
+ if self.dico_mot_clef['NOM_MED_MAILLAGE_FRONTIERE'] != None:
+ val="oui"
+ return val
+
+ def TypeBila(self):
+ inttypeBilan = 1
+ retour=None
+ dict_val={'NOMBRE':7,'INTERPENETRATION':3,'QUALITE':5,'CONNEXITE':11,'TAILLE':13}
+ for mot in ('NOMBRE','QUALITE','INTERPENETRATION','CONNEXITE','TAILLE'):
+ if self.dico_mot_clef.has_key(mot):
+ if (self.dico_mot_clef[mot] == "OUI"):
+ inttypeBilan=inttypeBilan*dict_val[mot]
+ retour = repr(inttypeBilan)
+ return retour
+
+
+ def ModeHOMA(self):
+ intModeHOMA=1
+ if self.dico_mot_clef.has_key('INFORMATION'):
+ if self.dico_mot_clef['INFORMATION'] == "OUI":
+ intModeHOMA=2
+ return repr(intModeHOMA)
+
+ def CCAssoci(self):
+ return 'MED'
+
+ def CCNoChaI(self):
+ if not (self.dico_mot_clef.has_key('NOM_MED')):
+ return None
+ if (self.dico_mot_clef['NOM_MED']== None):
+ return None
+ if not (self.dico_mot_clef.has_key('COMPOSANTE')):
+ return None
+ if (self.dico_mot_clef['COMPOSANTE']== None):
+ return None
+ chaine=self.dico_mot_clef['COMPOSANTE']+' '+self.dico_mot_clef['NOM_MED']
+ return chaine
+
+ def HOMaiN__(self):
+ chaine=None
+ if self.dico_mot_clef.has_key('NITER'):
+ if self.dico_mot_clef['NITER'] != None :
+ num="M"+repr(self.dico_mot_clef['NITER'])
+ chaine=num+" "+num+".hom"
+ return chaine
+
+ def HOMaiNP1(self):
+ chaine=None
+ if self.dico_mot_clef.has_key('NITER'):
+ if self.dico_mot_clef['NITER'] != None :
+ num="M"+repr(self.dico_mot_clef['NITER']+1)
+ chaine=num+" "+num+".hom"
+ return chaine
+
+ def CCNumOrI(self):
+ chaine=repr(1)
+ if self.dico_mot_clef.has_key('NUME_ORDRE'):
+ if self.dico_mot_clef['NUME_ORDRE'] != None :
+ chaine=repr(self.dico_mot_clef['NUME_ORDRE'])
+ return chaine
+
+ def CCNumPTI(self):
+ chaine=repr(1)
+ if self.dico_mot_clef.has_key('NUME_PAS_TEMPS'):
+ if self.dico_mot_clef['NUME_PAS_TEMPS'] != None :
+ chaine=repr(self.dico_mot_clef['NUME_PAS_TEMPS'])
+ return chaine
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier
+ au format ini pour EFICAS.
+"""
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
+import traceback
+import types
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+
+from Accas.processing import P_CR
+from Accas import MCSIMP,MCFACT,MCList
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'ini',
+ # La factory pour creer une instance du plugin
+ 'factory' : IniGenerator,
+ }
+
+
+class IniGenerator(object):
+ """
+ Ce generateur parcourt un objet de type MCFACT et produit
+ un fichier au format ini
+ L'acquisition et le parcours sont realises par le methode
+ generator.gener(objet_mcfact)
+ 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=('.ini','.conf')
+
+ 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=P_CR.CR(debut='CR generateur format ini',
+ fin='fin CR format ini')
+ # Le texte au format ini 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,config=None):
+ """
+ Tous les mots-cles simples du niveau haut sont mis dans la section DEFAUT
+ Tous les mots-cles facteurs sont convertis en sections
+ Un mot-cle facteur ne peut contenir que des mots-cles simples. Sinon => erreur
+ """
+ listeMcFact=[]
+ sect_defaut=''
+ if isinstance(obj,MCList):
+ if len(obj.data) > 1:
+ raise EficasException(tr("Pas supporte"))
+ else:
+ obj=obj.data[0]
+
+ for mocle in obj.mc_liste:
+ if isinstance(mocle,MCList):
+ if len(mocle.data) > 1:
+ raise EficasException(tr("Pas supporte"))
+ else:
+ listeMcFact.append(self.generMCFACT(mocle.data[0]))
+ elif isinstance(mocle,MCFACT):
+ listeMcFact.append(self.generMCFACT(mocle))
+ elif isinstance(mocle,MCSIMP):
+ sect_defaut=sect_defaut+self.generMCSIMP(mocle)
+ else:
+ self.cr.fatal(tr("Entite inconnue ou interdite :%s",repr(mocle)))
+
+ self.text=''
+ if sect_defaut != '':
+ self.text="[DEFAULT]\n"+sect_defaut
+ self.text=self.text + ''.join(listeMcFact,'\n')
+ return self.text
+
+ def generMCFACT(self,obj):
+ """
+ Cette methode convertit un mot-cle facteur ne contenant que des mots-cles
+ simples en une chaine de caracteres
+ """
+ sect_text='[%s]\n' % obj.nom
+ for mocle in obj.mc_liste:
+ if isinstance(mocle,MCSIMP):
+ sect_text=sect_text+self.generMCSIMP(mocle)
+ else:
+ self.cr.fatal(tr("Entite inconnue ou interdite :%s. Elle est ignoree",repr(mocle)))
+ return sect_text
+
+ def generMCSIMP(self,obj):
+ """
+ Cette methode convertit un mot-cle simple en une chaine de caracteres
+ au format ini
+ """
+ s=''
+ if type(obj.valeur) == tuple :
+ self.cr.fatal(tr("Les tuples ne sont pas supportes pour le format ini :%s ", obj.nom))
+ s="%s = %s\n" % (obj.nom,"ERREUR")
+ else :
+ try:
+ s="%s = %s\n" % (obj.nom,obj.valeur)
+ except Exception as e :
+ self.cr.fatal(tr("Type de valeur non supportee par le format ini :%(nom)s\n%(exception)s", \
+ {'nom': obj.nom, 'exception': str(e)}))
+ return s
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ 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
+except : pass
+
+import traceback
+import types,re,os
+import Accas
+
+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' : '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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ 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
+except : pass
+
+import traceback
+import types,re,os
+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
+
+ 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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ openturns pour EFICAS.
+
+"""
+import traceback
+import types,string,re
+from Accas.extensions.eficas_translation import tr
+
+
+from generator_python import PythonGenerator
+from OpenturnsBase import Generateur
+#from OpenturnsXML import XMLGenerateur
+#from OpenturnsSTD import STDGenerateur
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'openturns',
+ # La factory pour creer une instance du plugin
+ 'factory' : OpenturnsGenerator,
+ }
+
+
+class OpenturnsGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format xml
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+ def initDico(self):
+ self.dictMCVal={}
+ self.listeVariables=[]
+ self.listeFichiers=[]
+ self.dictMCLois={}
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+
+ def gener(self,obj,format='brut',config=None):
+ #print "IDM: gener dans generator_openturns.py"
+ self.initDico()
+ self.text=PythonGenerator.gener(self,obj,format)
+ self.genereXML()
+ self.genereSTD()
+ return self.text
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en texte python
+ Remplit le dictionnaire des MCSIMP si nous ne sommes pas ni dans une loi, ni dans une variable
+ """
+ s=PythonGenerator.generMCSIMP(self,obj)
+ if self.TraiteMCSIMP == 1 :
+ self.dictMCVal[obj.nom]=obj.valeur
+ else :
+ self.dictTempo[obj.nom]=obj.valeur
+ return s
+
+ def generMCFACT(self,obj):
+ # Il n est pas possible d utiliser obj.valeur qui n est pas
+ # a jour pour les nouvelles variables ou les modifications
+ if obj.nom == "Variables" or "Files":
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generMCFACT(self,obj)
+ if obj.nom == "Variables" :
+ self.listeVariables.append(self.dictTempo)
+ self.dictTempo={}
+ else :
+ self.listeFichiers.append(self.dictTempo)
+ self.TraiteMCSIMP=1
+ return s
+
+ def generETAPE(self,obj):
+ if obj.nom == "DISTRIBUTION" :
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generETAPE(self,obj)
+ if obj.nom == "DISTRIBUTION" :
+ self.dictMCLois[obj.sd]=self.dictTempo
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+ return s
+
+ def genereXML(self):
+ #print "IDM: genereXML dans generator_openturns.py"
+ if self.listeFichiers != [] :
+ self.dictMCVal["exchange_file"]=self.listeFichiers
+ MonBaseGenerateur=Generateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
+ MonGenerateur=MonBaseGenerateur.getXMLGenerateur()
+ #try :
+ if 1== 1 :
+ self.texteXML=MonGenerateur.CreeXML()
+ #except :
+ else :
+ self.texteXML=tr("Il y a un pb a la Creation du XML")
+
+ def genereSTD(self):
+ MonBaseGenerateur=Generateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
+ MonGenerateur=MonBaseGenerateur.getSTDGenerateur()
+ #try :
+ if 1== 1 :
+ self.texteSTD=MonGenerateur.CreeSTD()
+ #except :
+ else :
+ self.texteSTD=tr("Il y a un pb a la Creation du STD")
+
+ def getOpenturnsXML(self):
+ return self.texteXML
+
+ def getOpenturnsSTD(self):
+ return self.texteSTD
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ openturns pour EFICAS.
+
+"""
+import traceback
+import types,string,re
+from Accas.extensions.eficas_translation import tr
+
+
+from generator_python import PythonGenerator
+from OpenturnsBase import Generateur
+#from OpenturnsXML import XMLGenerateur
+#from OpenturnsSTD import STDGenerateur
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'openturns_study',
+ # La factory pour creer une instance du plugin
+ 'factory' : OpenturnsGenerator,
+ }
+
+
+class OpenturnsGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format xml
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+ def initDico(self):
+ self.dictMCVal={}
+ self.listeVariables=[]
+ self.listeFichiers=[]
+ self.dictMCLois={}
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+ self.texteSTD="""#!/usr/bin/env python
+ import sys
+ print "Invalid file. Check build process."
+ sys.exit(1)
+ """
+
+ def gener(self,obj,format='brut',config=None):
+ print "IDM: gener dans generator_openturns_study.py"
+ self.initDico()
+ self.text=PythonGenerator.gener(self,obj,format)
+ self.genereSTD()
+ return self.text
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en texte python
+ Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
+ """
+ s=PythonGenerator.generMCSIMP(self,obj)
+ if self.TraiteMCSIMP == 1 :
+ self.dictMCVal[obj.nom]=obj.valeur
+ else :
+ self.dictTempo[obj.nom]=obj.valeur
+ return s
+
+
+ def generETAPE(self,obj):
+ print "IDM: generETAPE dans generator_openturns_study.py"
+ print "IDM: obj.nom=", obj.nom
+ if obj.nom in ( "DISTRIBUTION", ) :
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generETAPE(self,obj)
+ if obj.nom in ( "DISTRIBUTION", ) :
+ self.dictMCLois[obj.sd]=self.dictTempo
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+ return s
+
+ def generPROC_ETAPE(self,obj):
+ print "IDM: generPROC_ETAPE dans generator_openturns_study.py"
+ print "IDM: obj.nom=", obj.nom
+ if obj.nom in ( "VARIABLE", ) :
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ if obj.nom in ( "VARIABLE", ) :
+ self.listeVariables.append(self.dictTempo)
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+ return s
+
+ def genereSTD(self):
+ print "IDM: genereSTD dans generator_openturns_study.py"
+ print "IDM: self.listeVariables=", self.listeVariables
+ MonGenerateur=self.getGenerateur()
+ #try :
+ if 1== 1 :
+ self.texteSTD=MonGenerateur.CreeSTD()
+ #except :
+ else :
+ self.texteSTD=tr("Il y a un pb a la Creation du STD")
+
+ def writeDefault(self, fn):
+ fileSTD = fn[:fn.rfind(".")] + '.py'
+ with open(fileSTD, 'w') as f:
+ f.write(self.texteSTD)
+
+ def getGenerateur (self):
+ print "IDM: getGenerateur dans generator_openturns_study.py"
+ print "IDM: self.dictMCVal=", self.dictMCVal
+ print "IDM: self.listeVariables=", self.listeVariables
+ print "IDM: self.dictMCLois=", self.dictMCLois
+ MonBaseGenerateur=Generateur(self.appli,self.dictMCVal, self.listeVariables, self.dictMCLois)
+ MonGenerateur=MonBaseGenerateur.getSTDGenerateur()
+ return MonGenerateur
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ openturns pour EFICAS.
+
+"""
+import traceback
+import types,string,re
+from Accas.extensions.eficas_translation import tr
+
+
+from generator_python import PythonGenerator
+from OpenturnsBase import Generateur
+#from OpenturnsXML import XMLGenerateur
+#from OpenturnsSTD import STDGenerateur
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'openturns_wrapper',
+ # La factory pour creer une instance du plugin
+ 'factory' : OpenturnsGenerator,
+ }
+
+
+class OpenturnsGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format xml
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+ def initDico(self):
+ self.dictMCVal={}
+ self.dictVariables={}
+ self.listeFichiers=[]
+ self.dictTempo={}
+ self.traiteMCSIMP=1
+ self.numOrdre=0
+ self.texteSTD="""#!/usr/bin/env python
+ import sys
+ print "Invalid file. Check build process."
+ sys.exit(1)
+ """
+ self.wrapperXML=None
+
+ def gener(self,obj,format='brut',config=None):
+ #print "IDM: gener dans generator_openturns_wrapper.py"
+ self.initDico()
+ self.text=PythonGenerator.gener(self,obj,format)
+ self.genereXML()
+ #self.genereSTD()
+ return self.text
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en texte python
+ Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
+ """
+ s=PythonGenerator.generMCSIMP(self,obj)
+ if not( type(obj.valeur) in (list, tuple)) and (obj.getMinMax()[1] != 1):
+ valeur=(obj.valeur,)
+ else :
+ valeur=obj.valeur
+ if self.traiteMCSIMP == 1 :
+ self.dictMCVal[obj.nom]=valeur
+ else :
+ self.dictTempo[obj.nom]=valeur
+ return s
+
+ def generETAPE(self,obj):
+ #print "generETAPE" , obj.nom
+ if obj.nom == "VARIABLE" :
+ self.traiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generETAPE(self,obj)
+ if obj.nom == "VARIABLE" :
+ self.dictTempo["numOrdre"]=self.numOrdre
+ self.numOrdre = self.numOrdre +1
+ if obj.sd == None :
+ self.dictVariables["SansNom"]=self.dictTempo
+ else :
+ self.dictVariables[obj.sd.nom]=self.dictTempo
+ self.dictTempo={}
+ self.traiteMCSIMP=1
+ return s
+
+ def generMCFACT(self,obj):
+ # Il n est pas possible d utiliser obj.valeur qui n est pas
+ # a jour pour les nouvelles variables ou les modifications
+ if obj.nom in ( "Files", ) :
+ self.traiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generMCFACT(self,obj)
+ self.listeFichiers.append(self.dictTempo)
+ self.traiteMCSIMP=1
+ return s
+
+ def genereXML(self):
+ print "IDM: genereXML dans generator_openturns_wrapper.py"
+ #print "appli.maConfiguration=",self.appli.maConfiguration.__dict__
+ if self.listeFichiers != [] :
+ self.dictMCVal["Files"]=self.listeFichiers
+ print "dictMCVal", self.dictMCVal, "dictVariables", self.dictVariables
+ MonBaseGenerateur=Generateur(self.appli,self.dictMCVal, [], {} ,self.dictVariables)
+ MonGenerateur=MonBaseGenerateur.getXMLGenerateur()
+ try :
+ #if 1== 1 :
+ self.wrapperXML=MonGenerateur.CreeXML()
+ except :
+ #else :
+ self.wrapperXML=None
+
+ def writeDefault(self, filename):
+ fileXML = filename[:filename.rfind(".")] + '.xml'
+ self.wrapperXML.writeFile( str(fileXML) )
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format pyth pour EFICAS.
+
+
+"""
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
+import traceback
+import types
+
+from Accas.processing import P_CR
+from Accas import MCSIMP,MCFACT,MCList
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'pyth',
+ # La factory pour creer une instance du plugin
+ 'factory' : PythGenerator,
+ }
+
+
+class PythGenerator(object):
+ """
+ Ce generateur parcourt un objet de type MCFACT et produit
+ un fichier au format pyth
+
+ L'acquisition et le parcours sont realises par la methode
+ generator.gener(objet_mcfact)
+
+ 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=('.py','.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=P_CR.CR(debut='CR generateur format ini',
+ fin='fin CR format ini')
+ # Le texte au format pyth 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='standard',config=None):
+ """
+ Tous les mots-cles simples du niveau haut sont transformes en variables
+
+ Tous les mots-cles facteurs sont convertis en dictionnaires
+
+ Les mots-cles multiples ne sont pas traites
+ """
+ s=''
+ if isinstance(obj,MCList):
+ if len(obj.data) > 1:
+ raise EficasException(tr("Pas supporte"))
+ else:
+ obj=obj.data[0]
+
+ for mocle in obj.mc_liste:
+ if isinstance(mocle,MCList):
+ if len(mocle.data) > 1:
+ raise EficasException(tr("Pas supporte"))
+ else:
+ valeur=self.generMCFACT(mocle.data[0])
+ s=s+"%s = %s\n" % (mocle.nom,valeur)
+ elif isinstance(mocle,MCFACT):
+ valeur=self.generMCFACT(mocle)
+ s=s+"%s = %s\n" % (mocle.nom,valeur)
+ elif isinstance(v,MCSIMP):
+ valeur = self.generMCSIMP(mocle)
+ s=s+"%s = %s\n" % (mocle.nom,valeur)
+ else:
+ self.cr.fatal("Entite inconnue ou interdite : "+repr(mocle))
+
+ self.text=s
+ return self.text
+
+ def generMCFACT(self,obj):
+ """
+ Cette methode convertit un mot-cle facteur
+ en une chaine de caracteres representative d'un dictionnaire
+ """
+ s = '{'
+ for mocle in obj.mc_liste:
+ if isinstance(mocle,MCSIMP):
+ valeur = self.generMCSIMP(mocle)
+ s=s+"'%s' : %s,\n" % (mocle.nom,valeur)
+ elif isinstance(mocle,MCFACT):
+ valeur=self.generMCFACT(mocle)
+ s=s+"'%s' : %s,\n" % (mocle.nom,valeur)
+ else:
+ self.cr.fatal(tr("Entite inconnue ou interdite : %s. Elle est ignoree", repr(mocle)))
+
+ s=s+'}'
+ return s
+
+ def generMCSIMP(self,obj):
+ """
+ Cette methode convertit un mot-cle simple en une chaine de caracteres
+ au format pyth
+ """
+ try:
+ s="%s" % obj.valeur
+ except Exception as e :
+ self.cr.fatal(tr("Type de valeur non supporte par le format pyth : n %(exception)s", \
+ {'nom': obj.nom, 'exception': str(e)}))
+
+
+ s="ERREUR"
+ return s
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ python pour EFICAS.
+
+"""
+import traceback
+import types,string,re
+
+from Accas.processing import P_CR
+from Accas.processing.P_utils import repr_float
+from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
+from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
+from Accas import GEOM,ASSD,MCNUPLET
+from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
+from Formatage import Formatage
+
+import generator_python
+
+def entryPoint():
+ """
+ Retourne les informations nécessaires pour le chargeur de plugins
+
+ Ces informations sont retournées dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'python6',
+ # La factory pour créer une instance du plugin
+ 'factory' : PythonGenerator,
+ }
+
+
+class PythonGenerator(generator_python.PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un fichier au format python6
+
+ L'acquisition et le parcours sont réalisés par la méthode
+ generator.gener(objet_jdc,format)
+
+ L'écriture du fichier au format python6 par appel de la méthode
+ generator.writefile(nom_fichier)
+
+ Ses caractéristiques principales sont exposées dans des attributs
+ de classe :
+ - extensions : qui donne une liste d'extensions de fichier préconisées
+
+ """
+ # Les extensions de fichier préconisées
+ extensions=('.comm',)
+
+ def generFORM_ETAPE(self,obj):
+ """
+ Méthode particulière pour les objets de type FORMULE
+ """
+ l=[]
+ nom = obj.getNom()
+ if nom == '' : nom = 'sansnom'
+ l.append(nom + ' = FORMULE(')
+ for v in obj.mc_liste:
+ text=self.generator(v)
+ l.append(v.nom+'='+text)
+ l.append(');')
+ return l
+
+ def gen_formule(self,obj):
+ """
+ Méthode particuliere aux objets de type FORMULE
+ """
+ try:
+ if obj.sd == None:
+ sdname=''
+ else:
+ sdname= self.generator(obj.sd)
+ except:
+ sdname='sansnom'
+ l=[]
+ label=sdname + ' = FORMULE('
+ l.append(label)
+ for v in obj.mc_liste:
+ s=''
+ s= v.nom+':'+sdname+'('+v.valeur+')'
+ l.append(s)
+ if len(l) == 1:
+ l[0]=label+');'
+ else :
+ l.append(');')
+ return l
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ python pour EFICAS.
+ PN
+
+"""
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+try :
+ from builtins import range
+except :
+ pass
+import traceback
+import types,re
+import math
+
+from Accas.processing import P_CR
+from Accas.processing.P_utils import repr_float
+import Accas
+import Accas.extensions
+from Accas.extensions.parametre import ITEM_PARAMETRE
+from .Formatage import Formatage
+from .generator_python import PythonGenerator
+from six.moves import range
+#from Editeur.widgets import showerror
+
+def entryPoint():
+ """
+ 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,
+ }
+
+
+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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
+"""
+
+import traceback
+import types,string,re,os
+from Accas.extensions.eficas_translation import tr
+from generator_python import PythonGenerator
+
+# Groupes de mailles dont les types sont definis par des prefixes dans leur nom
+usePrefix = False # les noms ont des prefixes (True) ou non (False)
+# liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom
+# Ce prefixe (et caractere _) doivent etre supprimes dans le fichier .phys
+listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",
+ "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",
+ "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",
+ "PORT_OMEGA","POST_PHI","PB_GRID",
+ "SCUTE","SCUTN","ZS","ZJ","ZT")
+# liste des prefixes des groupes de mailles, sans le separateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire
+dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'),
+ 'CONDUCTOR':('COND',),
+ 'STRANDED_INDUCTOR':('CURRENT', ),
+ 'EPORT':('EPORT', ),
+ 'HPORT':('HPORT', ),
+ 'ZSURFACIC':('ZS', ),
+ 'ZINSULATOR':('ZJ', ),
+ 'NILMAT':('NILMAT', )}
+# separateur entre le prefixe et le reste du nom du groupe de maille
+sepNomGroupeMaille = '_'
+
+
+# types de problemes
+HARMONIC = 'HARMONIC' # probleme frequentiel
+TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
+
+# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
+nomPlugin = 'CARMEL3DFV0'
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : nomPlugin,
+ # La factory pour creer une instance du plugin
+ 'factory' : CARMEL3DFV0Generator,
+ }
+
+
+
+class CARMEL3DFV0Generator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+#----------------------------------------------------------------------------------------
+ def gener(self,obj,format='brut',config=None):
+
+ self.initDico()
+
+ #self.debug = True
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+
+ if self.debug:
+ print "self.text = %s" % self.text
+
+ # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
+ # si le jdc est valide (sinon cela n a pas de sens)
+ if obj.isValid() :
+ try :
+ # constitution du bloc VERSION du fichier PHYS (existe toujours)
+ self.generBLOC_VERSION(obj)
+ # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
+ self.generBLOC_MATERIALS()
+ # constitution du bloc SOURCES du fichier PHYS (existe toujours)
+ self.generBLOC_SOURCES()
+
+ except ValueError, err:
+ raise ValueError(str(err))
+
+# print "texte carmel3d :\n",self.texteCarmel3D
+# print "dictMaterDielectric : ",self.dictMaterDielectric
+ if self.debug:
+ print "dictMaterDielectric : %s" % repr(self.dictMaterDielectric)
+ print "dictMaterConductor : %s" % repr(self.dictMaterConductor)
+
+ return self.text
+
+
+
+
+#----------------------------------------------------------------------------------------
+# initialisations
+#----------------------------------------------------------------------------------------
+
+ def initDico(self) :
+ self.texteCarmel3D=""
+ self.texteCarmel3D_PARAM=""
+ self.texteCarmel3D_PARAM_SOLV=""
+ self.texteCarmel3D_SH=""
+ self.texteCarmel3D_INFC=""
+ self.texteCarmel3D_CMD=""
+ self.texteCarmel3D_INGEND1=""
+ self.texteCarmel3D_INGEND2=""
+ self.texteCarmel3D_INGEND3=""
+ self.texteCarmel3D_INPOST=""
+ self.debug = True # affichage de messages pour deboguage (.true.) ou non
+ self.dicoEtapeCourant=None
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=None
+ self.dictGroupes = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[], 'ordreStrandJdC':[], 'ordreListeJdC':[], 'ordreDomaineJdC':[]} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
+ self.dictMaterConductor={}
+ self.dictMaterDielectric={}
+ self.dictMaterZsurfacic={}
+ self.dictMaterEmIso={}
+ self.dictMaterEmAnIso={}
+ self.dictMaterNilmat={}
+ self.dictMaterZinsulator={}
+ self.dictSourceStInd={}
+ self.dictSourceEport={}
+ self.dictSourceHport={}
+ self.dictStrand={}
+ self.dictDomaine={}
+ self.dictPort={}
+ self.cutlineValeur=[]
+ self.cutplaneValeur=[]
+ self.visu3dValeur=[]
+ self.fieldmapValeur=[]
+ self.fielddumpValeur=[]
+ self.repertory=""
+ self.frequency=""
+ self.domaine=""
+ self.direction=""
+ self.section=""
+ self.forme=""
+ self.centre=""
+ self.echelle=""
+ self.visu=False
+ self.post_global=False
+ self.visu_format=""
+ self.visu_type=""
+ self.gendof=""
+ self.fcarmel=""
+ self.postprocess=""
+ self.formulation=""
+ # on force le probleme a etre frequentiel, seul possible en l'etat des choses
+ self.problem = HARMONIC
+ self.fichierMaillage = "" # chemin absolu ou relatif du fichier contenant le maillage, défini dans PARAMETERS.Fichier_maillage.
+ self.nomFichierMaillage = "" # nom du fichier de maillage, sans le chemin
+ self.projet = "" # nom du projet, utilisé un peu partout, i.e., nom du fichier de maillage sans l'extension
+ self.materiauxGroupesTousHomogenes = True # Tous les groupes sont associés a priori à des matériaux tous homogènes mais pas forcément isotropes. On le vérifie ou modifie ci-dessous.
+ self.materiauxGroupesTousIsotropes = True # Tous les groupes sont associés a priori à des matériaux tous isotropes mais pas forcément homogènes. On le vérifie ou modifie ci-dessous.
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def writeDefault(self,fn) :
+ """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
+
+ # fn est le chemin complet du fichier de l'étude, e.g., /home/toto/foo.comm
+ #file = fn[:fn.rfind(".")] # chemin complet du fichier de l'étude sans l'extension, e.g., /home/toto/foo
+ repertory=os.path.dirname(fn) # répertoire de l'étude, e.g., /home/toto/
+ file = os.path.join(repertory, self.projet) # on crée le chemin complet des fichiers de configuration sans extension, à partir du nom du projet.
+ namefile=os.path.basename(file) # nom du projet e.g., foo
+
+
+ if self.debug:
+ print "ecriture du fichier de parametres (PHYS)"
+ filePHYS = file + '.phys'
+ typeBloc = 'PHYS_FILES'
+ f = open( str(filePHYS), 'w')
+ f.write( self.texteCarmel3D)
+ f.close()
+
+
+ if self.debug:
+ print "ecriture du fichier de parametres (PARAM)"
+ filePARAM = file + '.param'
+ f = open( str(filePARAM), 'w')
+ f.write('[VERSION \n'
+ ' NUM 1\n'
+ ' FILETYPE PARAM\n]\n'
+ '[PROBLEM\n'
+ ' NAME HARMONIC\n]\n'
+ )
+ typeBloc = 'CAR_FILES'
+ self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D_PARAM+=" NAME "+self.projet+".car"
+ self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
+ typeBloc = 'PHYS_FILES'
+ self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D_PARAM+=" NAME "+self.projet+".phys"
+ self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
+ self.texteCarmel3D_PARAM+="[FREQUENCY\n"
+ self.texteCarmel3D_PARAM+=" SINGLE %g \n" % (self.frequency )
+ self.texteCarmel3D_PARAM+="] \n"
+ f.write( self.texteCarmel3D_PARAM)
+ f.write(self.texteCarmel3D_PARAM_SOLV)
+ f.close()
+
+ # ecriture du fichier de commandes du post-traitement (.cmd), à partir du texte self.textCarmel3D défini dans la routine generPOST_COMMANDS
+ if self.debug:
+ print "ecriture du fichier de parametres (CMD)"
+ fileCMD =file + '.cmd'
+ f = open( str(fileCMD), 'w')
+ f.write(self.texteCarmel3D_CMD)
+ f.close()
+
+
+ if self.debug:
+ print "ecriture du fichier de parametres (INGENDOF)"
+ fileINGEND = file + '.ingendof'
+ f = open(fileINGEND, 'w')
+ self.texteCarmel3D_INGEND1+=""+self.nomFichierMaillage # nom du fichier de maillage (chemin relatif)
+
+ nomsGroupes = self.dictGroupes['ordreStrandJdC'][:]
+ nomsGroupes.sort()
+
+ #if self.dictDomaine !={}:
+ try:
+ self.creaBLOC_STRANDED_INDUCTOR_GEOMETRY(nomsGroupes)
+ except ValueError, err:
+ raise ValueError(str(err))
+ if self.dictPort != {} :
+ self.creaBLOC_PORTS_GEOMETRY(nomsGroupes)
+ if self.formulation=="APHI": self.texteCarmel3D_INGEND3+="\n1"
+ if self.formulation=="TOMEGA": self.texteCarmel3D_INGEND3+="\n2"
+ f.write(self.texteCarmel3D_INGEND1)
+ f.write(self.texteCarmel3D_INGEND2)
+ f.write(self.texteCarmel3D_INGEND3)
+ f.close()
+
+ if self.debug:
+ print "ecriture du fichier de parametres (INFCARMEL) "
+ fileINFC = file + '.infcarmel'
+ f = open(fileINFC, 'w')
+ self.texteCarmel3D_INFC+= self.projet+".param"
+ f.write(self.texteCarmel3D_INFC)
+ f.close()
+
+ if self.debug:
+ print "ecriture du fichier de parametres (INPOSTPROCESS) "
+ fileINPOST = file + '.inpostprocess'
+ f = open(fileINPOST, 'w')
+ self.texteCarmel3D_INPOST+= self.projet+".param"
+ self.texteCarmel3D_INPOST+="\n"+self.projet+".xmat"
+ self.texteCarmel3D_INPOST+="\n"+self.projet+".cmd"
+ f.write(self.texteCarmel3D_INPOST)
+ f.close()
+
+ print "dictionnaire complet=%s" %self.dictGroupes
+ print "dictionnaire des ports =%s" %self.dictPort
+ if self.debug:
+ print "ecriture du fichier d'execution (SH)"
+ print"LISTE DES DOMAINES=%s" %(self.dictGroupes['ordreDomaineJdC'])
+ RepCarmel= os.path.join(repertory,"lancer.sh")
+ f = open( str(RepCarmel), 'wb')
+ self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
+ if self.gendof=="TRUE":
+ self.texteCarmel3D_SH+='echo "Debut execution gendof" \n'
+ if self.echelle=="Millimetre":
+ self.texteCarmel3D_SH+=self.repertory+"/gendof.exe -scale 0.001 < " + self.projet + ".ingendof\n"
+ else:
+ self.texteCarmel3D_SH+=self.repertory+"/gendof.exe < " + self.projet + ".ingendof\n"
+ if self.fcarmel=="TRUE":
+ self.texteCarmel3D_SH+='echo "Debut execution fcarmel" \n'
+ self.texteCarmel3D_SH+=self.repertory+"/fcarmel.exe < " + self.projet + ".infcarmel\n"
+ if self.postprocess=="TRUE":
+ self.texteCarmel3D_SH+= 'echo "Debut execution postprocess" \n'
+ self.texteCarmel3D_SH+= self.repertory+"/postprocess.exe < " + self.projet + ".inpostprocess\n"
+ f.write(self.texteCarmel3D_SH)
+ f.close()
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ if self.debug:
+ print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
+ s=PythonGenerator.generMCSIMP(self,obj)
+ try:
+ self.dicoCourant[obj.nom]=obj.valeurFormatee
+ except:
+ print "Oubli des messages texte homo='information'"
+ return s
+
+
+#----------------------------------------------------------------------------------------
+ def generMCFACT(self,obj) :
+ """recuperation de l objet MCFACT"""
+ if self.debug:
+ print "MCFACT debut %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ dico={}
+ self.dicoMCFACTCourant=dico
+ self.dicoCourant=self.dicoMCFACTCourant
+ s=PythonGenerator.generMCFACT(self,obj)
+ # sauvegarde, dans self.dicoEtapeCourant, de la valeur du FACT courant, pour utilisation ultérieure dans generETAPE et generPROC_ETAPE
+ # traitement des FACT CUTLINE et CUTPLANE multiples (max='**' dans le catalogue)
+ # Ce traitement spécial est nécessaire pour le moment car le générateur bogue sinon au niveau des matériaux (non-linéaires ?)
+ if obj.nom in ('FIELDDUMP','CUTLINE', 'CUTPLANE', 'FIELDMAP', 'VISU3D' ):
+ # Remplissage se self.dicoEtapeCourant pour le nom du FACT courant
+ # Il ne contient qu'une seule valeur (un dictionnaire) par défaut lorsque le FACT est unique (max=1 dans le catalogue),
+ # mais il peut aussi contenir plusieurs valeurs (tableau) dans le cas contraire, e.g., max='**' dans le catalogue
+ if self.dicoEtapeCourant.has_key(obj.nom): # plusieurs valeurs
+ print "self.dicoEtapeCourant= %s"%self.dicoEtapeCourant
+ if type(self.dicoEtapeCourant[obj.nom]) == types.DictType: # une seule valeur entrée jusqu'à présent
+ dicoMCFACTprecedent = self.dicoEtapeCourant[obj.nom] # sauvegarde de la valeur précédente
+ print "dicoMCFACTpreceden= %s self.dicoEtapeCourant= %s"%(dicoMCFACTprecedent,self.dicoEtapeCourant)
+ self.dicoEtapeCourant[obj.nom] = [ dicoMCFACTprecedent, self.dicoMCFACTCourant ] # restructuration en liste et insertion de la valeur précédente et de la valeur courant
+ print "self.dicoEtapeCourant[obj.nom]= %s"%self.dicoEtapeCourant[obj.nom]
+ else: # plusieurs valeurs entrées jusqu'à présent, sous la forme d'une liste de dictionnaires
+ self.dicoEtapeCourant[obj.nom].append(self.dicoMCFACTCourant) # extension de la liste avec cette valeur, placée en dernier
+ else: # une seule valeur ou première valeur
+ self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
+ else: # traitement usuel des FACT uniques, pour ignorer le bogue décrit plus haut
+ self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=self.dicoEtapeCourant
+ if self.debug:
+ print "MCFACT fin %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ return s
+
+
+#----------------------------------------------------------------------------------------
+ def generPROC_ETAPE(self,obj):
+ """analyse des PROC du catalogue ( VERSION )"""
+ if self.debug:
+ print "PROC_ETAPE initial: %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant # on passe à obj la bonne structure générée par PythonGenerator.generPROC_ETAPE, pour le traitement de chaque partie ci-dessous
+ if self.debug:
+ print "PROC_ETAPE mis a jour: %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
+ if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
+ if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
+ s=PythonGenerator.generPROC_ETAPE(self,obj) # obj.valeur a été modifiée pour le traitement ci-dessus, alors il faut tout remettre en ordre en appelant de nouveau PythonGenerator.generPROC_ETAPE
+ return s
+
+
+
+#----------------------------------------------------------------------------------------
+ def generETAPE(self,obj):
+ """analyse des OPER du catalogue"""
+ if self.debug:
+ print "ETAPE mis a jour: obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant # cf. generPROC_ETAPE
+ if self.debug:
+ print "ETAPE mis a jour: obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
+ if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
+ if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
+ if obj.nom=="SOURCE" : self.generSOURCE(obj)
+ if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
+ if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
+ s=PythonGenerator.generETAPE(self,obj) # cf. generPROC_ETAPE
+ return s
+
+#----------------------------------------------------------------------------------------
+ def generMACRO_ETAPE(self,obj):
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ import generator
+ monGenerateur=generator.plugins[nomPlugin]()
+ jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
+ if self.debug:
+ print "jdc_aux_texte : %s" % jdc_aux_texte
+
+ for cle in monGenerateur.dictMaterConductor:
+ self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
+ for cle in monGenerateur.dictMaterDielectric:
+ self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
+ for cle in monGenerateur.dictMaterZsurfacic:
+ self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
+ for cle in monGenerateur.dictMaterEmIso:
+ self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
+ for cle in monGenerateur.dictMaterEmAnIso:
+ self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
+ for cle in monGenerateur.dictMaterNilmat:
+ self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
+ for cle in monGenerateur.dictMaterZinsulator:
+ self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
+
+ print "________FIN MACRO______________________________________"
+ s=PythonGenerator.generMACRO_ETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+#----------------------------------------------------------------------------------------
+ def generMESHGROUP(self,obj):
+ """preparation de la ligne NAME referencant le groupe de mailles
+ associe le groupe de mailles au materiau ou a la source utilisateur
+ on sauvegarde aussi les noms des groupes de maillage
+ """
+ try:
+ if usePrefix:
+ nomGroupe = self.nomReelGroupe(obj.getSdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+ else:
+ nomGroupe = obj.getSdname() # nom du groupe de maillage, i.e. nom du concept
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
+ #
+ # on utilise le fait que obj.valeur est un dictionnaire
+ self.dictGroupes[nomGroupe] = {}
+# nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ raise ValueError, nomGroupe + tr(" : ce groupe de maillage ne peut pas etre associe a un materiau et une source a la fois.")
+ # association a un materiau
+ if 'MATERIAL' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
+ # association a une source
+ if 'SOURCE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['STRAND'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ if 'Domaine' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
+ self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
+ texte=""
+ texte+="%s"%(obj.valeur['Domaine'])
+ print"le texte=%s" %(texte)
+ self.dictDomaine[obj.getSdname()]=texte
+ print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
+
+# else:
+# raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
+ if self.debug:
+ print "self.dictGroupes= %s" % repr(self.dictGroupes)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMACRO_GROUPE(self, obj):
+ """preparation de la ligne NAME referencant le groupe de mailles
+ associe le groupe de mailles au materiau ou a la source utilisateur
+ on sauvegarde aussi les noms des macros groupes
+ """
+ try:
+ #nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
+ if usePrefix:
+ nomGroupe = self.nomReelGroupe(obj.getSdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+ else:
+ nomGroupe = obj.getSdname() # nom du macro groupe
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+ self.dictGroupes[nomGroupe] = {}
+
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
+ #
+ # on utilise le fait que obj.valeur est un dictionnaire
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ raise ValueError, nomgroupe + tr(" : ce MACRO_GROUPE ne peut pas contenir a la fois un MATERIAL et une SOURCE.")
+ # association a une source
+ if 'SOURCE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ if 'LISTE_MESHGROUP' in obj.valeur.keys():
+ listeStrandedInductorGeometry = True # indicateur du fait que tous les groupes de la liste sont des inducteurs bobinés ou topologiques, en morceaux ou entier (True), ou non (False). Utilisé pour savoir si le Domaine est nécessaire ou non.
+ listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes[nomGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
+ groupe = groupe.replace("'", "") # suppression des guillement simpes
+ groupe = groupe.replace('"', "") # suppression des guillement doubles
+ self.dictGroupes[nomGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
+ if not self.dictGroupes[groupe].has_key('STRAND'): listeStrandedInductorGeometry = False # au moins un groupe de la liste n'est pas un inducteur bobiné ou topologique (morceau ou entier).
+ self.dictGroupes['ordreListeJdC'].append(nomGroupe) # sauvegarde du nom du macro groupe associe a une source, dans l'ordre du JdC
+ if not listeStrandedInductorGeometry: # Erreur en cas de liste ne définissant pas que des inducteurs bobinés ou topologiques en morceaux
+ raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE ne doit contenir, dans LISTE_MESHGROUP, que des morceaux d'inducteurs bobines ou topologiques.")
+ # test de présence du domaine pour les cas appropriés d'inducteur bobiné ou topologique en morceau.
+ if 'Domaine' in obj.valeur.keys():
+ if listeStrandedInductorGeometry: # Domaine seulement en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
+ self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
+ self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
+ texte=""
+ texte+="%s"%(obj.valeur['Domaine'])
+ print"le texte=%s" %(texte)
+ self.dictDomaine[obj.getSdname()]=texte
+ else: # Erreur si Domaine et macro-groupe pas complètement inducteur
+ raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE ne doit pas contenir de Domaine car il contient, dans LISTE_MESHGROUP, des groupes qui ne sont pas que des morceaux d'inducteurs bobines ou topologiques.")
+ else: # Domaine manquant
+ if listeStrandedInductorGeometry: # Erreur en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
+ raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE de morceaux d'inducteurs bobines ou topologiques doit contenir aussi un Domaine.")
+ else:
+ raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE doit contenir une liste de groupes LISTE_MESHGROUP.")
+ if self.debug:
+ print "self.dictGroupes= %s" % repr(self.dictGroupes)
+ print "self.dictDomaine=%s" %(self.dictDomaine)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+
+ def generSOLVEUR(self, obj):
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['Type']
+ if nature == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOLVEUR_LINEAIRE(self, obj):
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['Methode_lineaire']
+ if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
+ if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMETHODE_ITERATIVE_BICGCR(self, obj):
+ texte=""
+ if self.debug:
+ print "_____________iter_____________"
+
+ self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
+ self.texteCarmel3D_PARAM_SOLV+=" NAME BICGCR\n"
+ self.texteCarmel3D_PARAM_SOLV+=" [ITERATIVE_PARAM \n"
+ self.texteCarmel3D_PARAM_SOLV+=" NITERMAX "+str(obj.valeur["Nombre_iterations_max"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" EPSILON "+str(obj.valeur["Precision"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
+ if self.debug:
+ print "texte = %s", texte
+
+
+ def generMETHODE_DIRECTE_MUMPS(self, obj):
+ texte=""
+ if self.debug:
+ print "_____________directe_____________"
+
+ self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
+ self.texteCarmel3D_PARAM_SOLV+=" NAME MUMPS\n"
+ self.texteCarmel3D_PARAM_SOLV+=" [MUMPS_PARAMETER \n"
+ self.texteCarmel3D_PARAM_SOLV+=" SYM "+str(obj.valeur["Type_de_matrice"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" ICNTL "+str(obj.valeur["ICNTL_Control_Parameters"])+" "+str(obj.valeur["CNTL_Control_Parameters"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
+ if self.debug:
+ print "texte = %s", texte
+
+
+
+ def generMATERIAL(self,obj):
+ """preparation du bloc correspondant a un materiau du fichier PHYS"""
+ texte=""
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
+ if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
+ if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
+ if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
+ if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
+ if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
+ if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
+ if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMATERIAL_CONDUCTOR(self,obj):
+ """preparation du sous bloc CONDUCTOR"""
+ texte=""
+ if self.debug:
+ print "_____________cond_____________"
+ # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
+ if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
+ print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.getSdname()
+ raise ValueError, obj.getSdname() + tr(" : ce materiau conducteur (CONDUCTOR) doit contenir les proprietes PERMEABILITY et CONDUCTIVITY.")
+ else:
+ # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
+ for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
+ # seuls les reels sont pris en compte
+ if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
+ texte+=" [NONLINEAR \n"
+ texte+=" ISOTROPY TRUE\n"
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
+ # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
+ for keyN2 in obj.valeur[keyN1] :
+ if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
+ # fin du sous-bloc NONLINEAR
+ texte+=" ]"+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s", texte
+ self.dictMaterConductor[obj.getSdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
+
+ def generMATERIAL_DIELECTRIC(self,obj):
+ """preparation du sous bloc DIELECTRIC"""
+ texte=""
+ if self.debug:
+ print "______________nocond_____________"
+ # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
+ if 'PERMITTIVITY' not in obj.valeur:
+ print "obj.valeur=%s" %obj.valeur
+ obj.valeur["PERMITTIVITY"]={'HOMOGENEOUS': 'TRUE', 'LAW': 'LINEAR', 'ISOTROPIC': 'TRUE', 'VALUE': 1}
+
+ # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
+ for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
+ # seuls les reels sont pris en compte
+ if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
+ texte+=" [NONLINEAR \n"
+ texte+=" ISOTROPY TRUE\n"
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
+ # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
+ for keyN2 in obj.valeur[keyN1] :
+ if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
+ # fin du sous-bloc NONLINEAR
+ texte+=" ]"+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s" % texte
+ self.dictMaterDielectric[obj.getSdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
+
+ def generMATERIAL_ZSURFACIC(self,obj):
+ """preparation du sous bloc ZSURFACIC"""
+ texte=""
+ if self.debug:
+ print "______________zsurf_____________"
+ # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
+ if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
+ print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.getSdname()
+ raise ValueError, obj.getSdname() + tr(" : ce materiau impedance de surface (ZSURFACIC) doit contenir les proprietes PERMEABILITY et CONDUCTIVITY.")
+ else:
+ # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
+ for keyN1 in obj.valeur :
+ if keyN1=='TYPE': continue
+ # print "type loi = ", obj.valeur[keyN1]['LAW']
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s", texte
+ self.dictMaterZsurfacic[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
+
+ def generMATERIAL_EMISO(self,obj):
+ """preparation du sous bloc EM_ISOTROPIC_FILES.
+ Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
+ ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
+ """
+ if "CONDUCTIVITY_File" in obj.valeur:
+ texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
+ if "PERMEABILITY_File" in obj.valeur:
+ texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
+ # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
+ #from os.path import basename
+ #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
+ #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
+ # print "obj get sdname= ", obj.getSdname()
+ # if obj.getSdname() in self.dictMaterEmIso.keys() :
+ # self.dictMaterEmIso[obj.getSdname()].append(texte)
+ # else :
+ self.dictMaterEmIso[obj.getSdname()]=texte
+
+ def generMATERIAL_EMANISO(self,obj):
+ """preparation du sous bloc EM_ANISOTROPIC_FILES.
+ Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
+ ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
+ """
+ if "CONDUCTIVITY_File" in obj.valeur:
+ texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
+ if "PERMEABILITY_File" in obj.valeur:
+ texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
+ # print "obj get sdname= ", obj.getSdname()
+ # if obj.getSdname() in self.dictMaterEmAnIso.keys() :
+ # self.dictMaterEmAnIso[obj.getSdname()].append(texte)
+ # else :
+ self.dictMaterEmAnIso[obj.getSdname()]=texte
+
+ def generMATERIAL_NILMAT(self,obj):
+ """preparation du sous bloc NILMAT"""
+ texte=""
+ self.dictMaterNilmat[obj.getSdname()]=texte
+
+ def generMATERIAL_ZINSULATOR(self,obj):
+ """"preparation du sous bloc ZINSULATOR"""
+ texte=""
+ self.dictMaterZinsulator[obj.getSdname()]=texte
+
+#-------------------------------------------------------------------
+
+ def generSOURCE(self,obj):
+ """preparation du bloc correspondant a une source du fichier PHYS"""
+ if self.debug:
+ print "generation source obj valeur = %s" % obj.valeur
+ texte=""
+ try :
+ # test de la presence des types de sources reconnus
+ # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "STRANDED_INDUCTOR" in obj.valeur:
+ self.generSOURCE_STRANDED_INDUCTOR(obj)
+ elif "HPORT" in obj.valeur:
+ self.generSOURCE_HPORT(obj)
+ elif "EPORT" in obj.valeur:
+ self.generSOURCE_EPORT(obj)
+ else:
+ print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOURCE_STRANDED_INDUCTOR(self,obj):
+ """preparation du sous bloc STRANDED_INDUCTOR"""
+ texte=""
+ sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ try :
+ texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
+ self.nturns=sdict['NTURNS']
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ self.dictSourceStInd[obj.getSdname()]=texte
+ if self.debug:
+ print texte
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOURCE_HPORT(self,obj):
+ """preparation du sous bloc HPORT"""
+ texte=""
+ sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ nomPort = obj.getSdname()
+ self.dictPort[nomPort] = {}
+ self.dictPort[nomPort]['HPORT']=str(sdict['TYPE'])
+ try :
+ texte+=" TYPE %s\n" % str(sdict['TYPE'])
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ self.dictSourceHport[obj.getSdname()]=texte
+ if self.debug:
+ print texte
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOURCE_EPORT(self,obj):
+
+
+ """preparation du sous bloc EPORT"""
+ texte=""
+ sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ nomPort = obj.getSdname()
+ self.dictPort[nomPort] = {}
+ self.dictPort[nomPort]['EPORT']=str(sdict['TYPE'])
+ print "sdict=%s" %(sdict)
+ try :
+ texte+=" TYPE %s\n" % str(sdict['TYPE'])
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ self.dictSourceEport[obj.getSdname()]=texte
+ if self.debug:
+ print texte
+ except ValueError, err:
+ raise ValueError, str(err)
+
+#
+ def generPARAM_CIRCULAIRE(self, obj):
+ if self.debug:
+ print "generation stranded inductor geometry obj.valeur = %s" % obj.valeur
+ self.centre=obj.valeur["Centre"]
+
+ def generPOST_COMMANDS(self, obj):
+ """Création du texte de commandes de post-traitement toto.cmd"""
+ if self.debug:
+ print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
+
+ if obj.valeur.has_key('GLOBAL'):
+ self.texteCarmel3D_CMD+="[\nGLOBAL\n]\n"
+
+ if obj.valeur.has_key('DUMP'):
+ champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
+ self.texteCarmel3D_CMD+="[\nDUMP"
+ self.texteCarmel3D_CMD+="\n"+self.projet + '_postgroups.txt'
+ self.texteCarmel3D_CMD+="\n"+champsFieldkind[obj.valeur["DUMP"]["fieldkind"]]+"\n]\n"
+
+ if obj.valeur.has_key('FIELDDUMP'):
+ champs = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD', 'pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'}
+ champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
+ self.texteCarmel3D_CMD+="[\nFIELDDUMP"
+ if type(obj.valeur["FIELDDUMP"]) == types.DictType: # correspondance sur une 'Fielddump'
+ self.fielddumpValeur.append(obj.valeur["FIELDDUMP"])
+ else:
+ self.fielddumpValeur=obj.valeur["FIELDDUMP"] # correspondance sur plusieurs 'Fielddump'
+ for indexFielddump in self.fielddumpValeur:
+ self.texteCarmel3D_CMD+="\n [\n" +" "+ champs[indexFielddump["field"]]
+ self.texteCarmel3D_CMD+="\n" + " " + champsFieldkind[indexFielddump["fieldkind"]] + "\n ]"
+ self.texteCarmel3D_CMD+="\n]\n"
+
+
+ if obj.valeur.has_key('VISU'):
+ self.texteCarmel3D_CMD+="[\nVISU"
+ # test de fichier de maillage bien lu
+ if self.fichierMaillage == "": raise ValueError, tr("Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au-dessus du bloc POST_COMMANDS.")
+ self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
+ self.texteCarmel3D_CMD+=obj.valeur["VISU"]["visu_format"]+"\n"
+ self.texteCarmel3D_CMD+=obj.valeur["VISU"]["visu_type"]+"\n]\n"
+
+ if obj.valeur.has_key('VISU3D'):
+ champsField = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD', 'pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
+ champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
+ if type(obj.valeur["VISU3D"])==types.DictType: # correspondance sur une 'VISU3D'
+ self.visu3dValeur.append(obj.valeur["VISU3D"])
+ else:
+ self.visu3dValeur=obj.valeur["VISU3D"] # correspondance sur plusieurs 'VISU3D'
+ self.texteCarmel3D_CMD+="[\nVISU3D"
+ if self.fichierMaillage == "": raise ValueError, tr("Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au-dessus du bloc POST_COMMANDS.")
+ self.texteCarmel3D_CMD+="\n"+ self.projet
+ self.texteCarmel3D_CMD+="\n" + self.visu3dValeur[0]["visu_format"]
+ for indexVisu3d in self.visu3dValeur:
+ if indexVisu3d["visu_format"]!=self.visu3dValeur[0]["visu_format"]:
+ print "ERREUR! Dans les multiples VISU3D du bloc POST_COMMANDS, le parametre visu_format doit prendre la meme valeur."
+ raise ValueError, tr("Dans les multiples VISU3D du bloc POST_COMMANDS, le parametre visu_format doit prendre la meme valeur.")
+ self.texteCarmel3D_CMD+="\n [\n " + champsField[indexVisu3d["field"]]
+ self.texteCarmel3D_CMD+="\n "+ champsFieldkind[indexVisu3d["fieldkind"]]
+ self.texteCarmel3D_CMD+="\n "+ indexVisu3d["visu_type"]+"\n ]"
+ self.texteCarmel3D_CMD+="\n]\n"
+
+ if obj.valeur.has_key('ASTER_RMS_LOSSES'):
+ self.texteCarmel3D_CMD+="[\nASTER_RMS_LOSSES"
+ if self.fichierMaillage == "": raise ValueError, tr("Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au-dessus du bloc POST_COMMANDS.")
+ self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
+ self.texteCarmel3D_CMD+= obj.valeur["ASTER_RMS_LOSSES"]["rms_losses_format"] +"\n]\n"
+
+ if obj.valeur.has_key('CUTLINE'):
+ # création du champ, renommé par rapport à l'interface
+ champsField = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD', 'pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD', 'T':'TFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
+ champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
+ champsOutput={'xgraphic':'XGRAPHIC', 'gnuplot':'GNUPLOT', 'gmsh':'GMSH'}
+ champsLissage={'aucun':'NONE', 'un seul point par element':'1PTELT'}
+ if type(obj.valeur["CUTLINE"]) == types.DictType: # correspondance sur une 'Cutline'
+ self.cutlineValeur.append(obj.valeur["CUTLINE"]) # transfert d'une dictionnaire à une liste
+ else:
+ self.cutlineValeur=obj.valeur["CUTLINE"] # correspondance sur plusieurs 'Cutline'
+ for indexCutline in self.cutlineValeur:
+ self.texteCarmel3D_CMD+="[\nCUTLINE"
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexCutline["first_point"]), )
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexCutline["last_point"]), )
+ self.texteCarmel3D_CMD+="\n%d" % (indexCutline["number_of_points"], )
+ self.texteCarmel3D_CMD+="\n" +indexCutline["name"]
+ self.texteCarmel3D_CMD+="\n" + champsField[indexCutline["field"]]
+ if indexCutline.has_key('fieldkind'):
+ self.texteCarmel3D_CMD+="\nFIELDKIND " + champsFieldkind[indexCutline["fieldkind"]]
+ if indexCutline.has_key('output'):
+ self.texteCarmel3D_CMD+="\nOUTPUT " +champsOutput[indexCutline["output"]]
+ if indexCutline.has_key('lissage'):
+ self.texteCarmel3D_CMD+="\nSMOOTHLEVEL " +champsLissage[indexCutline["lissage"]]
+ self.texteCarmel3D_CMD+="\n]\n"
+
+ if obj.valeur.has_key('CUTPLANE'):
+ champs = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD','pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
+ champsFieldkind= {'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
+ champsOutput={'xgraphic':'XGRAPHIC', 'gnuplot':'GNUPLOT', 'gmsh':'GMSH'}
+ champsLissage={'aucun':'NONE', 'un seul point par element':'1PTELT'}
+ axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
+ if type(obj.valeur["CUTPLANE"]) == types.DictType:
+ self.cutplaneValeur.append(obj.valeur["CUTPLANE"]) # correspondance sur une 'Cutplane'
+ else:
+ self.cutplaneValeur=obj.valeur["CUTPLANE"] # correspondance sur plusieurs 'Cutplane'
+ for indexCutplane in self.cutplaneValeur:
+ self.texteCarmel3D_CMD+="[\nCUTPLANE"
+ self.texteCarmel3D_CMD+="\n%d" % (axes[indexCutplane["normal_vector"]], )
+ self.texteCarmel3D_CMD+="\n%f" % (indexCutplane["plane_position"], )
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexCutplane["number_of_points"]))
+ self.texteCarmel3D_CMD+="\n" + indexCutplane["name"]
+ self.texteCarmel3D_CMD+="\n" + champs[indexCutplane["field"]]
+ if indexCutplane.has_key('fieldkind'):
+ self.texteCarmel3D_CMD+="\nFIELDKIND " + champsFieldkind[indexCutplane["fieldkind"]]
+ if indexCutplane.has_key('output'):
+ self.texteCarmel3D_CMD+="\nOUTPUT " +champsOutput[indexCutplane["output"]]
+ if indexCutplane.has_key('lissage'):
+ self.texteCarmel3D_CMD+="\nSMOOTHLEVEL " +champsLissage[indexCutplane["lissage"]]
+ self.texteCarmel3D_CMD+="\n]\n"
+
+ if obj.valeur.has_key('FIELDMAP'):
+ champs = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD','pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
+ champsFieldkind= {'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
+ champsOutput={'xgraphic':'XGRAPHIC', 'gnuplot':'GNUPLOT', 'gmsh':'GMSH'}
+ champsFieldmap_type={'equation':'EQUATION', 'fichier':'FILE'}
+ champsType={'plane':'PLANE', 'line':'LINE'}
+ axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
+ if type(obj.valeur["FIELDMAP"]) == types.DictType:
+ self.fieldmapValeur.append(obj.valeur["FIELDMAP"]) # correspondance sur une 'Fieldmap'
+ else:
+ self.fieldmapValeur=obj.valeur["FIELDMAP"]# correspondance sur plusieurs 'Fieldmap'
+ for indexFieldmap in self.fieldmapValeur:
+ self.texteCarmel3D_CMD+="[\nFIELDMAP"
+ self.texteCarmel3D_CMD+="\n" + champsFieldmap_type[indexFieldmap["fieldmap_type"]]
+ if indexFieldmap["fieldmap_type"]=="equation":
+ self.texteCarmel3D_CMD+="\n" + champsType[indexFieldmap["type"]]
+ if indexFieldmap["type"]=="line":
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexFieldmap["first_point"]), )
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexFieldmap["last_point"]), )
+ self.texteCarmel3D_CMD+="\n%d" % (indexFieldmap["number_of_points"], )
+ if indexFieldmap["type"]=="plane":
+ self.texteCarmel3D_CMD+="\n%d" % (axes[indexFieldmap["normal_vector"]], )
+ self.texteCarmel3D_CMD+="\n%f" % (indexFieldmap["plane_position"], )
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexFieldmap["number_of_points"]))
+ if indexFieldmap["fieldmap_type"]=="fichier":
+ self.fichierFieldmap=indexFieldmap["filename"]
+ self.nomFichierFieldmap = os.path.basename(self.fichierFieldmap) # nom du fichier de fieldmap, sans le chemin
+ self.texteCarmel3D_CMD+="\n" + self.nomFichierFieldmap
+ self.texteCarmel3D_CMD+="\n" + champs[indexFieldmap["field"]]
+ self.texteCarmel3D_CMD+="\n" + champsFieldkind[indexFieldmap["fieldkind"]]
+ self.texteCarmel3D_CMD+="\n" +indexFieldmap["name"] # nom systématique, quel que soit le fieldmap_type, placé entre fieldkind et output
+ self.texteCarmel3D_CMD+="\n" +champsOutput[indexFieldmap["output"]]
+ self.texteCarmel3D_CMD+="\n]\n"
+
+
+
+
+#---------------------------------------------------------------------------------------
+# traitement fichier PHYS
+#---------------------------------------------------------------------------------------
+ def generBLOC_VERSION(self,obj) :
+ # constitution du bloc VERSION du fichier PHYS
+ # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
+ # dans le du catalogue
+ version=obj.addEntite('VERSION',pos=None)
+ self.generPROC_ETAPE(obj.etapes[0])
+ self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
+ for cle in obj.etapes[0].valeur :
+ self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
+ self.texteCarmel3D+="]\n"
+ # destruction de l entite creee
+ obj.suppEntite(version)
+ #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
+ #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
+
+
+ def generBLOC_PARAMETERS(self,obj):
+ if self.debug:
+ print "generation parameters obj.valeur = %s" % obj.valeur
+
+ self.frequency=obj.valeur["FREQUENCY"]
+ self.repertory=obj.valeur["RepCarmel"]
+ self.fichierMaillage=obj.valeur["Fichier_maillage"]
+ self.nomFichierMaillage = os.path.basename(self.fichierMaillage) # nom du fichier de maillage, sans le chemin
+ self.projet = self.nomFichierMaillage.split(".")[0] # nom du projet, utilisé un peu partout, équivalent au nom du fichier de maillage sans l'extension
+ self.echelle=obj.valeur["Echelle_du_maillage"]
+ self.gendof=obj.valeur["Realiser_topologie_gendof"]
+ self.fcarmel=obj.valeur["Resoudre_probleme"]
+ self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
+ self.formulation=obj.valeur["Formulation"]
+#----------------------------------------------------------------------------------------
+ def generBLOC_MATERIALS(self) :
+ """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
+ Le bloc MATERIALS existe toujours !
+ """
+ if self.debug:
+ print "cle dictionnaire materconductor : %s" % self.dictMaterConductor.keys()
+ print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()
+ # constitution du bloc MATERIALS du fichier PHYS
+ self.texteCarmel3D+="[MATERIALS\n"
+ # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
+ nomsGroupes = self.dictGroupes['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
+ nomsGroupes.sort() # tri alphabetique, avec les prefixes eventuels
+ if self.debug:
+ print "noms groupes de mailles associes a des materiaux \
+ (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \
+ {'v_1': self.dictGroupes['ordreMateriauxJdC'], \
+ 'v_2': nomsGroupes}
+ try: # mise à jour du fichier .phys selon les matériaux trouvés
+ # constitution du bloc CONDUCTOR du fichier PHYS si existe
+ if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupes)
+ # constitution du bloc DIELECTRIC du fichier PHYS si exixte
+ if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupes)
+ # constitution du bloc ZSURFACIC du fichier PHYS si exixte
+ if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupes)
+ # constitution du bloc NILMAT du fichier PHYS si exixte
+ if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupes)
+ # constitution du bloc ZINSULATOR du fichier PHYS si exixte
+ if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupes)
+ # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
+ # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
+ if self.dictMaterEmIso != {} and self.materiauxGroupesTousIsotropes and not self.materiauxGroupesTousHomogenes : self.creaBLOC_EMISO() # bloc isotrope si au moins un matériau isotrope et non homogene
+ # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
+ if self.dictMaterEmAnIso != {} and not self.materiauxGroupesTousIsotropes : self.creaBLOC_EMANISO() # bloc non isotrope si au moins un matériau non isotrope
+ except ValueError, err:
+ raise ValueError(str(err))
+
+
+ # fin du bloc MATERIALS du fichier PHYS
+ self.texteCarmel3D+="]\n"
+
+
+
+ def creaBLOC_CONDUCTOR(self, nomsGroupes) :
+ """Constitution du bloc CONDUCTOR du fichier PHYS"""
+ typeBloc = 'CONDUCTOR' # initialisation du type de bloc
+ dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
+ print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
+ raise ValueError, self.dictGroupes[nom]['MATERIAL'][:] + ',' + nom + tr(" : ce materiau (nom, groupe associe) doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement.")
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE' \
+ or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE' \
+ or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_DIELECTRIC(self, nomsGroupes) :
+ """Constitution du bloc DIELECTRIC du fichier PHYS"""
+ typeBloc = 'DIELECTRIC' # initialisation du type de bloc
+ dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ print "jdc materiaux= %s" %(self.dictGroupes['ordreMateriauxJdC'])
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
+ print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
+ raise ValueError, self.dictGroupes[nom]['MATERIAL'][:] + ',' + nom + tr(" : ce materiau (nom, groupe associe) doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement.")
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_ZSURFACIC(self, nomsGroupes) :
+ """Constitution du bloc ZSURFACIC du fichier PHYS"""
+ typeBloc = 'ZSURFACIC' # initialisation du type de bloc
+ dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_EMISO(self) :
+ """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
+ for cle in self.dictMaterEmIso.keys():
+ self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
+ self.texteCarmel3D+= self.dictMaterEmIso[cle]
+ self.texteCarmel3D+=" ]\n"
+
+ def creaBLOC_EMANISO(self) :
+ """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
+ for cle in self.dictMaterEmAnIso.keys():
+ self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
+ self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
+ self.texteCarmel3D+=" ]\n"
+
+ def creaBLOC_ZINSULATOR(self, nomsGroupes) :
+ """Constitution du bloc ZINSULATOR du fichier PHYS"""
+ typeBloc = 'ZINSULATOR' # initialisation du type de bloc
+ dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
+ if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_NILMAT(self, nomsGroupes) :
+ """Constitution du bloc NILMAT du fichier PHYS"""
+ typeBloc = 'NILMAT' # initialisation du type de bloc
+ dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+#----------------------------------------------------------------------------------------
+ def generBLOC_SOURCES(self):
+ """constitution du bloc SOURCES du fichier PHYS"""
+ self.texteCarmel3D+="[SOURCES\n"
+# # tri alphabetique de tous les groupes de maillage associes a des sources
+ nomsGroupes = self.dictGroupes['ordreSourcesJdC'][:]
+ nomsGroupes.sort()
+ # print "RESULTAT APRES FUSION self.dictGroupes= %s" %(self.dictGroupesnomsGroupes)
+
+ if self.debug:
+ print 'noms groupes de mailles associes a des sources \
+ (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \
+ {'g_maillage_orig': self.dictGroupes['ordreSourcesJdC'], \
+ 'g_maillage_trie': nomsGroupes}
+ if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupes)
+ if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupes)
+ if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupes)
+ # fin du bloc SOURCES du fichier PHYS
+ self.texteCarmel3D+="]\n"
+
+
+ def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupes) :
+ """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
+ if self.debug:
+ print 'cles sources STRANDED_INDUCTOR= %s' % self.dictSourceStInd.keys()
+ typeBloc = 'STRANDED_INDUCTOR'
+# print "liste des NOM=%s" %(nom)
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
+ # ecriture du bloc de l'inducteur bobine
+ self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes de l'inducteur bobine
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_EPORT(self, nomsGroupes) :
+ """constitution du bloc EPORT du fichier PHYS"""
+ if self.debug:
+ print 'cles sources EPORT= %s' % self.dictSourceEport.keys()
+ typeBloc = 'EPORT'
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
+ # ecriture du bloc du port electrique
+ self.texteCarmel3D+=" [EPORT\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceEport[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes du port electrique
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_HPORT(self, nomsGroupes) :
+ """constitution du bloc HPORT du fichier PHYS"""
+ if self.debug:
+ print 'cles sources HPORT= %s' % self.dictSourceHport.keys()
+ typeBloc = 'HPORT'
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
+ # ecriture du bloc du port magnetique
+ self.texteCarmel3D+=" [HPORT\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceHport[self.dictGroupes[nom]['SOURCE'][:]] # ecriture des proprietes du port magnetique
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
+ """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
+
+ texte=""
+ self.direction=obj.valeur["Direction"]
+ self.section=obj.valeur["Section"]
+ self.forme=obj.valeur["Forme"]
+# texte+="\n%s" %(self.domaine)
+
+ if self.forme=="Circulaire" : self.generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(obj)
+ else:
+ texte+="\n1"
+ texte+="\n%s" % ' '.join(map(str, self.direction))
+ texte+="\n%g" % (self.section)
+ self.dictStrand[obj.getSdname()]=texte
+ if self.debug:
+ print texte
+
+ def generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(self, obj):
+ texte=""
+ self.centre=obj.valeur["Centre"]
+ texte+="\n2"
+ texte+="\n%s" % ' '.join(map(str,self.direction))
+ texte+="\n%s" % ' '.join(map(str, self.centre))
+ texte+="\n%g" % (self.section)
+ self.dictStrand[obj.getSdname()]=texte
+ if self.debug:
+ print texte
+
+
+ def creaBLOC_STRANDED_INDUCTOR_GEOMETRY(self, nomsGroupes):
+ """Ecriture de chaque inducteur bobiné dans le in.gendof. Gestion des inducteurs en un ou plusieurs morceaux, avec le domaine.
+ Attention! L'argument nomSGroupes n'est pas utile ici. A supprimer. Routine à renommer aussi.
+ """
+ if self.debug:
+ print 'dictGroupes=', self.dictGroupes
+ print 'cles sources STRANDED_INDUCTOR_GEOMETRY= %s' % self.dictStrand.keys()
+ print "nomsGroupes=%s" %(nomsGroupes)
+ nomsSources=self.dictGroupes['ordreDomaineJdC']
+ nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
+ if self.debug: print"nomsSources=%s" %nomsSources
+ for nom in nomsSources:
+ if self.debug: print "nomSource courant=",nom
+ if self.dictGroupes[nom].has_key('SOURCE'):
+ if self.dictGroupes[nom]['SOURCE'] not in self.dictPort :
+ if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, nom + tr(" : il manque un Domaine a cet inducteur.")
+ self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
+ else:
+ if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, nom + tr(" : il manque un Domaine a cet inducteur.")
+ self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
+ if self.dictGroupes[nom].has_key('STRAND'): # inducteur en un seul morceau
+ if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, nom + tr(" : il manque un Domaine a cet inducteur.")
+ strand = self.dictGroupes[nom]['STRAND']
+ if self.debug: print "un seul morceau : nomStrand courant=", strand
+ self.texteCarmel3D_INGEND2+= self.dictStrand[strand]
+ if self.dictGroupes[nom].has_key('LISTE'): # inducteur en plusieurs morceaux
+ listeStrand = self.dictGroupes[nom]['LISTE'] # liste des groupes de maillage composant l'inducteur, ou groupe tout seul si inducteur en un seul morceau
+ for strand in listeStrand:
+ #strand = strand.replace("'", "") # suppression des guillemets simples
+ if self.debug: print "plusieurs morceaux : nomStrand courant=",strand
+ if self.debug: print "self.dictGroupes[strand]=", self.dictGroupes[strand]
+ self.texteCarmel3D_INGEND2+= self.dictStrand[self.dictGroupes[strand]['STRAND'] ]
+
+ def creaBLOC_PORTS_GEOMETRY(self, nomsGroupes):
+ if self.debug:
+ print "self.dictSourceEport=", self.dictSourceEport
+ print "self.dictSourceHport=", self.dictSourceHport
+ nomsSources=self.dictGroupes['ordreDomaineJdC']
+ nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
+
+ for nom in nomsSources:
+ port=self.dictGroupes[nom]['SOURCE']
+ if self.dictGroupes[nom]['SOURCE'] in self.dictPort :
+ self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
+ port=self.dictGroupes[nom]['SOURCE']
+
+ if self.dictPort[port].has_key('EPORT'):# inducteur en un seul morceau
+ if self.dictPort[port]['EPORT']=="VOLTAGE":
+ self.texteCarmel3D_INGEND2+= "\n1"
+ else:
+ self.texteCarmel3D_INGEND2+= "\n2"
+ if self.dictPort[port].has_key('HPORT'):# inducteur en un seul morceau
+ if self.dictPort[port]['HPORT']=="VOLTAGE":
+ self.texteCarmel3D_INGEND2+= "\n1"
+ else:
+ self.texteCarmel3D_INGEND2+= "\n2"
+
+#-------------------------------------
+# Methodes utilitaires
+# ------------------------------------
+ def formateCOMPLEX(self,nbC):
+ """prise en compte des differentes formes de description d un nombre complexe
+ 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
+ """
+ if self.debug:
+ print "formatage"
+ print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
+ nbformate =""
+ if isinstance(nbC,(tuple,list)):
+ if nbC[0] == "'RI'" :
+ nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
+ if nbC[0] == "'MP'" :
+ nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
+ else:
+ nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
+ if self.debug:
+ print "nbformate : %s" % nbformate
+ return nbformate
+
+ def nomReelGroupe(self, nom, typeBloc=None):
+ """Calcule et retourne le nom reel du groupe de maillage donne en entree,
+ en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
+ de bloc du fichier PHYS specifie.
+ Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
+ """
+ from string import join
+ if self.debug:
+ print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
+ {'nom': nom, 'use_prefix': str(usePrefix)}
+ nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
+ if usePrefix:
+ # suppression du prefixe si present
+ partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
+ # les tests suivants ne generent une erreur que si le prefixe est obligatoire
+ if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
+ print "ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
+ indiquant le type de materiau ou de source associee" % (nom, )
+ elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
+ print "ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable" % (nom, )
+ else:
+ # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
+ if typeBloc is not None:
+ if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
+ print "ERREUR! ce type de bloc (%s) n'est pas valable" % (str(typeBloc), )
+ elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
+ print "ERREUR! ce groupe de maille (%(nom)s) n'a pas \
+ le prefixe correct pour etre associe a un type %(type_bloc)s", \
+ {'nom': nom, 'type_bloc': str(typeBloc)}
+ else: # c'est bon
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
+ if self.debug:
+ print "ce groupe de maille (%(nom)s) a un prefixe qui \
+ est supprime automatiquement pour devenir : %(nom_reel)s", \
+ {'nom': nom, 'nom_reel': nomReel}
+ else: # c'est bon
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
+ if self.debug:
+ print "ce groupe de maille (%(nom)s) a un prefixe qui \
+ est supprime automatiquement pour devenir : %(nom_reel)s", \
+ {'nom': nom, 'nom_reel': nomReel}
+ if self.debug:
+ print "... %s", nomReel
+ return nomReel
--- /dev/null
+# Exemple de script pour lire la sortie csv du banc d'intégration odysee
+#
+# Lecture des valeurs dans le csv et renvoi de la valeur après application de la fonction d'agragation max,min et moy
+
+# To get the history in python
+# print('\n'.join([str(readline.get_history_item(i + 1)) for i in range(readline.get_current_history_length())]))
+
+
+def vMax(arrayNx2):
+ import numpy as np
+
+ return np.apply_along_axis(max, 0, arrayNx2[:, 1]).item()
+
+
+def vMin(arrayNx2):
+ import numpy as np
+
+ return np.apply_along_axis(min, 0, arrayNx2[:, 1]).item()
+
+
+def vMean(arrayNx2):
+ import numpy as np
+ import statistics
+
+ return np.apply_along_axis(statistics.mean, 0, arrayNx2[:, 1]).item()
+
+
+def vSum(arrayNx2):
+ import numpy as np
+
+ return np.apply_along_axis(sum, 0, arrayNx2[:, 1]).item()
+
+
+def vInitialTime(arrayNx2):
+ import numpy as np
+
+ # Dates on first column, Values on second one
+ timeColumn = arrayNx2[:, 0]
+ # Tmin=np.apply_along_axis(min, 0, timeColumn)
+ # assert(arrayNx2[0,0]==Tmin)
+ idxTmin = timeColumn.argmin()
+ assert idxTmin == 0
+
+ valTmin = arrayNx2[idxTmin][1].item()
+
+ return valTmin
+
+
+def vFinalTime(arrayNx2):
+ import numpy as np
+
+ # Dates on first column, Values on second one
+ timeColumn = arrayNx2[:, 0]
+ # Tmax=np.apply_along_axis(max, 0, timeColumn)
+ # assert(arrayNx2[timeColumn.size,0]==Tmax)
+ idxTmax = timeColumn.argmax()
+ idxMax = timeColumn.size - 1
+ assert idxTmax == idxMax
+
+ valTmax = arrayNx2[idxTmax][1].item()
+
+ return valTmax
+
+
+def vHalfTime(arrayNx2):
+ import numpy as np
+
+ # Dates on first column, Values on second one
+ timeColumn = arrayNx2[:, 0]
+ Tmin = np.apply_along_axis(min, 0, timeColumn)
+ Tmax = np.apply_along_axis(max, 0, timeColumn)
+
+ Thalf = (Tmax - Tmin) / 2 + Tmin
+ idxThalf = (np.abs(timeColumn - Thalf)).argmin()
+ valThalf = arrayNx2[idxThalf][1].item()
+
+ return valThalf
+
+
+def get_result_from_csv(
+ variableName: str, functionList, filename: str = None, delimiter=","
+):
+ from csv import reader
+ import numpy as np
+
+ transientName = "Transient duration"
+
+ # ex: file_csv = "Fuel temperature@Thermalhydraulics@MAX.csv"
+ if filename == None:
+ filename = variableName + ".csv"
+
+ with open(filename, "r") as csv_file:
+ csv_reader = reader(csv_file, delimiter=delimiter)
+ header = next(csv_reader)
+ header_transient_name = header[1]
+ header_variable_name = header[2]
+ if header_variable_name != variableName:
+ print(
+ sys.stderr,
+ "The variable name {} differs from the file's header one {}".format(
+ variableName, header_variable_name
+ ),
+ )
+ return -1 # TODO Exception ?
+ if header_transient_name != transientName:
+ print(
+ sys.stderr,
+ "The transient duration name {} differs from the file's header one {}".format(
+ transientName, header_transient_name
+ ),
+ )
+ return -1 # TODO Exception ?
+
+ date_value_array = np.loadtxt(filename, delimiter=delimiter, skiprows=1)[:, 1:3]
+ valList = []
+ for func in functionList:
+ valList.append(func(date_value_array))
+ return valList
+
+
+# Fuel-temperature_Thermalhydraulics_MAX
+# value at t_initial value at t_mid value at t_final mean value cumsum value min value max value
+# MeanFirstOrder (°C): 1113.040047 1009.112047 968.544065 207597.218716 1113.040047 968.544064 1032.821984
+# StandardDeviationFirstOrder (°C): 203.302658 250.504351 255.172144 43724.195535 203.302658 256.008518 217.533311
+
+
+def write_result_from_persalys(resultNp, indexNp, resSk, outputs):
+ import numpy as np
+ import pandas as pnd
+ from functools import reduce
+
+ # resultNp = np.array([meanFirstOrder, meanSecondOrderOrder, standardDeviationFirstOrder ])
+ # Lignes de résultats demandés pour toutes les fcts d'aggrégation en colonne
+ # resultNp = np.array([ {optionalResultList} ])
+ # Noms de lignes
+ # index = ['meanFirstOrder', 'meanSecondOrderOrder', 'standardDeviationFirstOrder' ]
+ # indexNp = [ {optionalResultStrList} ]
+ nResult = len(indexNp)
+ # Tableau skyline localisant les variables (hors fctAgg) dans le tableau de résultat global
+ # resultSk = [0,7,10]
+ # resSk = [ {resultSkList} ]
+ nOutVar = len(resSk) - 1
+
+ print("\n")
+ for i in range(nOutVar):
+ # Récupère les couples (fctAggrégation,Nom de variable ss fct Agg)
+ # des champs de description des sorties.
+ # Les sorties concernées proviennent de la section de résultatNp
+ # qui doit correspondre à une même variable hors fct Agg
+ fctAgg_outVarName = list(
+ map(lambda o: eval(o.getDescription()), outputs[resSk[i] : resSk[i + 1]])
+ )
+ outVarName = fctAgg_outVarName[0][1]
+ checkOutVarName = reduce(
+ lambda n1, n2: n1 == n2,
+ [True] + list(map(lambda o: o[1] == outVarName, fctAgg_outVarName)),
+ )
+ assert checkOutVarName == True
+ print(outVarName)
+ columns = list(map(lambda o1: o1[0], fctAgg_outVarName))
+ resultDf = pnd.DataFrame(
+ resultNp[:, resSk[i] : (resSk[i + 1])], index=indexNp, columns=columns
+ )
+ print(resultDf, "\n")
+ # name_csv = str.replace(str.replace(outVarName,"@","_"),' ','-')
+ name_csv = outVarName
+ resultDf.to_csv(name_csv + "-uncertainty.csv")
--- /dev/null
+# ----------------------------------
+# headerScriptPersalys
+# Parametres pour format :
+# nom de l etude, nom de l etude, nom de l etude, path pour wrapper, wrapper, nom de la fonction
+# sys.path[:0]=[{}]
+
+headerScriptPersalys = """#! /usr/bin/env python3
+# coding: utf-8
+# --------------------------------------------------------------------------
+# Script Eficas genere pour lancement Etude Probabiliste
+# ---------------------------------------------------------------------------
+# Exemple d'utilisation standalone avec salome :
+# ~/salome/appli_V9_7_0_package/salome start -k -t python3 mon_fichier_uq_genere.py
+# ou
+# ~/salome/appli_V9_7_0_package/salome start -k -t
+# ~/salome/appli_V9_7_0_package/salome shell python3 mon_fichier_uq_genere.py
+
+# Chargement du module systeme
+import sys
+import os
+
+# Chargement du module OpenTURNS #TODO : Parametrer OpenTurns/Uranie
+import openturns as ot
+import persalys
+
+"""
+
+# def run_case(self):
+# """
+# Launch the calculation once the case files are ready.
+# """
+# command = './run.sh '
+# command += './syrthes.py -n ' + str(self.nproc) + ' -d ' + self.comm_file
+# command += ' >' + os.path.join(self.workdir, "std.log")
+# command += ' 2>' + os.path.join(self.workdir, "err.log")
+# os.system(command)
+# pass
+
+
+# ----------------------------------
+# etudeScript
+etudeScript = """
+class Study:
+ import os
+ import subprocess
+
+ def __init__(self, {chaineDesVariablesInput}):
+ {chaineInitDesVariablesInput}
+
+ def do_sh(self, command, execdir=os.getcwd()):
+ print('Execution directory is : ', execdir)
+ import subprocess
+ sh = subprocess.Popen(command, shell=True, cwd=execdir,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT)
+ out, err = sh.communicate()
+ return out, err, sh.poll()
+
+ #TODO : Définir un décorateur pour sélectionner la fonction voulue
+ def define_workdirectory(self):
+ from incertainty_tools import value_repr_name
+ self.workdir = value_repr_name([{chaineSelfDesVariablesInput}])
+
+ def case_exists(self):
+ ok = True
+ if os.path.isdir(self.workdir):
+ try:
+ ok = False #TODO
+ except:
+ ok = False
+ else:
+ ok = False
+ return ok
+
+ def prepare_case(self):
+ from incertainty_tools import replace_data
+ import shutil
+
+ if not os.path.isdir(self.workdir):
+ os.mkdir(self.workdir)
+
+ #section spécifique au code de calcul
+ comm_file_balise = '{commFileBalise}'
+
+ self.nproc = {nproc} # La présence de cette variable dépend
+ # du mode de lancement MPI
+ # S'il est géré par le script appelé à partir du MDD, il est inutile de le stocker
+ self.comm_file_balise = os.path.join(self.workdir, comm_file_balise)
+ shutil.copy(comm_file_balise, self.comm_file_balise)
+
+ self.comm_file = os.path.join(self.workdir, '{commFile}')
+ replace_data(self.comm_file_balise, {{ {replaceDataList} }} , self.comm_file)
+ #TODO: Lancer la validation du fichier généré avant tout lancement : Le banc le fait
+
+ pass
+
+ def get_result_from_csv(self,postProcessedVar, aggregationFctList):
+ from post_csv_rn import get_result_from_csv
+ #TODO: Fonctions a implementer dans un fichier post_csv provenant
+ # de la mise en donnée pour définir la façon d'aggréger les valeurs
+ from post_csv_rn import vInitialTime, vHalfTime, vFinalTime, vMean, vSum, vMin, vMax
+
+ savdir=os.getcwd()
+ os.chdir(self.workdir)
+ results = get_result_from_csv(postProcessedVar, aggregationFctList)
+ os.chdir(savdir)
+ return results
+
+ def run_case(self):
+ #os.chdir(self.workdir)
+ # Si lancement mpi externe à ib_test.sh il faut utiliser self.nproc : mpiexec -n self.nproc ib_test.sh
+ #o,e,c = self.do_sh(command="ib_test.sh", execdir=self.workdir)
+ command="{uncertaintyScript} {uncertaintyScriptParameters}"
+ o,e,c = self.do_sh(command=command, execdir=self.workdir)
+ if o != None : print(o.decode())
+ if e != None : print(e.decode())
+ if c != 0:
+ raise Exception(' Study::run_case : Execution error : cd ' +
+ os.path.join('{workDirectory}',self.workdir) +
+ ' && '+ os.path.join('../','{uncertaintyScript}') +
+ ' '+ '{uncertaintyScriptParameters}')
+
+"""
+
+# /home/C65845/VIMMP/Banc_integration.newer_odysee/environment/bin/python3 /home/C65845/VIMMP/Banc_integration.newer_odysee/environment/bin/ib-run --cocagne-neutro-solver SPN --cocagne-thermo-solver THERMOMI/TRMIC -- /home/C65845/VIMMP/Banc_integration.newer_odysee/integration_bench/tests/control_rod_ejection_small_core_cathare3_cocagne.comm /home/C65845/VIMMP/Banc_integration.newer_odysee/integration_bench/tests/control_rod_ejection_small_core_cathare3_cocagne_spn_thermomi-trmic_serial
+
+getResultCall = """ {variableOutputList}, = study.get_result_from_csv( '{nomVarPostraite}', [{fonctionAggregationList}] )
+ print( '{nomVarPostraite}: ({variableOutputList})',{variableOutputList})
+"""
+
+getResultCallAvoidPersalysBug = """ {variableOutputList}, = study.get_result_from_csv( '{nomVarPostraite}', [{fonctionAggregationList}] )
+
+ print( '{nomVarPostraite}: ({variableOutputList})',{variableOutputList})
+
+ #Contournement Bug Persalys sur la longueur de la chaine retour
+ {shortVariableOutputList} = {variableOutputList}
+
+"""
+
+# -------------------------
+# fonctionPersalys
+# ------------------------
+fonctionPersalys = """
+def _exec({chaineDesVariablesInput}):
+ from post_csv_rn import vInitialTime, vHalfTime, vFinalTime, vMean, vSum, vMin, vMax
+ from {currentFile} import Study
+
+ study = Study({chaineDesVariablesInput})
+ study.define_workdirectory()
+ if not study.case_exists():
+ study.prepare_case()
+ study.run_case()
+
+{getAllResults}
+ return {chaineDesVariablesOutput}
+"""
+
+# ------------------------
+# codePersalys
+# ------------------------
+codePersalys = """
+code = '''
+{fonctionPersalys}
+'''
+"""
+
+# ----------------------------
+# inputHeaderPersalys
+# ----------------------------
+inputHeaderPersalys = """
+{indent}# definition des Inputs
+{indent}# ---------------------
+"""
+
+# inputPersalysUniform='{}{} = persalys.Input({}, {})'
+# inputPersalys='{}{} = persalys.Input({}, {})'
+
+# ------------------------------
+# ouputHeaderPersalys
+# ------------------------------
+outputHeaderPersalys = """
+{indent}# definition des Outputs
+{indent}# ----------------------
+"""
+
+# ------------------
+# mainPersalys
+# ------------------
+mainPersalys = """
+# ------------------
+# definition du main
+# ------------------
+if __name__ == '__main__':
+
+ from datetime import datetime
+
+ {nomEtude} = persalys.Study('{nomEtude}')
+ persalys.Study.Add({nomEtude})
+
+{inputVariableInitList}
+{outputVariableInitList}
+
+{inputHeaderPersalys}
+ inputs = [{chaineDesVariablesInput}]
+ nInputs = len(inputs)
+
+{outputHeaderPersalys}
+ outputs = [{chaineDesVariablesOutput}]
+ nOutputs = len(outputs)
+
+ yacsPhysicalModel = persalys.YACSPhysicalModel('PhysicalModel', inputs, outputs, code)
+{yacsJobParameters}
+ {nomEtude}.add(yacsPhysicalModel)
+
+{centralTendencyPersalys}
+ {nomEtude}.add(centralTendency)
+
+################ CUT THE FILE HERE IF YOU WANT TO IMPORT IT IN THE SALOME PERSALYS MODULE ################
+
+ head_study = str(datetime.now()) +" {scenarioType} "+""
+
+ centralTendency.run()
+{resultPersalys}
+
+"""
+# a = persalys.Input('a', 0, '')
+# b = persalys.Input('b', 0, '')
+# d = persalys.Output('d', '')
+# inputs = [a, b]
+# outputs = [d]
+
+# empiricalMean = ot.Sample(result.getMean())[nInputs:]
+# empiricalStandardDeviation = ot.Sample(result.getStandardDeviation())[nInputs:]
+# resultNp.reshape(nbindex,nbsorties)
+
+printResultMC = """ import numpy as np
+ sys.path.append(os.path.abspath('{post_csv_rnPath}'))
+ from {post_csv_rnScript} import write_result_from_persalys
+
+ #Noms de lignes
+ #index = ['meanFirstOrder', 'meanSecondOrderOrder', 'standardDeviationFirstOrder' ]
+ indexNp = [ {optionalResultStrList} ]
+ nResult = len(indexNp)
+
+ #resultNp = np.array([meanFirstOrder, meanSecondOrderOrder, standardDeviationFirstOrder ])
+ #Lignes de résultats demandés pour toutes les fcts d'aggrégation en colonne
+ resultNp = np.array([ {optionalResultList} ])
+ resultNp = resultNp.reshape(nResult, nOutputs) #En MC à cause du ot.Sample( PointsCollection) il y a un niveau de liste en trop
+
+ #Tableau skyline localisant les variables (hors fctAgg) dans le tableau de résultat global
+ # ex pour deux variables et respectivement 7 et 3 fcts aggrégation : resultSk = [0,7,10]
+ #nOutVar = len(resSk)-1
+ resSk = [ {resultSkList} ]
+
+ print('\\n\\n')
+ print('*********************************************************************************\\n')
+ print(' UNCERTAINTY QUANTIFICATION RESULTS\\n')
+
+ print(head_study,'\\n')
+
+ print('Uncertain inputs list :','\\n')
+ print(
+{Uncertain_inputs}'\\n'
+ )
+ print('\\nElapsed Time : ', centralTendency.getElapsedTime(),'\\n') #Monte Carlo ou Taylor
+
+ print('\\nDesign of Experiment :')
+ print(result.getDesignOfExperiment().getInputSample(),'\\n') #TODO: générer un fichier csv
+
+ print('\\nCoefficient of Variation :')
+ print(ot.Sample(result.getCoefficientOfVariation())[nInputs:],'\\n') #TODO: générer un fichier csv
+ write_result_from_persalys(resultNp, indexNp, resSk, outputs)
+
+ print('\\n*********************************************************************************\\n')
+"""
+
+
+printResultTaylor = """ import numpy as np
+ sys.path.append(os.path.abspath('{post_csv_rnPath}'))
+ from {post_csv_rnScript} import write_result_from_persalys
+
+ #resultNp = np.array([meanFirstOrder, meanSecondOrderOrder, standardDeviationFirstOrder ])
+ #Lignes de résultats demandés pour toutes les fcts d'aggrégation en colonne
+ resultNp = np.array([ {optionalResultList} ])
+
+ #Noms de lignes
+ #index = ['meanFirstOrder', 'meanSecondOrderOrder', 'standardDeviationFirstOrder' ]
+ #nResult = len(indexNp)
+ indexNp = [ {optionalResultStrList} ]
+
+ #nResult = len(indexNp)
+
+ #Tableau skyline localisant les variables (hors fctAgg) dans le tableau de résultat global
+ # ex pour deux variables et respectivement 7 et 3 fcts aggrégation : resultSk = [0,7,10]
+ #nOutVar = len(resSk)-1
+ resSk = [ {resultSkList} ]
+
+ print('\\n\\n')
+ print('*********************************************************************************\\n')
+ print(' UNCERTAINTY QUANTIFICATION RESULTS\\n')
+
+ print(head_study,'\\n')
+
+ print('Uncertain inputs list :','\\n')
+ print(
+{Uncertain_inputs}'\\n'
+ )
+ print('\\nElapsed Time : ', centralTendency.getElapsedTime(),'\\n') #Monte Carlo ou Taylor
+
+ # print('\\nDesign of Experiment :')
+ # print(result.getDesignOfExperiment().getInputSample(),'\\n') #TODO: Activer uniquement en MC + fichier csv
+
+ # print('\\nCoefficient of Variation :')
+ # print(result.getCoefficientOfVariation(),'\\n') #TODO: Activer uniquement en MC + fichier csv
+ write_result_from_persalys(resultNp, indexNp, resSk, outputs)
+
+ print('\\n*********************************************************************************\\n')
+"""
+
+## Tendance Centrale Taylor
+centralTendencyTaylor = """
+ centralTendency = persalys.TaylorExpansionMomentsAnalysis('centralTendencyTaylor', yacsPhysicalModel)
+"""
+
+# Le result est une liste de taille <nombre de variables de sortie>
+resultTaylor = """
+ result = centralTendency.getResult()
+{optionalResult}
+
+"""
+
+optionalResultTaylor = {
+ "MeanFirstOrder": "meanFirstOrder = result.getMeanFirstOrder()",
+ "StandardDeviationFirstOrder": "standardDeviationFirstOrder = result.getStandardDeviation()",
+ "MeanSecondOrder": "meanSecondOrder = result.getMeanSecondOrder()",
+ "Variance": "variance = result.getVariance()",
+}
+optionalPrintResultTaylor = {
+ "MeanFirstOrder": 'print("MeanFirstOrder : ",meanFirstOrder)',
+ "StandardDeviationFirstOrder": 'print("StandardDeviationFirstOrder :",standardDeviationFirstOrder)',
+ "MeanSecondOrder": 'print("MeanSecondOrder :",meanSecondOrder)',
+ "Variance": 'print("Variance :",variance)',
+}
+
+## Tendance Centrale MC
+centralTendencyMC = """
+ centralTendency = persalys.MonteCarloAnalysis('centralTendencyMC', yacsPhysicalModel)
+{critereArretMC}
+{advancedParameterMC}
+ centralTendency.setBlockSize({BlockSize})
+"""
+
+critereArretMC = {
+ "SimulationsNumber": "centralTendency.setMaximumCalls({SimulationsNumber})",
+ "MaximumElapsedTime": "centralTendency.setMaximumElapsedTime({MaximumElapsedTime})",
+ "Accuracy": "centralTendency.setMaximumCoefficientOfVariation({Accuracy})",
+}
+
+advancedParameterMC = {
+ "Seed": "centralTendency.setSeed({Seed})", # TODO : A ajouter dans le catalogue
+ "ComputeConfidenceIntervalAt": "centralTendency.setLevelConfidenceInterval({ComputeConfidenceIntervalAt})",
+}
+
+# TODO: Gérer les unités
+resultMC = """
+ result = centralTendency.getResult()
+{optionalResult}
+"""
+
+optionalResultMC = {
+ "EmpiricalMean": "empiricalMean = ot.Sample(result.getMean())[nInputs:]", # En MC les inputs apparaissent en début de résultat !
+ "Variance": "variance = ot.Sample(result.getVariance())[nInputs:]", # et on utilise ot.Sample pour accéder aux valeurs des Points
+ "EmpiricalStandardDeviation": "empiricalStandardDeviation = ot.Sample(result.getStandardDeviation())[nInputs:]", # Idem.
+ "EmpiricalQuantile": """
+ designOfExperiment=result.getDesignOfExperiment()
+ outputSample=designOfExperiment.getOutputSample()
+ empiricalQuantile_Order = {EmpiricalQuantile_Order}
+ empiricalQuantile=outputSample.computeQuantile(empiricalQuantile_Order)
+ """,
+}
+
+optionalPrintResultMC = {
+ "EmpiricalMean": 'print("EmpiricalMean : ", empiricalMean)',
+ "Variance": 'print("Variance : ", variance)',
+ "EmpiricalStandardDeviation": 'print("EmpiricalStandardDeviation : ",empiricalStandardDeviation)',
+ "EmpiricalQuantile": 'print("EmpiricalQuantile : ",empiricalQuantile)',
+ "EmpiricalQuantile_Order": 'print("EmpiricalQuantile_Order : ",empiricalQuantile_Order)',
+}
+
+
+# designOfExperiment=result.getDesignOfExperiment()
+# outputSample=designOfExperiment.getOutputSample()
+# computeQuantile=outputSample.computeQuantile(empiricalQuantile_Order)
+# ##isample=designOfExperiment.getSample()
+# ##computeQuantile=sample.computeQuantile(0.95)
+# ##nputSample=designOfExperiment.getInputSample()
+# ##computeQuantile=inputSample.computeQuantile(0.95)
+
+
+# En local le nombre de procs est inutile
+# TODO: S'il on peut récupérer les fichiers .csv des tirages,
+# il faut ajouter une ligne out_files
+yacsJobParameters = """
+ yacsPhysicalModel.jobParameters().salome_parameters.resource_required.name = '{resourceName}'
+ yacsPhysicalModel.jobParameters().salome_parameters.job_name = '{nomEtude}'
+ yacsPhysicalModel.jobParameters().salome_parameters.work_directory = '{workDirectory}'
+ yacsPhysicalModel.jobParameters().salome_parameters.result_directory = '{resultDirectory}'
+ yacsPhysicalModel.jobParameters().salome_parameters.in_files = {inFiles} # Chemins des fichiers locaux à copier dans work_directory
+ yacsPhysicalModel.jobParameters().nb_branches = {nbBranches} # nombre de jobs parallèles
+"""
+
+# Le nombre de procs du job manager est uniquement utile pour les clusters
+yacsJobClusterParameters = """
+ yacsPhysicalModel.jobParameters().salome_parameters.resource_required.nb_proc = {nprocs}
+ yacsPhysicalModel.jobParameters().salome_parameters.wckey = '{wckey}'
+"""
+
+# Ces 3 lignes permettent de modifier le mode d'évaluation par défaut qui est
+# d'avoir toutes les évaluations dans un seul job.
+# Ici <nb_branches> jobs seront crées dynamiquement pour lancer chaque évaluation
+# chaque job demandera la réservation de nprocs processus.
+yacsJobClusterMultiJob = """
+ import pydefx
+ multiJobModel = pydefx.MultiJobStudy() # mode un job par évaluation
+ yacsPhysicalModel.setJobModel(multiJobModel)
+"""
+
+# yacsJobParametersRef="""
+# yacsPhysicalModel.jobParameters().salome_parameters.job_name = '{nomEtude}_idefix_job'
+# yacsPhysicalModel.jobParameters().salome_parameters.work_directory = '/scratch/C65845/workingdir/persalys_light'
+# yacsPhysicalModel.jobParameters().salome_parameters.result_directory = '/tmp/local_result'
+# yacsPhysicalModel.jobParameters().salome_parameters.resource_required.name = 'gaia'
+# yacsPhysicalModel.jobParameters().salome_parameters.resource_required.nb_proc = 1
+# yacsPhysicalModel.jobParameters().salome_parameters.wckey = 'P11N0:SALOME'
+# yacsPhysicalModel.jobParameters().salome_parameters.in_files = [] # Chemins des fichiers locaux à copier dans work_directory
+# yacsPhysicalModel.jobParameters().nb_branches = 3 # nombre de jobs parallèles
+
+# # Ces 4 lignes permettent de modifier le mode d'évaluation par défaut qui est
+# # d'avoir toutes les évaluations dans un seul job.
+# import pydefx
+# import os
+# myModel = pydefx.MultiJobStudy() # mode un job par évaluation
+
+# PhysicalModel.setJobModel(myModel)
+# """
+
+
+if __name__ == "__main__":
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le chargeur dynamique de plugins (emprunte a HappyDoc)
+"""
+
+import glob, os, sys, traceback
+from collections import UserDict
+from importlib import import_module
+
+
+class PluginLoader(UserDict):
+ def __init__(self, directory):
+ UserDict.__init__(self)
+ pluginDir = directory
+ prefixName = directory.split('/')[-1]
+ fileList = glob.glob(
+ os.path.join(
+ pluginDir,
+ "%s*py" % prefixName,
+ )
+ )
+ fileList.sort()
+
+ for fileName in fileList:
+ fileName = os.path.basename(fileName)[:-3]
+ _import_name = "%s.%s.%s" % ('Accas.IO',prefixName, fileName)
+ try:
+ _module = import_module(_import_name)
+ except :
+ sys.stderr.write("\n--- Plugin Module Error ---\n")
+ traceback.print_exc()
+ sys.stderr.write("---------------------------\n\n")
+ continue
+
+ try:
+ info = _module.entryPoint()
+ except AttributeError:
+ pass
+ else:
+ self.addEntryPoint(info)
+
+ def addEntryPoint(self, infoDict):
+ name = infoDict["name"]
+ factory = infoDict["factory"]
+ self[name] = factory
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce package contient les classes qui seront effectivement utilisees dans les applications.
- C'est dans ce package que sont realisees les combinaisons de classes de base
- avec les classes MIXIN qui implementent les fonctionnalites qui ont ete separees
- du noyau pour des raisons de modularite afin de faciliter la maintenance et
+ Ce package contient les Accas. qui seront effectivement utilisees dans les applications.
+ C'est dans ce package que sont realisees les combinaisons de Accas. de base
+ avec les Accas. MIXIN qui implementent les fonctionnalites qui ont ete separees
+ du processing pour des raisons de modularite afin de faciliter la maintenance et
l'extensibilite.
- De plus toutes les classes utilisables par les applications sont remontees au
+ De plus toutes les Accas. utilisables par les applications sont remontees au
niveau du package afin de rendre le plus independant possible l'utilisation des
- classes et leur implementation.
+ Accas. et leur implementation.
"""
warnings.filterwarnings("error", "Non-ASCII character.*pep-0263", DeprecationWarning)
-from .A_JDC_CATA import JDC_CATA
-from .A_JDC_CATA_SINGLETON import JDC_CATA_SINGLETON
-from .A_OPER import OPER
-from .A_PROC import PROC
-from .A_MACRO import MACRO
-from .A_FORM import FORM
-from .A_BLOC import BLOC
-from .A_FACT import FACT
-from .A_SIMP import SIMP
-from .A_EVAL import EVAL
-from .A_NUPLET import NUPL
-from .A_TUPLE import Tuple
-from .A_TUPLE import Matrice
-
-
-from .A_JDC import JDC
-from .A_ETAPE import ETAPE
-from .A_PROC_ETAPE import PROC_ETAPE
-from .A_MACRO_ETAPE import MACRO_ETAPE
-from .A_FORM_ETAPE import FORM_ETAPE
-from .A_MCFACT import MCFACT
-from .A_MCLIST import MCList
-from .A_MCBLOC import MCBLOC
-from .A_MCSIMP import MCSIMP
+from Accas.classes.C_JDC_CATA import JDC_CATA
+from Accas.classes.C_JDC_CATA_SINGLETON import JDC_CATA_SINGLETON
+from Accas.classes.C_OPER import OPER
+from Accas.classes.C_PROC import PROC
+from Accas.classes.C_MACRO import MACRO
+from Accas.classes.C_FORM import FORM
+from Accas.classes.C_BLOC import BLOC
+from Accas.classes.C_FACT import FACT
+from Accas.classes.C_SIMP import SIMP
+from Accas.classes.C_EVAL import EVAL
+from Accas.classes.C_NUPLET import NUPL
+from Accas.classes.C_TUPLE import Tuple
+from Accas.classes.C_TUPLE import Matrice
+
+
+from Accas.classes.C_JDC import JDC
+from Accas.classes.C_ETAPE import ETAPE
+from Accas.classes.C_PROC_ETAPE import PROC_ETAPE
+from Accas.classes.C_MACRO_ETAPE import MACRO_ETAPE
+from Accas.classes.C_FORM_ETAPE import FORM_ETAPE
+from Accas.classes.C_MCFACT import MCFACT
+from Accas.classes.C_MCLIST import MCList
+from Accas.classes.C_MCBLOC import MCBLOC
+from Accas.classes.C_MCSIMP import MCSIMP
# Les regles
-from .A_AU_MOINS_UN import AU_MOINS_UN
-from .A_MEME_NOMBRE import MEME_NOMBRE
-from .A_AU_PLUS_UN import AU_PLUS_UN
-from .A_UN_PARMI import UN_PARMI
-from .A_PRESENT_PRESENT import PRESENT_PRESENT
-from .A_PRESENT_ABSENT import PRESENT_ABSENT
-from .A_EXCLUS import EXCLUS
-from .A_ENSEMBLE import ENSEMBLE
-from .A_A_CLASSER import A_CLASSER
-from .A_AVANT import AVANT
-
-from .A_ASSD import ASSD, assd, UserASSD, UserASSDMultiple
-from .A_ASSD import GEOM, geom
+from Accas.classes.C_AU_MOINS_UN import AU_MOINS_UN
+from Accas.classes.C_MEME_NOMBRE import MEME_NOMBRE
+from Accas.classes.C_AU_PLUS_UN import AU_PLUS_UN
+from Accas.classes.C_UN_PARMI import UN_PARMI
+from Accas.classes.C_PRESENT_PRESENT import PRESENT_PRESENT
+from Accas.classes.C_PRESENT_ABSENT import PRESENT_ABSENT
+from Accas.classes.C_EXCLUS import EXCLUS
+from Accas.classes.C_ENSEMBLE import ENSEMBLE
+from Accas.classes.C_A_CLASSER import A_CLASSER
+from Accas.classes.C_AVANT import AVANT
+
+from Accas.classes.C_ASSD import ASSD, assd, UserASSD, UserASSDMultiple
+from Accas.classes.C_ASSD import CO
+from Accas.classes.C_ASSD import GEOM, geom
# Pour le moment on laisse fonction (ceinture et bretelles)
-from .A_ASSD import FONCTION, fonction
-from .A_ASSD import formule
-from .A_ASSD import formule_c
-from .A_ASSD import CO
-
-from Noyau.N__F import _F
-
-from Noyau.N_Exception import AsException
-from Noyau.N_utils import AsType
-from Noyau.N_utils import AsType
-from Noyau.N_OPS import OPS, EMPTY_OPS
-from Noyau.N_ASSD import not_checked
-
-from .A_VALIDATOR import OrVal, AndVal, OnlyStr
-from .A_VALIDATOR import OrdList, NoRepeat, LongStr, Compulsory, Absent, Together
-from .A_VALIDATOR import RangeVal, EnumVal, TypeVal, PairVal
-from .A_VALIDATOR import CardVal, InstanceVal
-from .A_VALIDATOR import VerifTypeTuple, VerifExiste
-from .A_VALIDATOR import FileExtVal, FunctionVal
-from .A_VALIDATOR import CreeMotClef
-from .A_VALIDATOR import compareAutreMC
-from .A_VALIDATOR import infFrereMC, supFrereMC
-
-# On remplace la factory des validateurs initialement dans Noyau par celle
-# de A_VALIDATOR
-from .A_VALIDATOR import validatorFactory
-import Noyau.N_ENTITE
-
-Noyau.N_ENTITE.ENTITE.factories["validator"] = validatorFactory
-
-from .A_SENSIBILITE import CONCEPT_SENSIBLE, REUSE_SENSIBLE, DERIVABLE
-
-from Extensions.niveau import NIVEAU
-from Extensions.etape_niveau import ETAPE_NIVEAU
-from Extensions.commentaire import COMMENTAIRE
-from Extensions.parametre import PARAMETRE
-from Extensions.parametre_eval import PARAMETRE_EVAL
-from Extensions.commande_comm import COMMANDE_COMM
-from Extensions.mcnuplet import MCNUPLET
-
-from .A_SALOME_ENTRY import SalomeEntry
+from Accas.classes.C_ASSD import FONCTION, fonction
+from Accas.classes.C_ASSD import formule
+from Accas.classes.C_ASSD import formule_c
+
+from Accas.processing.P__F import _F
+
+from Accas.processing.P_Exception import AsException
+from Accas.processing.P_utils import AsType
+from Accas.processing.P_utils import AsType
+from Accas.processing.P_OPS import OPS, EMPTY_OPS
+from Accas.processing.P_ASSD import not_checked
+
+from Accas.classes.C_VALIDATOR import OrVal, AndVal, OnlyStr
+from Accas.classes.C_VALIDATOR import OrdList, NoRepeat, LongStr, Compulsory, Absent, Together
+from Accas.classes.C_VALIDATOR import RangeVal, EnumVal, TypeVal, PairVal
+from Accas.classes.C_VALIDATOR import CardVal, InstanceVal
+from Accas.classes.C_VALIDATOR import VerifTypeTuple, VerifExiste
+from Accas.classes.C_VALIDATOR import FileExtVal, FunctionVal
+from Accas.classes.C_VALIDATOR import CreeMotClef
+from Accas.classes.C_VALIDATOR import compareAutreMC
+from Accas.classes.C_VALIDATOR import infFrereMC, supFrereMC
+
+from Accas.classes.C_SENSIBILITE import CONCEPT_SENSIBLE, REUSE_SENSIBLE, DERIVABLE
+
+from Accas.extensions.niveau import NIVEAU
+from Accas.extensions.etape_niveau import ETAPE_NIVEAU
+from Accas.extensions.commentaire import COMMENTAIRE
+from Accas.extensions.parametre import PARAMETRE
+from Accas.extensions.parametre_eval import PARAMETRE_EVAL
+from Accas.extensions.commande_comm import COMMANDE_COMM
+from Accas.extensions.mcnuplet import MCNUPLET
+
+from Accas.classes.C_SALOME_ENTRY import SalomeEntry
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+from Accas.processing.P_VALIDATOR import ValError
+
+
+class ASSD:
+ def __repr__(self):
+ return "concept " + self.getName() + " type " + self.__class__.__name__
+
+ def __str__(self):
+ return self.getName() or "<None>"
+
+
+class assd(ASSD):
+ def __convert__(cls, valeur):
+ return valeur
+
+ __convert__ = classmethod(__convert__)
+
+
+class GEOM(ASSD):
+ def __convert__(cls, valeur):
+ return valeur
+
+ __convert__ = classmethod(__convert__)
+
+
+class geom(GEOM):
+ pass
+
+
+class CO(ASSD):
+ def __convert__(cls, valeur):
+ if hasattr(valeur, "_etape"):
+ # valeur est un concept CO qui a ete transforme par typeSDProd
+ if valeur.etape == valeur._etape:
+ # le concept est bien produit par l'etape
+ return valeur
+ raise ValError("Pas un concept CO")
+
+ __convert__ = classmethod(__convert__)
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+
+class A_AVANT:
+ """
+ La regle A_AVANT verifie que l'on trouve l ordre des mots-cles
+ de la regle parmi les arguments d'un JDC.
+
+ Ces arguments sont transmis a la regle pour Accas.validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
+ """
+
+ def __init__(self, *args):
+ if len(args) > 2:
+ print(("Erreur a la creation de la regle A_CLASSER(", args, ")"))
+ return
+ if type(args[0]) == tuple:
+ self.listeAvant = args[0]
+ else:
+ self.listeAvant = (args[0],)
+ if type(args[1]) == tuple:
+ self.listeApres = args[1]
+ else:
+ self.listeApres = (args[1],)
+
+ def verif(self, args):
+ """
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ""
+ boolListeAvant = 0
+ boolListeApres = 0
+ boolOK = 1
+ for nom in args:
+ if nom in self.listeAvant:
+ boolListeAvant = 1
+ if boolListeApres == 1:
+ boolOK = 0
+ if nom in self.listeApres:
+ boolListeApres = 1
+ if boolListeAvant == 0 and boolListeApres == 1:
+ boolOK = 0
+ return text, boolOK
+
+ def getText(self):
+ text = "Regle de classement " " :\n"
+ for mc in self.listeAvant:
+ text = text + mc + ", "
+ text = text + " \nAvant : \n"
+ for mc in self.listeApres:
+ text = text + mc + ","
+ return text
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+from Accas.accessor import A_REGLE
+
+
+class A_CLASSER(A_REGLE.REGLE):
+ def getText(self):
+ text = "Regle " + self.__class__.__name__ + " :\n"
+ t = " D'abord :\n" + " " * 8
+ for arg in self.args0:
+ t = t + arg.strip() + " ou "
+ text = text + t[0:-4] + "\n"
+ t = " Ensuite :\n" + " " * 8
+ for arg in self.args1:
+ t = t + arg.strip() + " ou "
+ text = text + t[0:-4] + "\n"
+ return text
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+_no = 0
+
+def numberEntite(entite):
+ """
+ Fonction qui attribue un numero unique a tous les objets du catalogue
+ Ce numero permet de conserver l'ordre des objets
+ """
+ global _no
+ _no = _no + 1
+ entite._no = _no
+
+
+class ENTITE:
+ def __init__(self):
+ numberEntite(self)
+
+ def getDocu(self):
+ if hasattr(self, "docu"):
+ if self.docu != "":
+ return self.docu
+ else:
+ if hasattr(self, "pere"):
+ return self.pere.getDocu()
+ else:
+ return None
+ else:
+ return None
+
+ def getSug(self):
+ if hasattr(self, "sug"):
+ if self.sug != "":
+ return self.sug
+ return None
+
+ def checkDefinition(self, parent):
+ """Verifie la definition d'un objet composite (commande, fact, bloc)."""
+ args = self.entites.copy()
+ mcs = set()
+ for nom, val in args.items():
+ if val.label == "SIMP":
+ mcs.add(nom)
+ # if val.max != 1 and val.type == 'TXM':
+ # print "#CMD", parent, nom
+ elif val.label == "FACT":
+ val.checkDefinition(parent)
+ else:
+ continue
+ del args[nom]
+ # seuls les blocs peuvent entrer en conflit avec les mcs du plus haut niveau
+ for nom, val in args.items():
+ if val.label == "BLOC":
+ mcbloc = val.checkDefinition(parent)
+ # print "#BLOC", parent, re.sub('\s+', ' ', val.condition)
+ # assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \
+ # % (parent, tuple(mcs.intersection(mcbloc)))
+ return mcs
+
+ #
+ def UQPossible(self):
+ return True
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+# Modules Python
+import sys, re
+import types
+from copy import copy
+
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+# Objet re pour controler les identificateurs Python
+conceptRE = re.compile(r"[a-zA-Z_]\w*$")
+
+import traceback
+from Accas.processing import P_ETAPE
+from Accas.processing import P_Exception
+from Accas.processing.P_Exception import AsException
+from Accas.validation import V_ETAPE
+
+# fin import a resorber
+
+# Modules EFICAS
+from Accas.accessor import A_MCCOMPO
+from Accas.accessor import CONNECTOR
+from Accas.extensions import commande_comm
+
+
+class ETAPE(A_MCCOMPO.MCCOMPO):
+ def ident(self):
+ return self.nom
+
+ def getSdname(self):
+ # print "SDNAME ",self.reuse,self.sd,self.sd.getName()
+ if CONTEXT.debug:
+ print(("SDNAME ", self.reuse, self.sd, self.sd.getName()))
+ sdname = ""
+ if self.reuse != None:
+ sdname = self.reuse.getName()
+ else:
+ if self.sd:
+ sdname = self.sd.getName()
+ if sdname.find("sansnom") != -1 or sdname.find("SD_") != -1:
+ # dans le cas ou la SD est 'sansnom' ou 'SD_' on retourne la chaine vide
+ return ""
+ return sdname
+
+ def isReentrant(self):
+ """
+ Indique si la commande est reentrante
+ """
+ return self.definition.reentrant == "o"
+
+ def initModif(self):
+ """
+ Met l'etat de l'etape a : modifie
+ Propage la modification au parent
+ """
+ # initModif doit etre appele avant de realiser une modification
+ # La validite devra etre recalculee apres cette modification
+ # mais dans l'appel a finModif pour preserver l'etat modified
+ # de tous les objets entre temps
+ # print "initModif",self,self.parent
+ self.state = "modified"
+ if self.parent:
+ self.parent.initModif()
+
+ def finModif(self):
+ """
+ Methode appelee une fois qu'une modification a ete faite afin de
+ declencher d'eventuels traitements post-modification
+ ex : INCLUDE et POURSUITE
+ Ne pas mettre de traitement qui risque d'induire des recursions (soit a peu pres rien)
+ """
+ CONNECTOR.Emit(self, "valid")
+ if self.parent:
+ self.parent.finModif()
+
+ def nommeSd(self, nom):
+ """
+ Cette methode a pour fonction de donner un nom (nom) au concept
+ produit par l'etape (self).
+ - si le concept n'existe pas, on essaye de le creer a condition que l'etape soit valide ET non reentrante)
+ - si il existe dea, on le renomme et on repercute les changements dans les autres etapes
+ Les valeurs de retour sont :
+ - 0 si le nommage n'a pas pu etre menea son terme,
+ - 1 dans le cas contraire
+ """
+ # Le nom d'un concept doit etre un identificateur Python (toujours vrai ou insuffisant?)
+ if not conceptRE.match(nom):
+ return 0, tr("Un nom de concept doit etre un identificateur Python")
+
+ # pour eviter que le nom du concept soit le nom de la classe --> souci pour utiliser le concept
+ if nom == self.definition.nom:
+ return (
+ 0,
+ tr("un concept de type ") + nom + tr(" ne peut pas se nommer ") + nom,
+ )
+ if nom in dir(self.jdc.cata):
+ return (0, nom + tr("est un not reserve"))
+ # if (not isinstance(nom,str)) : return (0, tr("Le nom ") + nom + tr(" est un mot reserve"))
+ # if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
+ # return 0, tr("Nom de concept trop long (maxi 8 caracteres)")
+
+ self.initModif()
+ #
+ # On verifie d'abord si les mots cles sont valides
+ #
+ if not self.isValid(sd="non"):
+ return 0, "Nommage du concept refuse : l'operateur n'est pas valide"
+ #
+ # Cas particulier des operateurs obligatoirement reentrants
+ # plus de concept reentrant (pour Aster)
+ #
+ if self.definition.reentrant == "o":
+ self.sd = self.reuse = self.jdc.getSdAvantEtape(nom, self)
+ if self.sd != None:
+ self.sdnom = self.sd.nom
+ self.finModif()
+ return 1, tr("Concept existant")
+ else:
+ return 0, tr("Operateur reentrant mais concept non existant")
+ #
+ # Cas particulier des operateurs facultativement reentrants
+ #
+ old_reuse = None
+ if self.definition.reentrant == "f":
+ sd = self.jdc.getSdAvantEtape(nom, self)
+ if sd != None:
+ if isinstance(sd, self.getType_produit()):
+ self.sd = self.reuse = sd
+ self.sdnom = sd.nom
+ self.finModif()
+ return 1, tr("Operateur reentrant et concept existant trouve")
+ else:
+ return 0, tr("Concept deja existant et de mauvais type")
+ else:
+ # il faut enlever le lien vers une SD existante car si on passe ici
+ # cela signifie que l'operateur n'est pas utilise en mode reentrant.
+ # Si on ne fait pas cela, on risque de modifier une SD produite par un autre operateur
+ if self.reuse:
+ old_reuse = self.reuse
+ self.sd = self.reuse = self.sdnom = None
+ #
+ # On est dans le cas ou l'operateur n'est pas reentrant ou est facultativement reentrant
+ # mais est utilise en mode non reentrant
+ #
+ if self.sd == None:
+ # Pas de concept produit preexistant
+ if self.parent.getSdAutourEtape(nom, self):
+ # Un concept de ce nom existe dans le voisinage de l'etape courante
+ # On retablit l'ancien concept reentrant s'il existait
+ if old_reuse:
+ self.sd = self.reuse = old_reuse
+ self.sdnom = old_reuse.nom
+ return 0, tr(
+ "Nommage du concept refuse : un concept de meme nom existe deja"
+ )
+ else:
+ # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
+ # On peut donc creer le concept retourne
+ # Il est cree sans nom mais enregistre dans la liste des concepts existants
+ try:
+ self.getSdProd()
+ # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
+ self.sd.nom = nom
+ self.sdnom = nom
+ self.parent.sdsDict[nom] = self.sd
+ self.parent.updateConceptAfterEtape(self, self.sd)
+ self.finModif()
+ return 1, tr("Nommage du concept effectue")
+ except:
+ return 0, tr("Nommage impossible %s", str(sys.exc_info()[1]))
+ else:
+ # Un concept produit preexiste
+ old_nom = self.sd.nom
+ if old_nom.find("sansnom"):
+ # Dans le cas ou old_nom == sansnom, isValid retourne 0 alors que ...
+ # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'etape est valide
+ # on peut donc le nommer sans test prealable
+ if self.parent.getSdAutourEtape(nom, self):
+ return 0, tr(
+ "Nommage du concept refuse : un concept de meme nom existe deja"
+ )
+ else:
+ # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
+ self.sd.nom = nom
+ self.sdnom = nom
+ self.parent.updateConceptAfterEtape(self, self.sd)
+ self.finModif()
+ return 1, tr("Nommage du concept effectue")
+ if self.isValid():
+ # Normalement l appel de isValid a mis a jour le concept produit (son type)
+ # Il suffit de specifier l attribut nom de sd pour le nommer si le nom n est pas
+ # deja attribue
+ if self.parent.getSdAutourEtape(nom, self):
+ return 0, tr(
+ "Nommage du concept refuse : un concept de meme nom existe deja"
+ )
+ else:
+ # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
+ self.sd.nom = nom
+ self.sdnom = nom
+ self.parent.updateConceptAfterEtape(self, self.sd)
+ self.finModif()
+ return 1, tr("Nommage du concept effectue")
+ else:
+ # Normalement on ne devrait pas passer ici
+ return 0, "Normalement on ne devrait pas passer ici"
+
+ def getSdprods(self, nom_sd):
+ """
+ Fonction : retourne le concept produit par l etape de nom nom_sd
+ s il existe sinon None
+ """
+ if self.sd:
+ if self.sd.nom == nom_sd:
+ return self.sd
+
+ def active(self):
+ """
+ Rend l'etape courante active.
+ Il faut ajouter la sd si elle existe au contexte global du JDC
+ et a la liste des sd
+ """
+ if self.actif:
+ return
+ self.actif = 1
+ self.initModif()
+ if self.sd:
+ try:
+ self.jdc.appendSdProd(self.sd)
+ except:
+ pass
+ CONNECTOR.Emit(self, "add", None)
+ CONNECTOR.Emit(self, "valid")
+
+ def inactive(self):
+ """
+ Rend l'etape courante inactive
+ Il faut supprimer la sd du contexte global du JDC
+ et de la liste des sd
+ """
+ self.actif = 0
+ self.initModif()
+ if self.sd:
+ self.jdc.delSdprod(self.sd)
+ self.jdc.deleteConceptAfterEtape(self, self.sd)
+ CONNECTOR.Emit(self, "supp", None)
+ CONNECTOR.Emit(self, "valid")
+
+ def controlSdprods(self, d):
+ """
+ Cette methode doit verifier que ses concepts produits ne sont pas
+ deja definis dans le contexte
+ Si c'est le cas, les concepts produits doivent etre supprimes
+ """
+ # print ("controlSdprods etape",d.keys(),self.sd and self.sd.nom,self.nom)
+ if self.sd:
+ if self.sd.nom in d:
+ # Le concept est deja defini
+ if self.reuse and self.reuse is d[self.sd.nom]:
+ # Le concept est reutilise : situation normale
+ pass
+ else:
+ # Redefinition du concept, on l'annule
+ # XXX on pourrait simplement annuler son nom pour conserver les objets
+ # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
+ self.initModif()
+ sd = self.sd
+ self.sd = self.reuse = self.sdnom = None
+ # supprime les references a sd dans les etapes suivantes
+ self.parent.deleteConceptAfterEtape(self, sd)
+ self.finModif()
+
+ def supprimeSdprod(self, sd):
+ """
+ Supprime le concept produit sd s'il est produit par l'etape
+ """
+ if sd is not self.sd:
+ return
+ if self.sd != None:
+ self.initModif()
+ self.parent.delSdprod(sd)
+ self.sd = None
+ self.finModif()
+ self.parent.deleteConcept(sd)
+
+ def supprimeSdProds(self):
+ """
+ Fonction:
+ Lors d'une destruction d'etape, detruit tous les concepts produits
+ Un operateur n a qu un concept produit
+ Une procedure n'en a aucun
+ Une macro en a en general plus d'un
+ """
+ self.deleteRef()
+ # print "supprimeSdProds",self
+ if self.reuse is self.sd:
+ return
+ # l'etape n'est pas reentrante
+ # le concept retourne par l'etape est a supprimer car il etait
+ # cree par l'etape
+ if self.sd != None:
+ self.parent.delSdprod(self.sd)
+ self.parent.deleteConcept(self.sd)
+
+ def close(self):
+ return
+
+ def updateConcept(self, sd):
+ for child in self.mcListe:
+ child.updateConcept(sd)
+
+ def deleteConcept(self, sd):
+ """
+ Inputs :
+ - sd=concept detruit
+ Fonction :
+ Mettre a jour les mots cles de l etape et eventuellement
+ le concept produit si reuse
+ suite a la disparition du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
+ """
+ if self.reuse and self.reuse == sd:
+ self.sd = self.reuse = None
+ self.initModif()
+ for child in self.mcListe:
+ child.deleteConcept(sd)
+
+ def replaceConcept(self, old_sd, sd):
+ """
+ Inputs :
+ - old_sd=concept remplace
+ - sd = nouveau concept
+ Fonction :
+ Mettre a jour les mots cles de l etape et eventuellement
+ le concept produit si reuse
+ suite au remplacement du concept old_sd
+ """
+ if self.reuse and self.reuse == old_sd:
+ self.sd = self.reuse = sd
+ self.initModif()
+ for child in self.mcListe:
+ child.replaceConcept(old_sd, sd)
+
+ def resetContext(self):
+ pass
+
+ def getNomsSdOperReentrant(self):
+ """
+ Retourne la liste des noms de concepts utilisesa l'interieur de la commande
+ qui sont du type que peut retourner cette commande
+ """
+ liste_sd = self.getSd_utilisees()
+ l_noms = []
+ if type(self.definition.sd_prod) == types.FunctionType:
+ d = self.creeDictValeurs(self.mcListe)
+ try:
+ classe_sd_prod = self.definition.sd_prod(*(), **d)
+ except:
+ return []
+ else:
+ classe_sd_prod = self.definition.sd_prod
+ for sd in liste_sd:
+ if sd.__class__ is classe_sd_prod:
+ l_noms.append(sd.nom)
+ l_noms.sort()
+ return l_noms
+
+ def getGenealogiePrecise(self):
+ return [self.nom]
+
+ def getMCPath(self):
+ return [self.nom, "@sdname " + self.sd.nom + " @"]
+
+ def getNomDsXML(self):
+ # en xml on a un choice
+ index = 0
+ for e in self.parent.etapes:
+ if e == self:
+ break
+ if e.nom == self.nom:
+ index += 1
+ nomDsXML = self.nom + "[" + str(index) + "]"
+ return nomDsXML
+
+ def getGenealogie(self):
+ """
+ Retourne la liste des noms des ascendants de l'objet self
+ en s'arretant a la premiere ETAPE rencontree
+ """
+ return [self.nom]
+
+ def verifExistenceSd(self):
+ """
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la referea ces concepts
+ """
+ # print "verifExistenceSd",self.sd
+ for motcle in self.mcListe:
+ motcle.verifExistenceSd()
+
+ def updateMcGlobal(self):
+ """
+ Met a jour les mots cles globaux enregistres dans l'etape
+ et dans le jdc parent.
+ Une etape ne peut pas etre globale. Elle se contente de passer
+ la requete a ses fils apres avoir reinitialise le dictionnaire
+ des mots cles globaux.
+ """
+ self.mc_globaux = {}
+ A_MCCOMPO.MCCOMPO.updateMcGlobal(self)
+
+ def updateConditionBloc(self):
+ """
+ Realise l'update des blocs conditionnels fils de self
+ """
+ self._updateConditionBloc()
+
+ def getObjetCommentarise(self, format):
+ """
+ Cette methode retourne un objet commande commentarisee
+ representant la commande self
+ """
+ import Accas.IO.generator as generator
+
+ g = generator.plugins[format]()
+ texte_commande = g.gener(self, format="beautifie")
+ # Il faut enlever la premiere ligne vide de texte_commande que
+ # rajoute le generator
+ # on construit l'objet COMMANDE_COMM repesentatif de self mais non
+ # enregistre dans le jdc (pas ajoute dans jdc.etapes)
+ parent = self.parent
+ pos = self.parent.etapes.index(self)
+ # on ajoute une fin à la commande pour pouvoir en commenter 2
+ texte_commande += "\nFin Commentaire"
+ commande_comment = commande_comm.COMMANDE_COMM(
+ texte=texte_commande, reg="non", parent=parent
+ )
+ self.parent.suppEntite(self)
+ parent.addEntite(commande_comment, pos)
+
+ return commande_comment
+
+ def modified(self):
+ """Le contenu de l'etape (mots cles, ...) a ete modifie"""
+ if self.nom == "DETRUIRE":
+ self.parent.controlContextApres(self)
+
+ # ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans processing
+ def buildSd(self, nom):
+ """
+ Mmethode de processing surchargee pour poursuivre malgre tout
+ si une erreur se produit pendant la creation du concept produit
+ """
+ try:
+ # sd = Accas.processing.P_ETAPE.ETAPE.buildSd(self, nom)
+ sd = P_ETAPE.ETAPE.buildSd(self, nom)
+ except AsException as e:
+ # Une erreur s'est produite lors de la construction du concept
+ # Comme on est dans EFICAS, on essaie de poursuivre quand meme
+ # Si on poursuit, on a le choix entre deux possibilites :
+ # 1. on annule la sd associee a self
+ # 2. on la conserve mais il faut la retourner
+ # En plus il faut rendre coherents sdnom et sd.nom
+ self.sd = None
+ self.sdnom = None
+ self.state = "unchanged"
+ self.valid = 0
+
+ return self.sd
+
+ # ATTENTION SURCHARGE: cette methode doit etre gardee en synchronisation avec processing
+ def makeRegister(self):
+ """
+ Initialise les attributs jdc, id, niveau et realise les
+ enregistrements necessaires
+ Pour EFICAS, on tient compte des niveaux
+ Surcharge la methode makeRegister du package processing
+ """
+ if self.parent:
+ self.jdc = self.parent.getJdcRoot()
+ self.id = self.parent.register(self)
+ self.UserError = self.jdc.UserError
+ if self.definition.niveau:
+ # La definition est dans un niveau. En plus on
+ # l'enregistre dans le niveau
+ self.nom_niveau_definition = self.definition.niveau.nom
+ self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
+ self.niveau.register(self)
+ else:
+ # La definition est au niveau global
+ self.nom_niveau_definition = "JDC"
+ self.niveau = self.parent
+ else:
+ self.jdc = self.parent = None
+ self.id = None
+ self.niveau = None
+ self.UserError = "UserError"
+
+ def report(self):
+ cr = V_ETAPE.ETAPE.report(self)
+ # rafraichisst de la validite de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)
+ self.isValid()
+ if not self.isValid() and self.nom == "INCLUDE":
+ self.cr.fatal(
+ "Etape : {} ligne : {} {}".format(
+ self.nom,
+ self.appel[0],
+ tr("\n Include Invalide. \n ne sera pas pris en compte"),
+ )
+ )
+ return cr
--- /dev/null
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+
+
+class EVAL:
+ """ """
+
+ def __init__(self, str):
+ """
+ L'objet EVAL est initialise avec une chaine de caracteres (str)
+ """
+ self.valeur = str
+ self.val = None
+
+ def __repr__(self):
+ return 'EVAL("""' + self.valeur + '""")'
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitEVAL(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+from Accas.accessor import A_REGLE
+
+
+class EXCLUS(A_REGLE.REGLE):
+ def purgeListe(self, liste_a_purger, listeMcPresents):
+ regle_active = 0
+ for mc_present in listeMcPresents:
+ if mc_present in self.mcs:
+ regle_active = 1
+ break
+ if not regle_active:
+ return liste_a_purger
+
+ for mc in self.mcs:
+ # Il ne faut pas purger un mot cle present. Sa cardinalite est verifiee par ailleurs
+ if mc in liste_a_purger and mc not in listeMcPresents:
+ liste_a_purger.remove(mc)
+ return liste_a_purger
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+import types
+
+
+class Fichier:
+ def __init__(
+ self, filtre="All Files (*)", existence="NonExistant", repertoire=None
+ ):
+ self.filtre = filtre
+ self.existence = existence
+ self.repertoire = repertoire
+
+ def __convert__(self, valeur):
+ # Attention ne verifie pas grand chose
+ if type(valeur) != bytes and type(valeur) != str:
+ return None
+ return valeur
+
+ def info(self):
+ return "Fichier de Type %s et %s" % (self.filtre, self.existence)
+
+ __repr__ = info
+ __str__ = info
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.accessor.A_ASSD import ASSD
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+
+class FONCTION(ASSD):
+ def __init__(self, etape=None, sd=None, reg="oui"):
+ if reg == "oui":
+ self.jdc.registerFonction(self)
+
+ def getFormule(self):
+ """
+ Retourne une formule decrivant self sous la forme d'un tuple :
+ (nom,type_retourne,arguments,corps)
+ """
+ if hasattr(self.etape, "getFormule"):
+ # on est dans le cas d'une formule Aster
+ return self.etape.getFormule()
+ else:
+ # on est dans le cas d'une fonction
+ return (self.nom, "REEL", "(REEL:x)", """bidon""")
+
+
+# On ajoute la classe formule pour etre coherent avec la
+# modification de C Durand sur la gestion des formules dans le superviseur
+# On conserve l'ancienne classe fonction (ceinture et bretelles)
+class fonction(FONCTION):
+ pass
+
+
+from Accas.extensions import param2
+
+
+class formule(FONCTION):
+ def __call__(self, *val):
+ if len(val) != len(self.nompar):
+ raise TypeError(
+ " %s() takes exactly %d argument (%d given)"
+ % (self.nom, len(self.nompar), len(val))
+ )
+ return param2.Unop2(self.nom, self.realCall, val)
+
+ def realCall(self, *val):
+ if hasattr(self.parent, "contexte_fichier_init"):
+ context = self.parent.contexte_fichier_init
+ else:
+ context = {}
+ i = 0
+ for param in self.nompar:
+ context[param] = val[i]
+ i = i + 1
+ try:
+ res = eval(self.expression, self.jdc.const_context, context)
+ except:
+ print(75 * "!")
+ print("! " + "Erreur evaluation formule %s" % self.nom + 20 * "!")
+ print(75 * "!")
+ raise EficasException
+ return res
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+classe pour declarer une formule
+tombée en désuétude
+Attention, n est pas projete en XSD
+verifier l analyse catalogue
+"""
+import string, traceback, re
+
+identifier = re.compile(r"^[^\d\W]\w*\Z", re.UNICODE)
+
+
+from Accas.extensions.eficas_translation import tr
+from Accas.accessor.A_MACRO_ETAPE import MACRO_ETAPE
+from Accas.extensions import interpreteur_formule
+from Editeur import analyse_catalogue
+
+analyse_catalogue.l_noms_commandes.append(
+ "FORM"
+) # declare le nom FORM a l'analyseur de catalogue
+
+
+class FORM_ETAPE(MACRO_ETAPE):
+ interpreteur = interpreteur_formule.Interpreteur_Formule
+
+ def MCBuild(self):
+ self.mcListe = self.buildMc()
+ # on cree la liste des types autorises (liste des noms de mots-cles
+ # simples dans le catalogue de FORMULE)
+ self.l_types_autorises = list(self.definition.entites.keys())
+ # en plus de la construction traditionnelle des fils de self
+ # il faut pour les FORMULE decortiquer l'expression ...
+ self.type_retourne, self.arguments, self.corps = self.analyseFormule()
+
+ def analyseFormule(self):
+ """
+ Cette methode decortique l'expression de la FORMULE.
+ Elle retourne 3 valeurs:
+ - le type retourne par la FORMULE
+ - les arguments de la FORMULE
+ - le corps de la FORMULE, cad son expression
+ """
+ if len(self.mcListe) == 0:
+ # pas de fils pour self --> la FORMULE est incomplete
+ return None, None, None
+ type_retourne = "REEL"
+ if len(self.mcListe) > 0:
+ child = self.mcListe[0] # child est un MCSIMP
+ corps = child.getVal()
+ else:
+ corps = None
+ if len(self.mcListe) > 1:
+ child = self.mcListe[1]
+ l_args = child.getVal()
+ else:
+ l_args = None
+ return type_retourne, l_args, corps
+
+ def getNom(self):
+ """
+ Retourne le nom de la FORMULE, cad le nom de la SD si elle existe,
+ la string vide sinon
+ """
+ if self.sd:
+ return self.sd.getName()
+ else:
+ return ""
+
+ def getFormule(self):
+ """
+ Retourne un tuple decrivant la formule :
+ (nom,type_retourne,arguments,corps)
+ """
+ t, a, c = self.analyseFormule()
+ n = self.getNom()
+ return (n, t, a, c)
+
+ def verifArguments(self, arguments=None):
+ """
+ Verifie si les arguments passes en argument (si aucun prend les arguments courants)
+ sont des arguments valide pour une FORMULE.
+ Retourne :
+ - un booleen, qui vaut 1 si arguments licites, 0 sinon
+ - un message d'erreurs ('' si illicites)
+ """
+ if not arguments:
+ arguments = self.arguments
+ if not arguments:
+ return 0, "Une formule doit avoir au minimum un argument"
+ # il faut au prealable enlever les parentheses ouvrantes et fermantes
+ # encadrant les arguments
+ arguments = string.strip(arguments)
+ if arguments[0] != "(":
+ return 0, tr(
+ "La liste des arguments d'une formule doit etre entre parentheses : parenthese ouvrante manquante"
+ )
+ if arguments[-1] != ")":
+ return 0, tr(
+ "La liste des arguments d'une formule doit etre entre parentheses : parenthese fermante manquante"
+ )
+ # on peut tester la syntaxe de chaque argument maintenant
+ erreur = ""
+ test = 1
+ arguments = arguments[1:-1] # on enleve les parentheses ouvrante et fermante
+ l_arguments = string.split(arguments, ",")
+ for a in l_arguments:
+ if not re.match(identifier, str(a)):
+ return 0, str(a) + " n est pas un identifiant"
+ return test, erreur
+
+ def verifCorps(self, corps=None, arguments=None):
+ """
+ Cette methode a pour but de verifier si le corps de la FORMULE
+ est syntaxiquement correct.
+ Retourne :
+ - un booleen, qui vaut 1 si corps de FORMULE licite, 0 sinon
+ - un message d'erreurs ('' si illicite)
+ """
+ if not corps:
+ corps = self.corps
+ if not arguments:
+ arguments = self.arguments
+ formule = (self.getNom(), self.type_retourne, arguments, corps)
+ # on recupere la liste des constantes et des autres fonctions predefinies
+ # et qui peuvent etre utilisees dans le corps de la formule courante
+ l_ctes, l_form = self.jdc.getParametresFonctionsAvantEtape(self)
+ # on cree un objet verificateur
+ try:
+ verificateur = self.interpreteur(
+ formule=formule, constantes=l_ctes, fonctions=l_form
+ )
+ except:
+ traceback.print_exc()
+ return 0, tr("Impossible de realiser la verification de la formule")
+ return verificateur.isValid(), verificateur.report()
+
+ def verifNom(self, nom=None):
+ """
+ Verifie si le nom passe en argument (si aucun prend le nom courant)
+ est un nom valide pour une FORMULE.
+ Retourne :
+ - un booleen, qui vaut 1 si nom licite, 0 sinon
+ - un message d'erreurs ('' si illicite)
+ """
+ if not nom:
+ nom = self.getNom()
+ if nom == "":
+ return 0, tr("Pas de nom donne a la FORMULE")
+ if len(nom) > 8:
+ return 0, tr("Un nom de FORMULE ne peut depasser 8 caracteres")
+ if nom[0] > "0" and nom[0] < "9":
+ return 0, tr("Un nom de FORMULE ne peut pas commencer par un chiffre")
+ sd = self.parent.getSdAutourEtape(nom, self)
+ if sd:
+ return 0, tr("Un concept de nom %s existe deja !" % nom)
+ return 1, ""
+
+ def verifType(self, type=None):
+ """
+ Verifie si le type passe en argument (si aucun prend le type courant)
+ est un type valide pour une FORMULE.
+ Retourne :
+ - un booleen, qui vaut 1 si type licite, 0 sinon
+ - un message d'erreurs ('' si illicite)
+ """
+ if not type:
+ type = self.type_retourne
+ if not type:
+ return 0, tr("Le type de la valeur retournee n'est pas specifie")
+ if type not in self.l_types_autorises:
+ return 0, tr("Une formule ne peut retourner une valeur de type : %s" % type)
+ return 1, ""
+
+ def verifFormule(self, formule=None):
+ """
+ Verifie la validite de la formule passee en argument.
+ Cette nouvelle formule est passee sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
+ Si aucune formule passee, prend les valeurs courantes de la formule
+ Retourne :
+ - un booleen, qui vaut 1 si formule licite, 0 sinon
+ - un message d'erreurs ('' si illicite)
+ """
+ if not formule:
+ formule = (None, None, None, None)
+ test_nom, erreur_nom = self.verifNom(formule[0])
+ test_type, erreur_type = self.verifType(formule[1])
+ if formule[2]:
+ args = "(" + formule[2] + ")"
+ else:
+ args = None
+ test_arguments, erreur_arguments = self.verifArguments(args)
+ test_corps, erreur_corps = self.verifCorps(corps=formule[3], arguments=args)
+ # test global = produit des tests partiels
+ test = test_nom * test_type * test_arguments * test_corps
+ # message d'erreurs global = concatenation des messages partiels
+ erreur = ""
+ if not test:
+ for mess in (erreur_nom, erreur_type, erreur_arguments, erreur_corps):
+ erreur = erreur + (len(mess) > 0) * "\n" + mess
+ return test, erreur
+
+ def verifFormule_python(self, formule=None):
+ """
+ Pour l instant ne fait qu un compile python
+ il serait possible d ajouter des tests sur les arguments
+ ou le type retourne mais ...
+ """
+ if not formule:
+ formule = (None, None, None, None)
+ test_nom, erreur_nom = self.verifNom(formule[0])
+ if formule[2]:
+ args = "(" + formule[2] + ")"
+ else:
+ args = None
+ test_arguments, erreur_arguments = self.verifArguments(args)
+ corps = formule[3]
+ erreur_formule = ""
+ test_formule = 1
+ try:
+ compile(corps, "<string>", "eval")
+ except:
+ erreur_formule = (
+ "le corps de la formule n'est pas une formule python valide"
+ )
+ test_formule = 0
+ erreur = ""
+ test = test_nom * test_arguments * test_formule
+ if not test:
+ for mess in (erreur_nom, erreur_arguments, erreur_formule):
+ erreur = erreur + (len(mess) > 0) * "\n" + mess
+ return test, erreur
+
+ def update(self, formule):
+ """
+ Methode externe.
+ Met a jour les champs nom, type_retourne,arguments et corps de la FORMULE
+ par les nouvelles valeurs passees dans le tuple formule.
+ On stocke les valeurs SANS verifications.
+ """
+ self.type_retourne = formule[1]
+ self.arguments = "(" + formule[2] + ")"
+ self.corps = formule[3]
+ # il faut ajouter le mot-cle simple correspondant dans mcListe
+ # pour cela on utilise la methode generale buildMc
+ # du coup on est oblige de modifier le dictionnaire valeur de self ...
+ self.valeur = {}
+ self.valeur[self.type_retourne] = self.arguments + " = " + self.corps
+ self.MCBuild()
+ sd = self.getSdProd()
+ if sd:
+ sd.nom = formule[0]
+
+ # bidouille PN
+ # Il faut que formule soit constituee de
+ # nom de la formule
+ # type retourne
+ # parametres
+ # corps de la fonction
+ # il faut aussi que les arguments soient sous forme de tuple
+ def updateFormulePython(self, formule):
+ self.buildMc()
+ self.mcListe = []
+ if len(formule) < 4:
+ return 0
+ arguments = formule[3]
+ if arguments[0] == "(":
+ arguments = arguments[1:]
+ if arguments[-1] == ")":
+ arguments = arguments[:-1]
+ self.arguments = tuple(arguments.split(","))
+
+ mocles = {"NOM_PARA": self.arguments}
+ if formule[1] == "REEL":
+ mocles["VALE"] = formule[2]
+ if formule[1] == "COMPLEXE":
+ mocles["VALE_C"] = formule[2]
+
+ for k, v in self.definition.entites.items():
+ if not k in mocles:
+ continue
+ child = self.definition.entites[k](None, nom=k, parent=self)
+ child.valeur = mocles[k]
+ child.state = "modified"
+ self.mcListe.append(child)
+
+ self.corps = formule[2]
+ self.type_retourne = formule[1]
+ sd = self.getSdProd()
+ if sd:
+ sd.nom = formule[0]
+ self.initModif()
+ return 1
+
+ def active(self):
+ """
+ Rend l'etape courante active.
+ Il faut ajouter la formule au contexte global du JDC
+ """
+ self.actif = 1
+ self.initModif()
+ nom = self.getNom()
+ if nom == "":
+ return
+ try:
+ self.jdc.appendFonction(self.sd)
+ except:
+ pass
+
+ def inactive(self):
+ """
+ Rend l'etape courante inactive
+ Il faut supprimer la formule du contexte global du JDC
+ """
+ self.actif = 0
+ self.initModif()
+ if not self.sd:
+ return
+ self.jdc.delFonction(self.sd)
+
+ def updateConcept(self, sd):
+ return
+
+ def deleteConcept(self, sd):
+ """
+ Inputs :
+ - sd=concept detruit
+ Fonction :
+ Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse
+ suite a la disparition du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,
+ sauf les objets FORM_ETAPE qui doivent verifier que le concept detruit n'est pas
+ utilise dans le corps de la fonction
+ """
+ self.initModif()
+
+ def replaceConcept(self, old_sd, sd):
+ """
+ Inputs :
+ - old_sd=concept remplace
+ - sd = nouveau concept
+ Fonction :
+ Les objets FORM_ETAPE devraient verifier que le concept remplace n'est pas
+ utilise dans le corps de la fonction
+ """
+ self.initModif()
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+# Modules Python
+import types, traceback, sys, os
+import linecache
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+
+# Modules Eficas
+from Accas.accessor import A_OBJECT
+from Accas.processing.P_ASSD import ASSD
+
+# from Accas.processing.P_LASSD import LASSD
+from Accas.processing.P_ETAPE import ETAPE
+from Accas.processing.P_Exception import AsException
+from Accas.extensions import commentaire, parametre, parametre_eval
+from Accas.accessor import CONNECTOR
+from Accas.validation import V_JDC
+
+try:
+ basestring
+except NameError:
+ basestring = str
+
+
+class LASSD:
+ pass
+
+
+class JDC(A_OBJECT.OBJECT):
+ """ """
+
+ def __init__(self):
+ self.editmode = 0
+ self.etapes_niveaux = []
+ self.niveau = self
+ self.params = []
+ self.fonctions = []
+ self._etape_context = None
+ self.recorded_units = {}
+ self.old_recorded_units = {}
+
+ def getIndex(self, objet):
+ """
+ Retourne la position d'objet dans la liste self
+ """
+ return self.etapes.index(objet)
+
+ def getSdAvantDuBonType(self, etape, types_permis):
+ """
+ Retourne la liste des concepts avant etape d'un type acceptable
+ """
+ # print ('getSdAvantDuBonType ', types_permis)
+ d = self.getContexteAvant(etape)
+
+ l = []
+ for k, v in d.items():
+ # if type(v) != types.InstanceType and not isinstance(v,object): continue
+ if not isinstance(v, object):
+ continue
+ # On considere que seul assd indique un type quelconque pas CO
+ elif self.assd in types_permis:
+ if v.etape.sdnom != "sansnom":
+ l.append(k)
+ elif self.estPermis(v, types_permis):
+ if v.etape.sdnom != "sansnom":
+ l.append(k)
+ l.sort()
+ return l
+
+ def getSdCreeParObjet(self, classeAChercher):
+ l = []
+ for v in list(self.sdsDict.keys()):
+ if isinstance(self.sdsDict[v], classeAChercher):
+ l.append(self.sdsDict[v])
+ return l
+
+ def getVariables(self, etape):
+ etapeStop = etape
+ l = []
+ for etapeTraitee in self.etapes:
+ if etapeTraitee == etapeStop:
+ break
+ if etapeTraitee.nom == "VARIABLE":
+ variable = etapeTraitee.getMocle("ModelVariable")
+ if variable != None:
+ l.append(variable.nom)
+ return l
+
+ def getDistributions(self, etape):
+ etapeStop = etape
+ l = []
+ for etapeTraitee in self.etapes:
+ if etapeTraitee == etapeStop:
+ break
+ if etapeTraitee.nom == "DISTRIBUTION" and etapeTraitee.sd != None:
+ l.append(etapeTraitee.sd.nom)
+ return l
+
+ # def set_Copules_recalcule_etat(self):
+ # for etapeTraitee in self.etapes :
+ # if etapeTraitee.nom == 'CORRELATION' :
+ # Matrix=etapeTraitee.getChild('Matrix')
+ # if Matrix !=None :
+ # Correlation=etapeTraitee.getChild('CorrelationMatrix')
+ # if Correlation !=None : Correlation.state='arecalculer'
+ # Matrix.state='arecalculer'
+
+ # def recalculeEtatCorrelation(self):
+ # for etapeTraitee in self.etapes :
+ # if etapeTraitee.nom == 'CORRELATION' :
+ # Matrix=etapeTraitee.getChild('Matrix')
+ # if Matrix !=None :
+ # Matrix.state='arecalculer'
+ # Correlation=Matrix.getChild('CorrelationMatrix')
+ # if Correlation !=None : Correlation.state='arecalculer'
+ # Correlation.isValid()
+ # Matrix.isValid()
+ # etapeTraitee.state='arecalculer'
+ # if etapeTraitee.state=='arecalculer': etapeTraitee.isValid()
+
+ def recalculeEtatCorrelation(self):
+ for etapeTraitee in self.etapes:
+ if etapeTraitee.nom == "CORRELATION":
+ Correlation = etapeTraitee.getChild("CorrelationMatrix")
+ if Correlation != None:
+ Correlation.state = "arecalculer"
+ Correlation.isValid()
+ etapeTraitee.isValid()
+
+ def recalculeValiditeApresChangementGlobalJdc(self, motClef):
+ # print ("je passe dans recalculeValiditeApresChangementGlobalJdc")
+ try:
+ liste = self.getJdcRoot().cata.dict_condition[motClef.nom]
+ except:
+ liste = ()
+ for etapeTraitee in self.etapes:
+ if etapeTraitee.nom not in liste:
+ continue
+ # self.forceRecalculBloc(etapeTraitee)
+ etapeTraitee.state = "arecalculer"
+ etapeTraitee.deepUpdateConditionBloc()
+ etapeTraitee.isValid()
+ # print (etapeTraitee.nom ,etapeTraitee.isValid())
+
+ def activeBlocsGlobaux(self):
+ for nomMotClef in self.mc_globaux:
+ motClef = self.mc_globaux[nomMotClef]
+ if nomMotClef in list(self.cata.dict_condition.keys()):
+ liste = self.cata.dict_condition[nomMotClef]
+ else:
+ liste = ()
+ for etapeTraitee in self.etapes:
+ if etapeTraitee.nom not in liste:
+ continue
+ etapeTraitee.state = "arecalculer"
+ etapeTraitee.deepUpdateConditionBlocApresCreation()
+ etapeTraitee.isValid()
+
+ # def forceRecalculBloc(self,objet):
+ # Attention : certains objets deviennent None quand on recalcule
+ # les conditions d existence des blocs
+ # if objet != None: objet.state='arecalculer'
+ # if hasattr(objet,'listeMcPresents'):
+ # for childNom in objet.listeMcPresents():
+ # child=objet.getChild(childNom)
+ # if hasattr(objet,'_updateConditionBloc'):objet._updateConditionBloc()
+ # self.forceRecalculBloc(child)
+
+ def getSdAvantDuBonTypePourTypeDeBase(self, etape, type):
+ """
+ Retourne la liste des concepts avant etape d'1 type de base acceptable
+ Attention different de la routine precedente : 1 seul type passe en parametre
+ Teste sur issubclass et par sur le type permis
+ """
+ d = self.getContexteAvant(etape)
+ l = []
+ try:
+ typeverif = self.cata.__dict__[type]
+ except:
+ return l
+ for k, v in d.items():
+ if issubclass(v.__class__, typeverif):
+ l.append(k)
+ l.sort()
+ return l
+
+ def chercheListAvant(self, etape, valeur):
+ d = self.getContexteAvant(etape)
+ for k, v in d.items():
+ if issubclass(v.__class__, LASSD):
+ if k == valeur:
+ return k
+ # Attention pour enlever les . a la fin des pretendus reels
+ if k == valeur[0:-1]:
+ return v
+ return None
+
+ def estPermis(self, v, types_permis):
+ for type_ok in types_permis:
+ if type_ok in ("R", "I", "C", "TXM") and v in self.params:
+ return 1
+ elif type_ok == "R" and v.__class__.__name__ == "reel":
+ return 1
+ elif type_ok == "I" and v.__class__.__name__ == "entier":
+ return 1
+ elif type_ok == "C" and v.__class__.__name__ == "complexe":
+ return 1
+ elif type_ok == "TXM" and v.__class__.__name__ == "chaine":
+ return 1
+ elif type(type_ok) != type and not isinstance(type_ok, type):
+ continue
+ elif v.__class__ == type_ok or issubclass(v.__class__, type_ok):
+ return 1
+ return 0
+
+ def addEntite(self, name, pos):
+ """
+ Ajoute une entite :
+ Si name est le nom d une commande ou un commentaire ajoute
+ une etape au JDC
+ Sinon remonte une erreur
+ """
+ self.initModif()
+ self.editmode = 1
+ if name == "COMMENTAIRE":
+ from Accas.extensions import commentaire
+
+ # ajout d'un commentaire
+ self.setCurrentStep()
+ ind = 1
+ for child in self.etapes:
+ if isinstance(child, commentaire.COMMENTAIRE):
+ ind = ind + 1
+ objet = commentaire.COMMENTAIRE("", parent=self)
+ objet.nom = "_comm_" + repr(ind)
+ if pos == None:
+ pos = 0
+ self.etapes.insert(pos, objet)
+ self.resetContext()
+ self.editmode = 0
+ self.activeEtapes()
+ CONNECTOR.Emit(self, "add", objet)
+ self.finModif()
+ return objet
+ elif name == "PARAMETRE":
+ # ajout d'un parametre
+ self.setCurrentStep()
+ nom_param = "_param_" + str(len(self.params) + 1)
+ objet = parametre.PARAMETRE(nom=nom_param)
+ if pos == None:
+ pos = 0
+ self.etapes.insert(pos, objet)
+ self.resetContext()
+ self.editmode = 0
+ self.activeEtapes()
+ CONNECTOR.Emit(self, "add", objet)
+ self.finModif()
+ return objet
+ elif name == "PARAMETRE_EVAL":
+ # ajout d'un parametre EVAL
+ self.setCurrentStep()
+ nom_param = "_param_" + str(len(self.params) + 1)
+ objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
+ if pos == None:
+ pos = 0
+ self.etapes.insert(pos, objet)
+ self.resetContext()
+ self.editmode = 0
+ self.activeEtapes()
+ CONNECTOR.Emit(self, "add", objet)
+ self.finModif()
+ return objet
+ elif not (isinstance(name, basestring)):
+ # elif type(name)==types.InstanceType:
+ # elif isinstance(name,object):
+ # on est dans le cas ou on veut ajouter une commande deja
+ # existante (par copie donc)
+ # on est donc necessairement en mode editeur ...
+ objet = name
+ # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
+ from Accas.extensions import commentaire
+
+ if not (isinstance(objet, commentaire.COMMENTAIRE)):
+ objet.reparent(self)
+ self.setCurrentStep()
+ if isinstance(objet, ETAPE):
+ if objet.nom_niveau_definition == "JDC":
+ # l'objet depend directement du JDC
+ objet.niveau = self
+ else:
+ # l'etape depend d'un niveau et non directement du JDC :
+ # il faut l'enregistrer dans le niveau de parent
+ objet.parent.dict_niveaux[objet.nom_niveau_definition].register(
+ objet
+ )
+ objet.niveau = objet.parent.dict_niveaux[
+ objet.nom_niveau_definition
+ ]
+ self.etapes.insert(pos, objet)
+ self.resetContext()
+ # il faut verifier que les concepts utilises par objet existent bien
+ # a ce niveau d'arborescence
+ objet.verifExistenceSd()
+ objet.updateMcGlobal()
+ self.editmode = 0
+ self.activeEtapes()
+ CONNECTOR.Emit(self, "add", objet)
+ self.finModif()
+ return objet
+ else:
+ # On veut ajouter une nouvelle commande
+ try:
+ self.setCurrentStep()
+ cmd = self.getCmd(name)
+ # L'appel a make_objet n'a pas pour effet d'enregistrer l'etape
+ # aupres du step courant car editmode vaut 1
+ # Par contre elle a le bon parent grace a setCurrentStep
+ e = cmd.make_objet()
+ if pos == None:
+ pos = 0
+ self.etapes.insert(pos, e)
+ self.resetCurrentStep()
+ self.resetContext()
+ self.editmode = 0
+ self.activeEtapes()
+ self.enregistreEtapePyxb(e, pos)
+ # PN fait ds self.activeEtapes
+ CONNECTOR.Emit(self, "add", e)
+ self.finModif()
+ return e
+ except AsException as e:
+ traceback.print_exc()
+ self.resetCurrentStep()
+ self.editmode = 0
+ raise AsException(tr("Impossible d'ajouter la commande") + name + "\n")
+ except:
+ # else :
+ traceback.print_exc()
+ self.resetCurrentStep()
+ self.editmode = 0
+ raise AsException(tr("Impossible d ajouter la commande") + name)
+
+ def close(self):
+ # print "JDC.close",self
+ for etape in self.etapes:
+ if hasattr(etape, "close"):
+ etape.close()
+ CONNECTOR.Emit(self, "close")
+
+ def setCurrentStep(self):
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(self)
+
+ def resetCurrentStep(self):
+ CONTEXT.unsetCurrentStep()
+
+ def listeMcPresents(self):
+ return []
+
+ def getSdAvantEtape(self, nom_sd, etape):
+ return self.getContexteAvant(etape).get(nom_sd, None)
+
+ def getSdApresEtapeAvecDetruire(self, nom_sd, sd, etape, avec="non"):
+ """
+ Cette methode retourne la SD sd de nom nom_sd qui est eventuellement
+ definie apres etape en tenant compte des concepts detruits
+ Si avec vaut 'non' exclut etape de la recherche
+ """
+ # print "JDC.getSdApresEtapeAvecDetruire",nom_sd,sd
+ ietap = self.etapes.index(etape)
+ if avec == "non":
+ ietap = ietap + 1
+ d = {nom_sd: sd}
+ for e in self.etapes[ietap:]:
+ if e.isActif():
+ e.updateContext(d)
+ autre_sd = d.get(nom_sd, None)
+ if autre_sd is None:
+ # Le concept a ete detruit. On interrompt la recherche car il n'y a
+ # pas eu de redefinition du concept (il n'y a pas de conflit potentiel).
+ return None
+ if autre_sd is not sd:
+ # L'etape produit un concept different de meme nom. La situation n'est
+ # pas saine (sauf peut etre si reuse ???)
+ if hasattr(e, "reuse") and e.reuse == autre_sd:
+ # Le concept etant reutilise, on interrompt la recherche.
+ # On considere qu'il n'y a pas de nouveau concept defini
+ # meme si dans les etapes suivantes le concept est detruit
+ # et un concept de meme nom cree.
+ # AVERIFIER : avec reuse le concept devrait etre le meme
+ # le passage par ici est tres improbable
+ return None
+ else:
+ # Le concept est produit par l'etape (Il y a conflit potentiel).
+ # Le concept est redefini par une etape posterieure.
+ return autre_sd
+ # Pas de destruction du concept ni de redefinition. On retourne le
+ # concept initial
+ return sd
+
+ def getSdApresEtape(self, nom_sd, etape, avec="non"):
+ """
+ Cette methode retourne la SD de nom nom_sd qui est eventuellement
+ definie apres etape
+ Si avec vaut 'non' exclut etape de la recherche
+ """
+ ietap = self.etapes.index(etape)
+ if avec == "non":
+ ietap = ietap + 1
+ for e in self.etapes[ietap:]:
+ sd = e.getSdprods(nom_sd)
+ if sd:
+ if hasattr(e, "reuse"):
+ if e.reuse != sd:
+ return sd
+ return None
+
+ def getSdAutourEtape(self, nom_sd, etape, avec="non"):
+ """
+ Fonction: retourne la SD de nom nom_sd qui est eventuellement
+ definie avant ou apres etape
+ Permet de verifier si un concept de meme nom existe dans le perimetre
+ d'une etape
+ Si avec vaut 'non' exclut etape de la recherche
+ """
+ sd = self.getSdAvantEtape(nom_sd, etape)
+ if sd:
+ return sd
+ sd = self.getSdApresEtape(nom_sd, etape, avec)
+ if sd:
+ return sd
+ # Pour tenir compte des UserASSD # et des UserASSDMultiple a affiner
+ if nom_sd in self.sdsDict.keys():
+ sd = self.sdsDict[nom_sd]
+ return sd
+
+ def getContexte_apres(self, etape):
+ """
+ Retourne le dictionnaire des concepts connus apres etape
+ On tient compte des commandes qui modifient le contexte
+ comme DETRUIRE ou les macros
+ Si etape == None, on retourne le contexte en fin de JDC
+ """
+ if not etape:
+ return self.getContexteAvant(etape)
+
+ d = self.getContexteAvant(etape)
+ if etape.isActif():
+ etape.updateContext(d)
+ self.index_etape_courante = self.index_etape_courante + 1
+ return d
+
+ def activeEtapes(self):
+ """ """
+ for etape in self.etapes:
+ etape.active()
+
+ def deplaceEntite(self, indexNoeudACopier, indexNoeudOuColler, pos):
+ """
+ Pour le cut
+ """
+ if indexNoeudACopier == indexNoeudOuColler:
+ return
+ etapeACopier = self.etapes[indexNoeudACopier]
+ try:
+ sd = self.etapes[indexNoeudACopier].sd
+ except:
+ sd = None
+ if pos == "before" and indexNoeudOuColler == 0:
+ self.etapes2 = (
+ [
+ etapeACopier,
+ ]
+ + self.etapes[0:indexNoeudACopier]
+ + self.etapes[indexNoeudACopier + 1 :]
+ )
+ elif indexNoeudACopier < indexNoeudOuColler:
+ self.etapes2 = (
+ self.etapes[0:indexNoeudACopier]
+ + self.etapes[indexNoeudACopier + 1 : indexNoeudOuColler + 1]
+ + [
+ etapeACopier,
+ ]
+ + self.etapes[indexNoeudOuColler + 1 :]
+ )
+ else:
+ self.etapes2 = (
+ self.etapes[0 : indexNoeudOuColler + 1]
+ + [
+ etapeACopier,
+ ]
+ + self.etapes[indexNoeudOuColler + 1 : indexNoeudACopier]
+ + self.etapes[indexNoeudACopier + 1 :]
+ )
+ self.etapes = self.etapes2
+ if indexNoeudACopier < indexNoeudOuColler:
+ self.deleteConceptEntreEtapes(indexNoeudACopier, indexNoeudOuColler, sd)
+ self.resetContext()
+ for e in self.etapes:
+ e.state = "modified"
+ self.controlContextApres(None)
+ return 1
+
+ def suppEntite(self, etape):
+ """
+ Cette methode a pour fonction de supprimer une etape dans
+ un jeu de commandes
+ Retourne 1 si la suppression a pu etre effectuee,
+ Retourne 0 dans le cas contraire
+ """
+ # PN correction de bugs
+ # print ('suppEntite', etape.nom)
+ if etape not in self.etapes:
+ return 0
+ # print ('suppEntite', etape.nom)
+ if etape.nom == "ExpressionIncertitude":
+ etape.delieIncertitude()
+
+ self.initModif()
+ index_etape = self.etapes.index(etape)
+
+ # etape.delObjPyxb()
+ self.etapes.remove(etape)
+
+ if etape.niveau is not self:
+ # Dans ce cas l'etape est enregistree dans un niveau
+ # Il faut la desenregistrer
+ etape.niveau.unregister(etape)
+
+ etape.supprimeSdProds()
+ etape.supprimeUserAssd()
+ etape.close()
+ etape.supprime()
+ self.activeEtapes()
+
+ # Apres suppression de l'etape il faut controler que les etapes
+ # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
+ if index_etape > 0:
+ index_etape = index_etape - 1
+ etape = self.etapes[index_etape]
+ else:
+ etape = None
+ self.controlContextApres(etape)
+
+ self.resetContext()
+ CONNECTOR.Emit(self, "supp", etape)
+ self.finModif()
+ return 1
+
+ def controlContextApres(self, etape):
+ """
+ Cette methode verifie que les etapes apres l'etape etape
+ ont bien des concepts produits acceptables (pas de conflit de
+ nom principalement)
+ Si des concepts produits ne sont pas acceptables ils sont supprimes.
+ Effectue les verifications sur les etapes du jdc mais aussi sur les
+ jdc parents s'ils existent.
+ """
+ # print ("controlContextApres",self,etape)
+ # Regularise les etapes du jdc apres l'etape etape
+ self.controlJdcContextApres(etape)
+
+ def controlJdcContextApres(self, etape):
+ """
+ Methode semblable a controlContextApres mais ne travaille
+ que sur les etapes et sous etapes du jdc
+ """
+ # print ("controlJdcContextApres",self,etape)
+ if etape is None:
+ # on demarre de la premiere etape
+ index_etape = 0
+ else:
+ index_etape = self.etapes.index(etape) + 1
+
+ try:
+ etape = self.etapes[index_etape]
+ except:
+ # derniere etape du jdc : rien a faire
+ return
+
+ context = self.getContexteAvant(etape)
+ for e in self.etapes[index_etape:]:
+ e.controlSdprods(context)
+ e.updateContext(context)
+
+ def analyse(self):
+ self.compile()
+ self.execCompile()
+ if not self.cr.estvide():
+ return
+ self.activeEtapes()
+ if self.mc_globaux != {}:
+ self.activeBlocsGlobaux()
+
+ def analyseXML(self):
+ # print ('analyseXML')
+ # print (self.procedure)
+ self.setCurrentContext()
+ try:
+ self.analyseFromXML()
+ except Exception as e:
+ print("Erreur dans analyseXML a la generation du JDC a partir du xml")
+ # import traceback
+ # traceback.print_stack()
+ # Erreur lors de la conversion
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ self.cr.exception(
+ tr("Impossible de convertir le fichier XML\n %s", "".join(l))
+ )
+ print(e)
+ return
+
+ def registerParametre(self, param):
+ """
+ Cette methode sert a ajouter un parametre dans la liste des parametres
+ """
+ self.params.append(param)
+
+ def registerFonction(self, fonction):
+ """
+ Cette methode sert a ajouter une fonction dans la liste des fonctions
+ """
+ self.fonctions.append(fonction)
+
+ def deleteParam(self, param):
+ """
+ Supprime le parametre param de la liste des parametres
+ et du contexte gobal
+ """
+ if param in self.params:
+ self.params.remove(param)
+ if param.nom in self.g_context:
+ del self.g_context[param.nom]
+
+ def getParametresFonctionsAvantEtape(self, etape):
+ """
+ Retourne deux elements :
+ - une liste contenant les noms des parametres (constantes ou EVAL)
+ definis avant etape
+ - une liste contenant les formules definies avant etape
+ """
+ l_constantes = []
+ l_fonctions = []
+ # on recupere le contexte avant etape
+ # on ne peut mettre dans les deux listes que des elements de ce contexte
+ d = self.getContexteAvant(etape)
+ # construction de l_constantes
+ for param in self.params:
+ nom = param.nom
+ if not nom:
+ continue
+ if nom in d:
+ l_constantes.append(nom)
+ # construction de l_fonctions
+ for form in self.fonctions:
+ nom = form.nom
+ if not nom:
+ continue
+ if nom in d:
+ l_fonctions.append(form.getFormule())
+
+ # on ajoute les concepts produits par DEFA_VALEUR
+ # XXX On pourrait peut etre faire plutot le test sur le type
+ # de concept : entier, reel, complexe, etc.
+ for k, v in d.items():
+ if hasattr(v, "etape") and v.etape.nom in ("DEFA_VALEUR",):
+ l_constantes.append(k)
+
+ # on retourne les deux listes
+ return l_constantes, l_fonctions
+
+ def getNbEtapesAvant(self, niveau):
+ """
+ Retourne le nombre d etapes avant le debut de niveau
+ """
+ nb = 0
+ for niv in self.etapes_niveaux:
+ if niv == niveau:
+ break
+ nb = nb + len(niv.etapes)
+ return nb
+
+ def initModif(self):
+ """
+ Methode appelee au moment ou une modification va etre faite afin de
+ declencher d'eventuels traitements pre-modification
+ """
+ # print "initModif",self
+ self.state = "modified"
+
+ def finModif(self):
+ # print "finModif",self
+ CONNECTOR.Emit(self, "valid")
+ self.isValid()
+ pass
+
+ def deepUpdateConditionBloc(self, motClef=None):
+ # pour le moment, on ne fait rien
+ self.getJdcRoot().recalculeValiditeApresChangementGlobalJdc(motClef)
+ # raise EficasException(tr("Pas implemente"))
+
+ def updateConditionBloc(self):
+ # pour le moment, on ne fait rien
+ raise EficasException(tr("Pas implemente"))
+
+ def getListeMcInconnus(self):
+ """
+ Retourne une liste contenant les mots-cles inconnus a la relecture du JDC
+ """
+ # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
+ l_mc = []
+ for etape in self.etapes:
+ if etape.isActif():
+ if not etape.isValid():
+ l = etape.getListeMcInconnus()
+ if l:
+ l_mc.extend(l)
+ return l_mc
+
+ def getMCPath(self):
+ return []
+
+ def getGenealogiePrecise(self):
+ return []
+
+ def getObjetByMCPath(self, MCPath):
+ # Attention; le MCPath n est valide qu a la lecture du fichier
+ etape = None
+ nomEtape = MCPath[0]
+ nomSuivant = MCPath[1]
+ if nomSuivant.startswith("@sdname "):
+ nomEtape = nomSuivant.split(" ")[1]
+ etape = self.getEtapeByConceptName(nomEtape)
+ elif nomSuivant.startswith("@index "):
+ indexEtape = nomSuivant.split(" ")[1]
+ etape = self.getEtapesByName(nomEtape)[indexEtape]
+ if not etape:
+ return None
+ return etape.getObjetByMCPath(MCPath[2:])
+
+ def selectXYWhereCondition(self, MCPath1, MCPath2, MCARetourner, MCCondition, valeur):
+ #---------------------------------------------------------------------------------------
+ # est-ce que cette signature va bien ?
+ # elle permet de selection MCARetourner sous MCPath2 si MCCondition sous MCPath2 == valeur
+ # il y aura surement d autres cas
+ # est-ce qu il ne faut pas deja prevoir les etapes nommees
+ # retourne la valeur de MCPath1 et de MCARetourner
+ # si dans le fact decrit par MCPath2, le MCCOndition == Valeur
+ # fact
+
+ debug=0
+ from Accas import MCList
+ if MCPath1[0] != MCPath2[0] :
+ print (' les MCPaths n indiquent pas la meme etape' )
+ return []
+ listeDonnees=[]
+ if debug : print ('McPath1 ', MCPath1)
+ if debug : print ('McPath2 ', MCPath2)
+ if debug : print ('McARetourner ', MCARetourner)
+ if debug : print ('MCCondition ', MCCondition)
+ if debug : print ('valeur ', valeur)
+ for e in self.etapes:
+ if e.nom != MCPath1[0] : continue
+ obj2=e.getObjetByMCPath(MCPath2[1:])
+ if not obj2 : continue
+ if not (isinstance(obj2,MCList) and len(obj2) > 1) : obj2=(obj2,)
+ if debug : print ('obj2', obj2)
+ for o in obj2 :
+ objCondition = o.getChild(MCCondition)
+ if debug : print ('objCondition', objCondition)
+ if objCondition.valeur != valeur : continue
+ if debug : print ('la condition est vraie')
+
+ objX=e.getObjetByMCPath(MCPath1[1:])
+ objY=o.getChild(MCARetourner)
+ if not objX or not objY : continue
+ listeDonnees.append((objX.valeur,objY.valeur))
+ return listeDonnees
+
+
+ def selectXY(self, MCPath1, MCPath2):
+ #------------------------------------
+ debug=0
+ from Accas import MCList
+ if MCPath1[0] != MCPath2[0] :
+ print (' les MCPaths n indiquent pas la meme etape' )
+ return []
+ listeDonnees=[]
+ if debug : print ('McPath1 ', MCPath1)
+ if debug : print ('McPath2 ', MCPath2)
+ for e in self.etapes:
+ if debug : print (e, e.nom)
+ if e.nom != MCPath1[0] : continue
+ objX=e.getObjetByMCPath(MCPath1[1:])
+ if debug : print ('objX', objX)
+ objY=e.getObjetByMCPath(MCPath2[1:])
+ if debug : print ('objY', objY)
+ if not objX or not objY : continue
+ listeDonnees.append((objX.valeur,objY.valeur))
+ return listeDonnees
+ def getGenealogie(self):
+ """
+ Retourne la liste des noms des ascendants de l'objet self
+ jusqu'a la premiere ETAPE parent.
+ """
+ return []
+
+ def getListeCmd(self):
+ """
+ Retourne la liste des commandes du catalogue
+ """
+ return self.niveau.definition.getListeCmd()
+
+ def getGroups(self):
+ """
+ Retourne la liste des groupes
+ """
+ return self.niveau.definition.liste_groupes, self.niveau.definition.dict_groupes
+
+ def setEtapeContext(self, etape):
+ """
+ Positionne l'etape qui sera utilisee dans NommerSdProd pour
+ decider si le concept passe pourra etre nomme
+ """
+ self._etape_context = etape
+
+ def resetContext(self):
+ """
+ Cette methode reinitialise le contexte glissant pour pouvoir
+ tenir compte des modifications de l'utilisateur : craation
+ de commandes, nommage de concepts, etc.
+ """
+ # print "resetContext",self,self.nom
+ self.currentContext = {}
+ self.index_etape_courante = 0
+ ind = {}
+ for i, etape in enumerate(self.etapes):
+ ind[etape] = i
+ self.index_etapes = ind
+
+ # for etape in self.etapes:
+ # etape.resetContext()
+
+ def delSdprod(self, sd):
+ """
+ Supprime la SD sd de la liste des sd et des dictionnaires de contexte
+ """
+ # print "delSdprod",self,sd
+ # print "delSdprod",self.sds
+ # print "delSdprod",self.g_context
+ # print "delSdprod",self.sdsDict
+ # if sd in self.sds : self.sds.remove(sd)
+ if sd.nom in self.g_context:
+ del self.g_context[sd.nom]
+ if sd.nom in self.sdsDict:
+ del self.sdsDict[sd.nom]
+
+ def delParam(self, param):
+ """
+ Supprime le parametre param de la liste des paramatres
+ et du contexte gobal
+ """
+ if param in self.params:
+ self.params.remove(param)
+ if param.nom in self.g_context:
+ del self.g_context[param.nom]
+
+ def delFonction(self, fonction):
+ """
+ Supprime la fonction fonction de la liste des fonctions
+ et du contexte gobal
+ """
+ if fonction in self.fonctions:
+ self.fonctions.remove(fonction)
+ if fonction.nom in self.g_context:
+ del self.g_context[fonction.nom]
+
+ def appendSdProd(self, sd):
+ """
+ Ajoute la SD sd a la liste des sd en verifiant au prealable qu'une SD de
+ meme nom n'existe pas deja
+ """
+ if sd == None or sd.nom == None:
+ return
+ o = self.sdsDict.get(sd.nom, None)
+ if isinstance(o, ASSD):
+ raise AsException(tr("Nom de concept deja defini " + sd.nom))
+ self.sdsDict[sd.nom] = sd
+ self.g_context[sd.nom] = sd
+ # if sd not in self.sds : self.sds.append(sd)
+
+ def appendParam(self, param):
+ """
+ Ajoute le parametre param a la liste des params
+ et au contexte global
+ """
+ # il faudrait verifier qu'un parametre de meme nom n'existe pas deja !!!
+ if param not in self.params:
+ self.params.append(param)
+ self.g_context[param.nom] = param
+
+ def appendFonction(self, fonction):
+ """
+ Ajoute la fonction fonction a la liste des fonctions
+ et au contexte global
+ """
+ # il faudrait verifier qu'une fonction de meme nom n'existe pas deja !!!
+ if fonction not in self.fonctions:
+ self.fonctions.append(fonction)
+ self.g_context[fonction.nom] = fonction
+
+ def deleteConcept(self, sd):
+ """
+ Inputs :
+ - sd=concept detruit
+ Fonction :
+ Mettre a jour les etapes du JDC suite a la disparition du
+ concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
+ """
+ for etape in self.etapes:
+ etape.deleteConcept(sd)
+ # PN PN PN pour les matrices ????
+ # self.getVariables_avant(etape)
+
+ def replaceConceptAfterEtape(self, etape, old_sd, sd):
+ """
+ Met a jour les etapes du JDC qui sont apres etape en fonction
+ du remplacement du concept sd
+ """
+ index = self.etapes.index(etape) + 1
+ if index == len(self.etapes):
+ return # etape est la derniere etape du jdc ...on ne fait rien !
+ for child in self.etapes[index:]:
+ child.replaceConcept(old_sd, sd)
+
+ def updateConceptAfterEtape(self, etape, sd):
+ """
+ Met a jour les etapes du JDC qui sont apres etape en fonction
+ de la modification (principalement nommage) du concept sd
+ """
+ if etape is None:
+ # On traite toutes les etapes
+ index = 0
+ else:
+ index = self.etapes.index(etape) + 1
+ if index == len(self.etapes):
+ return # etape est la derniere etape du jdc ...on ne fait rien !
+ for child in self.etapes[index:]:
+ child.updateConcept(sd)
+
+ def dumpState(self):
+ # print(("JDC.state: ",self.state))
+ for etape in self.etapes:
+ print((etape.nom + ".state: ", etape.state))
+
+ def changeUnit(self, unit, etape, old_unit):
+ # print "changeUnit",unit,etape,old_unit
+ # print id(self.recorded_units),self.recorded_units
+ # if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
+ self.recordUnit(unit, etape)
+
+ def recordUnit(self, unit, etape):
+ """Enregistre les unites logiques incluses et les infos relatives a l'etape"""
+ # print "recordUnit",unit,etape
+ if unit is None:
+ # Cas de POURSUITE
+ self.recorded_units[None] = (
+ etape.fichier_ini,
+ etape.fichier_text,
+ etape.recorded_units,
+ )
+ else:
+ self.recorded_units[unit] = (
+ etape.fichier_ini,
+ etape.fichier_text,
+ etape.recorded_units,
+ )
+ # print id(self.recorded_units),self.recorded_units
+ # print self.recorded_units.get(None,(None,"",{}))[2]
+ # print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{}))
+
+ def changeFichier(self, fichier):
+ self.finModif()
+
+ def evalInContext(self, valeur, etape):
+ """Tente d'evaluer valeur dans le contexte courant de etape
+ Retourne le parametre valeur inchange si l'evaluation est impossible
+ """
+ # contexte initial du jdc
+ context = self.condition_context.copy()
+ # contexte courant des concepts. Il contient les parametres
+ context.update(self.getContexteAvant(etape))
+ try:
+ objet = eval(valeur, context)
+ return objet
+ except:
+ # traceback.print_exc()
+ pass
+ return valeur
+
+ # ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de processing
+ def supprime(self):
+ Accas.processing.P_JDC.JDC.supprime(self)
+ for etape in self.etapes:
+ etape.supprime()
+ self.appliEficas = None
+ self.g_context = {}
+ self.const_context = {}
+ self.sdsDict = {}
+ self.mc_globaux = {}
+ self.currentContext = {}
+ self.condition_context = {}
+ self.etapes_niveaux = []
+ self.niveau = None
+ self.params = []
+ self.fonctions = []
+ self._etape_context = None
+ self.etapes = []
+
+ # ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de processing
+ def register(self, etape):
+ """
+ Cette methode ajoute etape dans la liste
+ des etapes self.etapes et retourne l identificateur d'etape
+ fourni par l appel a gRegister
+
+ A quoi sert editmode ?
+ - Si editmode vaut 1, on est en mode edition de JDC. On cherche
+ a enregistrer une etape que l'on a creee avec eficas (en passant
+ par addEntite) auquel cas on ne veut recuperer que son numero
+ d'enregistrement et c'est addEntite qui l'enregistre dans
+ self.etapes a la bonne place...
+ - Si editmode vaut 0, on est en mode relecture d'un fichier de
+ commandes et on doit enregistrer l'etape a la fin de self.etapes
+ (dans ce cas l'ordre des etapes est bien l'ordre chronologique
+ de leur creation )
+ """
+ # import traceback
+ # traceback.print_stack()
+ if not self.editmode:
+ self.etapes.append(etape)
+ self.index_etapes[etape] = len(self.etapes) - 1
+ else:
+ pass
+ return self.gRegister(etape)
+
+ # ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de processing
+ def nommerSDProd(self, sd, sdnom, restrict="non"):
+ """
+ Nomme la SD apres avoir verifie que le nommage est possible :
+ nom non utilise
+ Si le nom est deja utilise, leve une exception
+ Met le concept cree dans le concept global g_context
+ """
+ # XXX En mode editeur dans EFICAS, le nommage doit etre gere differemment
+ # Le dictionnaire g_context ne represente pas le contexte
+ # effectif avant une etape.
+ # Il faut utiliser getContexteAvant avec indication de l'etape
+ # traitee.
+ # Cette etape est indiquee par l'attribut _etape_context qui a ete
+ # positionne prealablement par un appel a setEtapeContext
+
+ if CONTEXT.debug:
+ print(("JDC.nommerSDProd ", sd, sdnom))
+
+ if self._etape_context:
+ o = self.getContexteAvant(self._etape_context).get(sdnom, None)
+ else:
+ o = self.sdsDict.get(sdnom, None)
+
+ if isinstance(o, ASSD):
+ raise AsException(tr(" Nom de concept deja defini : " + sdnom))
+
+ # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
+ # Ajoute a la creation (appel de regSD).
+ # print (' je pass ici, pour ', sdnom, self.sdsDict)
+ self.sdsDict[sdnom] = sd
+ sd.nom = sdnom
+
+ # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
+ if restrict == "non":
+ self.g_context[sdnom] = sd
+
+ def deleteConceptEntreEtapes(self, index1, index2, sd):
+ if index2 <= index1:
+ return
+ for child in self.etapes[index1:index2]:
+ child.deleteConcept(sd)
+
+ def deleteConceptAfterEtape(self, etape, sd):
+ """
+ Met a jour les etapes du JDC qui sont apres etape en fonction
+ de la disparition du concept sd
+ """
+ index = self.etapes.index(etape) + 1
+ if index == len(self.etapes):
+ return # etape est la derniere etape du jdc ...on ne fait rien !
+ for child in self.etapes[index:]:
+ child.deleteConcept(sd)
+
+ def updateMCPath(self):
+ # Cette methode sert a recaluler les MCPaths qui peuvent avoir changer
+ # si il y a eu des suprressions dans des MCList freres ou oncles des motclefs incertains
+ etapeIncertitude = self.getEtapesByName("ExpressionIncertitude")
+ if etapeIncertitude == []:
+ return
+ mcVP = self.getChild("Input").getChild("VariableProbabiliste")
+ if mcVP == None:
+ return
+ for mc in mcVP:
+ itemMCPath = mc.getChild("MCPath")
+ itemMCPath.setValeur(mc.variableDeterministe.getMCPath())
+
+ # ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de processing et Accas.validation : a reintegrer
+
+ def getFile(self, unite=None, fic_origine=""):
+ """
+ Retourne le nom du fichier correspondant a un numero d'unite
+ logique (entier) ainsi que le source contenu dans le fichier
+ """
+ if self.appliEficas is not None:
+ # Si le JDC est relie a une appliEficascation maitre, on delegue la recherche
+ file, text = self.appliEficas.getFile(unite, fic_origine)
+ else:
+ file = None
+ if unite != None:
+ if os.path.exists("fort." + str(unite)):
+ file = "fort." + str(unite)
+ if file == None:
+ raise AsException(
+ tr(
+ "Impossible de trouver le fichier correspondant a l'unite "
+ + str(unite)
+ )
+ )
+ if not os.path.exists(file):
+ raise AsException(str(unite) + tr(" n'est pas un fichier existant"))
+ fproc = open(file, "r")
+ text = fproc.read()
+ fproc.close()
+ # if file == None : return None,None
+ text = text.replace("\r\n", "\n")
+ if file:
+ linecache.cache[file] = 0, 0, text.split("\n"), file
+ return file, text
+
+ def isValid(self, cr="non"):
+ if hasattr(self, "valid"):
+ old_valid = self.valid
+ else:
+ old_valid = 0
+ valid = V_JDC.JDC.isValid(self, cr)
+ if valid != old_valid:
+ CONNECTOR.Emit(self, "valid")
+ return valid
+
+ def getLNomsEtapes(self):
+ """
+ Retourne la liste des noms des etapes de self
+ """
+ l = []
+ for etape in self.etapes:
+ l.append(etape.nom)
+ return l
+
+ def getValuesOfAllMC(self,McPath):
+ from Accas.A_MCLIST import MCList
+ debug=0
+ l=set()
+ listeObj=[]
+ for etape in self.etapes :
+ if etape.nom == McPath[0] : listeObj.append(etape)
+ if debug : print (listeObj)
+ if debug : print (len(listeObj))
+ for nom in McPath [1:] :
+ if debug : print ('traitement de ', nom)
+ newList=[]
+ for obj in listeObj:
+ newObj=obj.getChildOrChildInBloc(nom)
+ if debug : print (newObj)
+ if newObj :
+ if isinstance(newObj,MCList):
+ for o in newObj : newList.append(o)
+ else :
+ newList.append(newObj)
+ if debug : print (newList)
+ listeObj=newList
+ for obj in listeObj :
+ if debug : print (obj)
+ l.add(obj.valeur)
+ if debug : print (l)
+ return l
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_JDC_CATA
+
+
+class JDC_CATA:
+ def __init__(self):
+ self.l_noms_entites = []
+
+ def getListeCmd(self):
+ self.l_noms_entites.sort()
+ return self.l_noms_entites
+
+ def getDocu(self):
+ return
+
+ # ATTENTION SURCHARGE: cette methode doit etre synchronisee avec celle de processing
+ def enregistre(self, commande):
+ """
+ Cette methode surcharge la methode de la classe de processing
+ """
+ P_JDC_CATA.JDC_CATA.enregistre(self, commande)
+ self.l_noms_entites.append(commande.nom)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+
+class LASSD:
+ def __repr__(self):
+ return self.getName()
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+# Modules Python
+import sys
+import os.path as osp
+import traceback, types
+
+# Modules Eficas
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+from Accas.accessor import A_ETAPE
+from Accas.accessor import A_ENTITE
+from Accas.accessor import A_OBJECT
+from Accas.processing.P_ASSD import ASSD
+from Accas.processing import P__F
+from Accas.processing import P_MACRO_ETAPE
+from Accas.processing import P_Exception
+from Accas.processing.P_Exception import AsException
+from Accas.extensions import param2
+
+# fin import a resorber
+
+
+class MACRO_ETAPE(A_ETAPE.ETAPE):
+ def __init__(self):
+ self.typret = None
+ # indique si le jeu de commande inclus a pu etre analyse par convert
+ # pour etre editable (0=NON, 1=OUI)
+ self.text_converted = 1
+ self.text_error = ""
+ self.recorded_units = {}
+
+ def getSdprods(self, nom_sd):
+ """
+ Fonction : retourne le concept produit par l etape de nom nom_sd
+ s il existe sinon None
+ """
+ if self.sd and self.sd.nom == nom_sd:
+ return self.sd
+ for co in self.sdprods:
+ if co.nom == nom_sd:
+ return co
+ if type(self.definition.op_init) == types.FunctionType:
+ d = {}
+ self.definition.op_init(*(self, d))
+ return d.get(nom_sd, None)
+ return None
+
+ def getContexteJdc(self, fichier, text, doitEtreValide=1):
+ """
+ Interprete text comme un texte de jdc et retourne le contexte final.
+
+ Le contexte final est le dictionnaire des sd disponibles a la derniere etape.
+ Si text n'est pas un texte de jdc valide, retourne None
+ ou leve une exception
+ --> utilisee par ops.POURSUITE et INCLUDE
+ """
+ # print ("getContexteJdc",self,self.nom, text)
+ # On recupere l'etape courante
+ step = CONTEXT.getCurrentStep()
+ self.text_included_converted = 0
+ try:
+ # if 1 :
+ # on essaie de creer un objet JDC auxiliaire avec un contexte initial
+ # Attention getContexteAvant retourne un dictionnaire qui contient
+ # le contexte courant. Ce dictionnaire est reactualise regulierement.
+ # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
+ context_ini = self.parent.getContexteAvant(self).copy()
+
+ # Indispensable avant de creer un nouveau JDC
+ CONTEXT.unsetCurrentStep()
+ args = self.jdc.args
+ prefix_include = None
+ if hasattr(self, "prefix"):
+ prefix_include = self.prefix
+ # ATTENTION : le dictionnaire recorded_units sert a memoriser les unites des
+ # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
+ # tout le traitement et de ne pas le reinitialiser brutalement (utiliser
+ # clear plutot) si on ne veut pas perdre la memoire des unites.
+ # En principe si la memorisation est faite au bon moment il n'est pas necessaire
+ # de prendre cette precaution mais ce n'est pas vrai partout.
+ old_recorded_units = self.recorded_units.copy()
+
+ # on supprime l'ancien jdc_aux s'il existe
+ if hasattr(self, "jdc_aux") and self.jdc_aux:
+ self.jdc_aux.supprime_aux()
+
+ if fichier is None:
+ fichier = "SansNom"
+
+ # Il faut convertir le texte inclus en fonction du format
+ self.text_converted = 0
+ self.text_error = ""
+ format = self.jdc.appliEficas.format_fichier
+ import Accas.IO.convert as convert
+ if format in convert.plugins:
+ # Le convertisseur existe on l'utilise
+ p = convert.plugins[format]()
+ p.text = text
+ text = p.convert("exec", self.jdc.appliEficas)
+ # Si le fichier ne peut pas etre converti, le cr n'est pas vide
+ # et le texte est retourne tel que
+ if not p.cr.estvide():
+ self.text_converted = 0
+ self.text_error = str(p.cr)
+ else:
+ self.text_converted = 1
+
+ if hasattr(self, "sd") and self.sd != None:
+ context_ini[self.sd.nom] = self.sd
+ j = self.JdC_aux(
+ procedure=text,
+ nom=fichier,
+ appliEficas=self.jdc.appliEficas,
+ cata=self.jdc.cata,
+ cata_ord_dico=self.jdc.cata_ordonne_dico,
+ context_ini=context_ini,
+ jdc_pere=self.jdc,
+ etape_include=self,
+ prefix_include=prefix_include,
+ recorded_units=self.recorded_units,
+ old_recorded_units=old_recorded_units,
+ **args
+ )
+
+ j.analyse()
+ if not j.cr.estvide():
+ self.text_included_converted = 0
+ else:
+ self.text_included_converted = 1
+ self.text_included_error = str(j.cr)
+ # On recupere les etapes internes (pour Accas.validation)
+ self.etapes = j.etapes
+ self.jdc_aux = j
+ self.jdc.jdcDict = self.jdc_aux
+
+ except:
+ # else :
+ traceback.print_exc()
+ # On retablit l'etape courante step
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(step)
+ return None
+
+ if not j.cr.estvide() and doitEtreValide:
+ # Erreurs dans l'INCLUDE. On garde la memoire du fichier
+ # mais on n'insere pas les concepts
+ # On retablit l'etape courante step
+ # print (j.cr)
+ # print ("valid ",j.isValid())
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(step)
+ raise EficasException(
+ tr("Impossible de relire le fichier %s \n ") + str(j.cr)
+ )
+
+ if not j.isValid() and doitEtreValide:
+ # L'INCLUDE n'est pas valide.
+ # on produit un rapport d'erreurs
+ cr = j.report()
+ # print ('cr', cr)
+ # On retablit l'etape courante step
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(step)
+ self.jdc.cr.fatal("Le fichier include contient des erreurs ")
+ raise EficasException(tr("Le fichier include contient des erreurs "))
+
+ # Si aucune erreur rencontree
+ # ou qu on accepte un jdc incomplet
+ # On recupere le contexte de l'include verifie
+ try:
+ j_context = j.getVerifContexte()
+ # print j_context.keys()
+ # print j.g_context.keys()
+ except:
+ # On retablit l'etape courante step
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(step)
+ raise EficasException(" ")
+
+ # Si on est arrive ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...)
+ # est valide et inserable dans le JDC
+
+ # On remplit le dictionnaire des concepts produits inclus
+ # en retirant les concepts presents dans le contexte initial
+ # On ajoute egalement le concept produit dans le sdsDict du parent
+ # sans verification car on est sur (verification integree) que
+ # le nommage est possible
+ self.g_context.clear()
+ for k, v in j_context.items():
+ if (not k in context_ini) or (context_ini[k] != v):
+ self.g_context[k] = v
+ self.parent.sdsDict[k] = v
+
+ # Ce traitement n'est realise que dans les cas suivants:
+ # - si convert n'a pas pu convertir le jeu de commandes
+ # - et ce n'est pas un INCLUDE_MATERIAU
+ # On collecte les variables Python qui ne sont pas dans le contexte initial
+ # et dans le contexte valide et on en fait un pseudo-parametre (Variable)
+ if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU":
+ for k, v in j.g_context.items():
+ if k in context_ini:
+ continue
+ if k in j_context:
+ continue
+ if isinstance(v, ASSD):
+ continue
+ if isinstance(v, A_ENTITE.ENTITE):
+ continue
+ if isinstance(v, A_OBJECT.OBJECT):
+ continue
+ if callable(v):
+ continue
+ self.g_context[k] = param2.Variable(k, v)
+
+ # On recupere le contexte courant
+ self.currentContext = j.currentContext
+ self.index_etape_courante = j.index_etape_courante
+ self.jdc_aux = j
+
+ # On retablit l'etape courante step
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(step)
+
+ return j_context
+
+ def reevalueSdJdc(self):
+ """
+ Avec la liste des SD qui ont ete supprimees, propage la
+ disparition de ces SD dans toutes les etapes et descendants
+ """
+ # print "reevalueSdJdc"
+ l_sd_supp, l_sd_repl = self.diffContextes()
+ for sd in l_sd_supp:
+ self.parent.deleteConceptAfterEtape(self, sd)
+ for old_sd, sd in l_sd_repl:
+ self.parent.replaceConceptAfterEtape(self, old_sd, sd)
+
+ def diffContextes(self):
+ """
+ Realise la difference entre les 2 contextes
+ old_contexte_fichier_init et contexte_fichier_init
+ cad retourne la liste des sd qui ont disparu ou ne derivent pas
+ de la meme classe et des sd qui ont ete remplacees
+ """
+ if not hasattr(self, "old_contexte_fichier_init"):
+ return [], []
+ l_sd_suppressed = []
+ l_sd_replaced = []
+ for old_key in self.old_contexte_fichier_init:
+ if not old_key in self.contexte_fichier_init:
+ if isinstance(self.old_contexte_fichier_init[old_key], ASSD):
+ l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
+ else:
+ if isinstance(self.old_contexte_fichier_init[old_key], ASSD):
+ # Un concept de meme nom existe
+ old_class = self.old_contexte_fichier_init[old_key].__class__
+ if not isinstance(self.contexte_fichier_init[old_key], old_class):
+ # S'il n'est pas d'une classe derivee, on le supprime
+ l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
+ else:
+ l_sd_replaced.append(
+ (
+ self.old_contexte_fichier_init[old_key],
+ self.contexte_fichier_init[old_key],
+ )
+ )
+ return l_sd_suppressed, l_sd_replaced
+
+ def controlSdprods(self, d):
+ """
+ Cette methode doit verifier que les concepts produits par la
+ commande ne sont pas incompatibles avec le contexte fourni (d).
+ Si c'est le cas, le concept produit doit etre supprime
+ Si la macro a elle meme des etapes, elle doit propager
+ le traitement (voir methode controlJdcContextApres de A_JDC)
+ """
+ # print ("A_MACRO_ETAPE.controlSdprods",d.keys(),self,self.nom,self.sd and self.sd.nom)
+ if self.sd:
+ if self.sd.nom in d:
+ # Le concept est deja defini
+ if self.reuse and self.reuse is d[self.sd.nom]:
+ # Le concept est reutilise : situation normale
+ pass
+ else:
+ # Redefinition du concept, on l'annule
+ # XXX on pourrait simplement annuler son nom pour conserver les objets
+ # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
+ self.initModif()
+ sd = self.sd
+ self.sd = self.reuse = self.sdnom = None
+ self.parent.deleteConceptAfterEtape(self, sd)
+ self.finModif()
+
+ # On verifie les concepts a droite du signe =
+ self.initModif()
+ sdprods = self.sdprods[:]
+ self.sdprods = []
+ for co in sdprods:
+ if co.nom in d and co is not d[co.nom]:
+ # nettoie les mots cles de l'etape qui ont comme valeur co
+ self.deleteConcept(co)
+ # supprime les references a co dans les etapes suivantes
+ self.parent.deleteConceptAfterEtape(self, co)
+ else:
+ self.sdprods.append(co)
+ self.finModif()
+
+ for e in self.etapes:
+ e.controlSdprods(d)
+ e.updateContext(d)
+
+ def supprimeSdprod(self, sd):
+ """
+ Supprime le concept produit sd s'il est produit par l'etape
+ """
+ # print ('supprimeSdprod de MACRO_ETAPE')
+ if sd in self.sdprods:
+ self.initModif()
+ self.parent.delSdprod(sd)
+ self.sdprods.remove(sd)
+ self.finModif()
+ self.parent.deleteConcept(sd)
+ return
+
+ if sd is not self.sd:
+ return
+ if self.sd is not None:
+ self.initModif()
+ self.parent.delSdprod(sd)
+ self.sd = None
+ self.finModif()
+ self.parent.deleteConcept(sd)
+
+ def supprimeSdProds(self):
+ """
+ Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
+ Un operateur n a qu un concept produit
+ Une procedure n'en a aucun
+ Une macro en a en general plus d'un
+ """
+ # print "supprimeSdProds"
+ if self.reuse is not self.sd:
+ # l'etape n'est pas reentrante
+ # le concept retourne par l'etape est a supprimer car il etait
+ # cree par l'etape
+ if self.sd != None:
+ self.parent.delSdprod(self.sd)
+ self.parent.deleteConcept(self.sd)
+ # On detruit les concepts a droite du signe =
+ for co in self.sdprods:
+ self.parent.delSdprod(co)
+ self.parent.deleteConcept(co)
+ # Si la macro a des etapes et des concepts inclus, on les detruit
+ for nom_sd, co in self.g_context.items():
+ if not isinstance(co, ASSD):
+ continue
+ self.parent.delSdprod(co)
+ self.parent.deleteConcept(co)
+ # On met g_context a blanc
+ self.g_context = {}
+
+ def close(self):
+ # print "close",self
+ if hasattr(self, "jdc_aux") and self.jdc_aux:
+ # La macro a un jdc auxiliaire inclus. On demande sa fermeture
+ self.jdc_aux.close()
+
+ def resetContext(self):
+ if hasattr(self, "jdc_aux") and self.jdc_aux:
+ # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
+ self.jdc_aux.resetContext()
+
+ def updateConcept(self, sd):
+ A_ETAPE.ETAPE.updateConcept(self, sd)
+ for etape in self.etapes:
+ etape.updateConcept(sd)
+
+ def deleteConcept(self, sd):
+ """
+ Fonction : Mettre a jour les mots cles de l etape et eventuellement
+ le concept produit si reuse suite a la disparition du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
+ """
+ # print "deleteConcept",sd
+ A_ETAPE.ETAPE.deleteConcept(self, sd)
+ for etape in self.etapes:
+ etape.deleteConcept(sd)
+
+ def replaceConcept(self, old_sd, sd):
+ """
+ Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
+ suite au remplacement du concept old_sd par sd
+ """
+ # print "replaceConcept",old_sd,sd
+ A_ETAPE.ETAPE.replaceConcept(self, old_sd, sd)
+ for etape in self.etapes:
+ etape.replaceConcept(old_sd, sd)
+
+ def changeFichierInit(self, new_fic, text):
+ """
+ Tente de changer le fichier include. Le precedent include est conserve
+ dans old_xxx
+ """
+ if not hasattr(self, "fichier_ini"):
+ self.fichier_ini = None
+ self.fichier_text = None
+ self.fichier_err = "Le fichier n'est pas defini"
+ self.contexte_fichier_init = {}
+ self.recorded_units = {}
+ self.jdc_aux = None
+ self.fichier_unite = "PasDefini"
+ import Accas.extensions.jdc_include
+
+ self.JdC_aux = extensions.jdc_include.JdC_include
+
+ self.old_fic = self.fichier_ini
+ self.old_text = self.fichier_text
+ self.old_err = self.fichier_err
+ self.old_context = self.contexte_fichier_init
+ self.old_units = self.recorded_units
+ self.old_etapes = self.etapes
+ self.old_jdc_aux = self.jdc_aux
+
+ self.fichier_ini = new_fic
+ self.fichier_text = text
+
+ try:
+ self.makeContexteInclude(new_fic, text)
+ except:
+ l = traceback.format_exception_only(
+ tr("Fichier invalide %s", sys.exc_info()[1])
+ )
+ self.fichier_err = "".join(l)
+ raise EficasException(self.fichier_err)
+
+ # L'evaluation de text dans un JDC auxiliaire s'est bien passe
+ # on peut poursuivre le traitement
+ self.initModif()
+ self.state = "undetermined"
+ self.fichier_err = None
+ # On enregistre la modification de fichier
+ self.recordUnite()
+ # Le contexte du parent doit etre reinitialise car les concepts produits ont change
+ self.parent.resetContext()
+
+ # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
+ self.old_contexte_fichier_init = self.old_context
+ self.reevalueSdJdc()
+
+ self.finModif()
+ if self.old_jdc_aux:
+ self.old_jdc_aux.close()
+
+ def restoreFichierInit(self):
+ """
+ Restaure le fichier init enregistre dans old_xxx
+ """
+ self.fichier_ini = self.old_fic
+ self.fichier_text = self.old_text
+ self.fichier_err = self.old_err
+ self.contexte_fichier_init = self.old_context
+ self.recorded_units = self.old_units
+ self.etapes = self.old_etapes
+ self.jdc_aux = self.old_jdc_aux
+
+ def forceFichierInit(self):
+ """
+ Force le remplacement du fichier init meme si le remplacant est en erreur
+ """
+ # Reinitialisation complete du compte-rendu d'erreurs
+ self.jdc_aux.cr = self.jdc_aux.CR()
+ # On remplit le dictionnaire des concepts produits inclus
+ # en retirant les concepts presents dans le contexte initial
+ # On ajoute egalement le concept produit dans le sdsDict du parent
+ # sans verification car on est sur (verification integree) que
+ # le nommage est possible
+ j_context = self.jdc_aux.getContexteAvant(None)
+ self.g_context.clear()
+ context_ini = self.jdc_aux.context_ini
+ for k, v in j_context.items():
+ if not k in context_ini or context_ini[k] != v:
+ self.g_context[k] = v
+ self.parent.sdsDict[k] = v
+ # On recupere le contexte courant
+ self.currentContext = self.jdc_aux.currentContext
+ self.index_etape_courante = self.jdc_aux.index_etape_courante
+ self.contexte_fichier_init = j_context
+ self.fichier_err = None
+
+ # On enregistre la modification de fichier
+ self.initModif()
+ self.state = "undetermined"
+ self.recordUnite()
+ # Le contexte du parent doit etre reinitialise car les concepts produits ont change
+ self.parent.resetContext()
+
+ # On remplace les anciens concepts par les nouveaux (y compris ajouts
+ # et suppression) et on propage les modifications aux etapes precedentes et suivantes
+ # reevalueSdJdc construit la liste des differences entre les contextes contexte_fichier_init
+ # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
+ # necessaires
+ self.old_contexte_fichier_init = self.old_context
+ self.reevalueSdJdc()
+ self.finModif()
+ if self.old_jdc_aux:
+ self.old_jdc_aux.close()
+
+ self.jdc_aux.forceContexte(self.g_context)
+
+ def buildInclude(self, fichier, text):
+ import Accas.extensions.jdc_include
+
+ self.JdC_aux = extensions.jdc_include.JdC_include
+ # un include partage la table des unites avec son parent (jdc)
+ self.recorded_units = self.parent.recorded_units
+ self.buildJdcaux(fichier, text)
+
+ def buildPoursuite(self, fichier, text):
+ import Accas.extensions.jdc_include
+
+ self.JdC_aux = extensions.jdc_include.JdC_poursuite
+ # une poursuite a sa propre table d'unites
+ self.recorded_units = {}
+ self.buildJdcaux(fichier, text)
+
+ def buildIncludeInclude(self, text):
+ import Accas.extensions.jdc_include
+
+ self.JdC_aux = extensions.jdc_include.JdC_include
+ # un include partage la table des unites avec son parent (jdc)
+
+ def buildIncludeEtape(self, text, doitEtreValide=0):
+ import Accas.extensions.jdc_include
+
+ self.JdC_aux = extensions.jdc_include.JdC_include
+ # un include partage la table des unites avec son parent (jdc)
+ # self.buildJdcauxInclude(text)
+ # Attention fonctionne pour import_Zone de MT
+ # a adapter eventuellement
+ try:
+ # if 1 :
+ contexte = self.getContexteJdc(None, text, doitEtreValide)
+ except EficasException:
+ return 0
+
+ for e in self.etapes:
+ e.niveau = self.niveau
+ e.parent = self.parent
+ e.state = "change"
+
+ index = self.jdc.etapes.index(self)
+ self.jdc.etapes = (
+ self.jdc.etapes[: index + 1] + self.etapes + self.jdc.etapes[index + 1 :]
+ )
+
+ self.g_context = {}
+ self.etapes = []
+ self.jdc.resetContext()
+ self.jdc_aux = None
+ CONTEXT.unsetCurrentStep()
+ return 1
+
+ def buildJdcauxInclude(self, text):
+ try:
+ contexte = self.getContexteJdc(None, text)
+ except EficasException:
+ pass
+ index = self.jdc.etapes.index(self)
+ for e in self.etapes:
+ e.niveau = self.niveau
+ self.jdc.etapes = (
+ self.jdc.etapes[: index + 1] + self.etapes + self.jdc.etapes[index + 1 :]
+ )
+ self.g_context = {}
+ self.etapes = []
+ self.jdc_aux = None
+ CONTEXT.unsetCurrentStep()
+
+ def buildJdcaux(self, fichier, text):
+ """
+ Cree un jdc auxiliaire initialise avec text.
+ Initialise le nom du fichier associe avec fichier
+ N'enregistre pas d'association unite <-> fichier
+ """
+ self.fichier_ini = fichier
+ self.fichier_text = text
+ self.fichier_unite = None
+ self.fichier_err = None
+ try:
+ contexte = self.getContexteJdc(fichier, text)
+ if contexte is None:
+ # Impossible de construire le jdc auxiliaire (sortie par None)
+ # On simule une sortie par exception
+ raise EficasException(
+ tr(
+ "Impossible de construire le jeu de commandes correspondant au fichier"
+ )
+ )
+ else:
+ # La construction du jdc auxiliaire est allee au bout
+ self.contexte_fichier_init = contexte
+ self.initModif()
+ self.finModif()
+ except:
+ # Impossible de construire le jdc auxiliaire (sortie par exception)
+ l = traceback.format_exception_only("Fichier invalide", sys.exc_info()[1])
+ if self.jdc.editor is not None:
+ self.jdc.editor.afficheAlerte(
+ tr("Erreur lors de l'evaluation du fichier inclus"),
+ message=tr(
+ "Ce fichier ne sera pas pris en compte\n %s", "".join(l)
+ ),
+ )
+
+ self.g_context = {}
+ self.etapes = []
+ self.jdc_aux = None
+ self.fichier_err = "".join(l)
+ self.contexte_fichier_init = {}
+ self.initModif()
+ self.finModif()
+ raise EficasException(" ")
+
+ def makeContexteInclude(self, fichier, text):
+ """
+ Cette methode sert a craer un contexte en interpratant un texte source Python.
+ """
+ # print ("makeContexteInclude",fichier)
+ # on recupere le contexte d'un nouveau jdc dans lequel on interprete text
+ contexte = self.getContexteJdc(fichier, text)
+ # print (contexte)
+ if contexte == None:
+ raise EficasException(
+ "Impossible de construire le jeu de commandes correspondant au fichier"
+ )
+ else:
+ # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
+ # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
+ # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
+ # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
+ # existants en debut de macro contenus dans context_ini (dans getContexteJdc)
+ # g_context est utilise pour avoir les concepts produits par la macro
+ # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
+ self.contexte_fichier_init = contexte
+ # print ("fin makeContexteInclude",fichier)
+
+ def reevalueFichierInitObsolete(self):
+ """Recalcule les concepts produits par le fichier enregistre"""
+ # print "reevalue_fichier_init"
+ old_context = self.contexte_fichier_init
+ try:
+ self.makeContexteInclude(self.fichier_ini, self.fichier_text)
+ except:
+ l = traceback.format_exception_only("Fichier invalide", sys.exc_info()[1])
+ self.fichier_err = "".join(l)
+ self.g_context = {}
+ self.etapes = []
+ self.jdc_aux = None
+ self.old_contexte_fichier_init = old_context
+ self.contexte_fichier_init = {}
+ self.reevalueSdJdc()
+ return
+
+ # L'evaluation s'est bien passee
+ self.fichier_err = None
+ self.old_contexte_fichier_init = old_context
+ self.reevalueSdJdc()
+
+ def updateFichierInit(self, unite):
+ """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
+ les noms des fichiers
+ Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement
+ L'include a ete initialise precedemment. Le jdc auxiliaire existe.
+ """
+ # print "updateFichierInit",unite,self.fichier_unite
+ self.old_contexte_fichier_init = self.contexte_fichier_init
+ old_fichier_ini = self.fichier_ini
+ if not hasattr(self, "jdc_aux"):
+ self.jdc_aux = None
+ old_jdc_aux = self.jdc_aux
+
+ # print "updateFichierInit",self,self.parent,self.parent.recorded_units
+
+ if self.fichier_unite is None:
+ # L'unite n'etait pas definie precedemment. On ne change que l'unite
+ # print "updateFichierInit","pas de changement dans include"
+ self.fichier_unite = unite
+ return
+ elif unite == self.fichier_unite:
+ # L'unite n'a pas change
+ # print "updateFichierInit","pas de changement dans include 3"
+ return
+ elif unite != self.fichier_unite:
+ # L'unite etait definie precedemment. On remplace l'include
+ #
+ f, text = self.getFileMemo(unite=unite, fic_origine=self.parent.nom)
+ if f is None:
+ # Le fichier associe n'a pas pu etre defini
+ # on change l'unite associee mais pas l'include
+ # print "updateFichierInit","pas de changement dans include 2"
+ self.fichier_unite = unite
+ return
+ else:
+ self.fichier_ini = f
+ self.fichier_text = text
+ self.fichier_unite = unite
+ # print "updateFichierInit",self.recorded_units
+
+ # print "updateFichierInit",self.fichier_ini,self.fichier_text,self.fichier_unite
+
+ if old_fichier_ini == self.fichier_ini:
+ # Le fichier inclus n'a pas change. On ne recree pas le contexte
+ # mais on enregistre le changement d'association unite <-> fichier
+ # print "updateFichierInit.fichier inchange",self.jdc_aux.context_ini
+ self.parent.recordUnit(unite, self)
+ return
+
+ try:
+ self.fichier_err = None
+ self.makeContexteInclude(self.fichier_ini, self.fichier_text)
+ # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
+ # avant d'appeler changeUnit
+ except:
+ # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
+ l = traceback.format_exception_only("Fichier invalide", sys.exc_info()[1])
+ # On conserve la memoire du nouveau fichier
+ # mais on n'utilise pas les concepts crees par ce fichier
+ # on met l'etape en erreur : fichier_err=''.join(l)
+ self.fichier_err = "".join(l)
+ self.g_context = {}
+ self.etapes = []
+ self.jdc_aux = None
+ self.contexte_fichier_init = {}
+
+ if old_jdc_aux:
+ old_jdc_aux.close()
+ self.parent.recordUnit(unite, self)
+ # Le contexte du parent doit etre reinitialise car les concepts
+ # produits ont change
+ self.parent.resetContext()
+ # Si des concepts ont disparu lors du changement de fichier, on
+ # demande leur suppression
+ self.reevalueSdJdc()
+ # print "updateFichierInit",self.jdc_aux.context_ini.keys()
+
+ def recordUnite(self):
+ # print "recordUnite",self.nom
+ if self.nom == "POURSUITE":
+ self.parent.recordUnit(None, self)
+ else:
+ if hasattr(self, "fichier_unite"):
+ self.parent.recordUnit(self.fichier_unite, self)
+
+ def getFileMemo(self, unite=None, fname=None, fic_origine=""):
+ """Retourne le nom du fichier et le source correspondant a l'unite unite
+ Initialise en plus recorded_units
+ """
+ # print "getFileMemo",unite,fic_origine,self,self.parent
+ # print self.parent.recorded_units
+ if unite is None:
+ # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
+ units = {}
+ else:
+ # On est dans le cas d'un include. On reutilise toutes les unites de parent
+ units = self.parent.recorded_units
+
+ if unite in self.parent.recorded_units:
+ f, text, units = self.parent.recorded_units[unite]
+ elif self.jdc:
+ if fname:
+ if not osp.exists(fname):
+ raise AsException(fname + tr(" n'est pas un fichier existant"))
+ f = fname
+ text = open(fname, "r").read()
+ else:
+ f, text = self.jdc.getFile(unite=unite, fic_origine=fic_origine)
+ else:
+ f, text = None, None
+
+ self.recorded_units = units
+ if f is None and self.jdc.editor:
+ self.jdc.editor.afficheAlerte(
+ tr("Erreur lors de l'evaluation du fichier inclus"),
+ message=tr(
+ "Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"
+ ),
+ )
+ return f, text
+
+ def updateContext(self, d):
+ """
+ Met a jour le contexte contenu dans le dictionnaire d
+ Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
+ Une fonction enregistree dans op_init peut egalement modifier le contexte
+ """
+ # print ("updateContext",self,self.nom,d.keys())
+ if hasattr(self, "jdc_aux") and self.jdc_aux:
+ # ATTENTION: updateContext NE DOIT PAS appeler resetContext
+ # car il appelle directement ou indirectement updateContext
+ # equivalent a resetContext. Evite les recursions
+ self.jdc_aux.context_ini = d.copy()
+ self.jdc_aux.currentContext = {}
+ self.jdc_aux.index_etape_courante = 0
+ # ATTENTION: il ne faut pas utiliser self.jdc_aux.getContexteAvant
+ # car cet appel conduit a des remontees multiples incoherentes dans le
+ # ou les parents.
+ # get_context_avant appelle updateContext qui NE DOIT PAS appeler getContexteAvant
+ # On n'a besoin que d'un update local connaissant
+ # le contexte amont : d qui sert a reinitialiser self.context_ini
+ for e in self.etapes:
+ e.updateContext(d)
+ return
+
+ if type(self.definition.op_init) == types.FunctionType:
+ self.definition.op_init(*(self, d))
+ if self.sd != None:
+ d[self.sd.nom] = self.sd
+ for co in self.sdprods:
+ d[co.nom] = co
+ # print "updateContext.fin",d.keys()
+
+ # ATTENTION SURCHARGE : cette methode surcharge celle de processing (a garder en synchro)
+ def copy(self):
+ etape = Accas.processing.P_MACRO_ETAPE.MACRO_ETAPE.copy(self)
+ if hasattr(etape, "etapes"):
+ etape.etapes = []
+ if hasattr(etape, "jdc_aux"):
+ etape.jdc_aux = None
+ del etape.fichier_ini
+ return etape
+
+ def supprime(self):
+ # print "supprime",self
+ if hasattr(self, "jdc_aux") and self.jdc_aux:
+ self.jdc_aux.supprime_aux()
+ self.jdc_aux = None
+ Accas.processing.P_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
+
+ # ATTENTION SURCHARGE : cette methode surcharge celle de processing (a garder en synchro)
+ def getFile(self, unite=None, fic_origine=""):
+ """Retourne le nom du fichier et le source correspondant a l'unite unite"""
+ if self.jdc:
+ f, text = self.jdc.getFile(unite=unite, fic_origine=fic_origine)
+ else:
+ f, text = None, None
+ return f, text
+
+ def makeInclude3(self, fichier=None):
+ self.makeIncludeCarmel(fichier)
+
+ def makeIncludeCND(self, fichier=None):
+ unite = 999
+ if fichier == None:
+ return
+ if hasattr(self, "fichier_ini"):
+ print((self.fichier_ini))
+ if hasattr(self, "fichier_ini"):
+ return
+ self.fichier_ini = fichier
+ from acquiertGroupes import getGroupes
+
+ erreur, listeGroupes = getGroupes(fichier)
+ if erreur != "":
+ print("a traiter")
+ texteSources = ""
+ texteCond = ""
+ texteNoCond = ""
+ texteVcut = ""
+ for groupe in listeGroupes:
+ if groupe[0:8] == "CURRENT_":
+ texteSources += groupe[8:] + "=SOURCE();\n"
+ if groupe[0:5] == "COND_":
+ texteCond += groupe[5:] + "=CONDUCTEUR();\n"
+ if groupe[0:7] == "NOCOND_":
+ texteNoCond += groupe[7:] + "=NOCOND();\n"
+ # if groupe[0:5]=='VCUT_': texteVcut +=groupe[5:]+"=VCUT();\n"
+ if groupe[0:5] == "VCUT_":
+ texteVcut += "V_" + groupe[5:] + "=VCUT();\n"
+ texte = texteSources + texteCond + texteNoCond + texteVcut
+ # print (texte)
+ self.buildIncludeInclude(texte)
+ if CONTEXT.getCurrentStep() == None:
+ CONTEXT.setCurrentStep(self)
+ reevalue = 0
+
+ def makeIncludeCarmel(self, fichier=None):
+ # Pour Carmel
+ # print "je suis dans makeIncludeCarmel"
+ unite = 999
+ if hasattr(self, "fichier_ini"):
+ return
+ reevalue = 0
+ if hasattr(self, "old_context_fichier_init"):
+ reevalue = 1
+ for concept in self.old_context_fichier_init.values():
+ self.jdc.deleteConcept(concept)
+ if fichier == None:
+ fichier = str(self.jdc.appliEficas.getFile_dictDonnees())
+ if fichier == str(""):
+ self.fichier_ini = "badfile"
+ self.fichier_text = ""
+ self.fichier_err = tr("Le fichier n est pas defini")
+ self.parent.recordUnit(999, self)
+ try:
+ MCFils = self.getChild("FileName")
+ MCFils.setValeur(None)
+ except:
+ pass
+ raise EficasException(self.fichier_err)
+ self.fichier_ini = fichier
+ f = open(self.fichier_ini, "r")
+ self.fichier_text = f.read()
+ f.close()
+
+ self.contexte_fichier_init = {}
+ self.fichier_unite = 999
+ self.fichier_err = None
+
+ try:
+ # if 1 :
+ import Accas.extensions.jdc_include
+
+ self.JdC_aux = extensions.jdc_include.JdC_include
+ except:
+ # else:
+ traceback.print_exc()
+ self.makeIncl2Except()
+ raise EficasException(" ")
+
+ try:
+ # if 1 :
+ self.makeContexteInclude(self.fichier_ini, self.fichier_text)
+ self.old_context_fichier_init = self.contexte_fichier_init
+ self.parent.recordUnit(unite, self)
+ try:
+ MCFils = self.getChild("FileName")
+ # MCFils.setValeur(fichier)
+ # on appelle pas setValeur qui modifie le contexte ce qui fout le bazar
+ # pas de modification de bloc
+ MCFils.valeur = fichier
+ MCFils.val = fichier
+ except:
+ pass
+ except:
+ # else:
+ self.makeIncl2Except()
+ # Cette P*** de ligne suivante ne fonctionne que pour Aster
+ # si quelqu un a une idee merci de m en parler
+ # CONTEXT.setCurrentStep(self)
+
+ def makeInclude2(self, fichier=None):
+ # Pour OT
+ # gestion de l unicite SVP
+ unite = 999
+
+ if hasattr(self, "fichier_ini"):
+ return
+ reevalue = 0
+ if hasattr(self, "old_context_fichier_init"):
+ reevalue = 1
+ for concept in self.old_context_fichier_init.values():
+ self.jdc.deleteConcept(concept)
+
+ if fichier == None:
+ fichier = str(self.jdc.appliEficas.getFileVariable())
+ if fichier == str(""):
+ self.fichier_ini = "badfile"
+ self.fichier_text = ""
+ self.fichier_err = tr("Le fichier n est pas defini")
+ self.parent.recordUnit(999, self)
+ try:
+ MCFils = self.getChild("FileName")
+ MCFils.setValeur(None)
+ except:
+ pass
+ raise EficasException(self.fichier_err)
+
+ self.fichier_ini = fichier
+ self.fichier_text = ""
+ self.contexte_fichier_init = {}
+ self.fichier_unite = 999
+ self.fichier_err = None
+ nbVariableOut = 0
+ try:
+ from openturns import WrapperFile
+
+ monWrapper = WrapperFile(fichier)
+ data = monWrapper.getWrapperData()
+ maVariableListe = data.getVariableList()
+ nbVariables = maVariableListe.getSize()
+ for i in range(nbVariables):
+ nom = maVariableListe[i].id_
+ type = maVariableListe[i].type_
+ if type:
+ # ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
+ ligneTexte = ""
+ nbVariableOut = nbVariableOut + 1
+ else:
+ ligneTexte = "%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (
+ nom,
+ nom,
+ i,
+ )
+ self.fichier_text = self.fichier_text + ligneTexte
+ except:
+ self.makeIncl2Except()
+ raise EficasException(" ")
+
+ if nbVariableOut != 1:
+ self.makeIncl2Except(
+ mess=tr("le fichier doit contenir une unique variable de sortie")
+ )
+ raise EficasException(" ")
+
+ try:
+ import Accas.extensions.jdc_include
+
+ self.JdC_aux = extensions.jdc_include.JdC_include
+ except:
+ traceback.print_exc()
+ self.makeIncl2Except()
+ raise EficasException(" ")
+
+ try:
+ self.makeContexteInclude(self.fichier_ini, self.fichier_text)
+ self.old_context_fichier_init = self.contexte_fichier_init
+ self.parent.recordUnit(unite, self)
+ try:
+ MCFils = self.getChild("FileName")
+ MCFils.setValeur(fichier)
+ except:
+ pass
+ except:
+ self.makeIncl2Except()
+
+ # recalcul validite pour la matrice eventuelle
+ if reevalue:
+ for e in self.jdc.etapes:
+ if e.nom == "VARIABLE":
+ e.state = "modified"
+ try:
+ mc = e.getChild("ModelVariable")
+ mc.state = "modified"
+ except:
+ pass
+ if e.nom == "CORRELATION":
+ e.state = "modified"
+ try:
+ mc = e.getChild("Matrix")
+ mc.state = "modified"
+ mcFeuille = mc.getChild("CorrelationMatrix")
+ mcFeuille.state = "modified"
+ except:
+ pass
+ e.isValid()
+
+ def makeIncl2Except(self, mess=None):
+ l = traceback.format_exception_only(tr("Fichier invalide"), sys.exc_info()[1])
+ if self.jdc.editor is not None:
+ if mess == None:
+ self.jdc.editor.afficheAlerte(
+ tr("Erreur lors de l'evaluation du fichier inclus"),
+ message=tr(
+ "Le contenu de ce fichier ne sera pas pris en compte\n %s",
+ "".join(l),
+ ),
+ )
+
+ else:
+ self.jdc.editor.afficheAlerte(
+ tr("Erreur lors de l'evaluation du fichier inclus"),
+ message=tr(mess),
+ )
+ # self.parent.recordUnit(unite,self)
+ self.g_context = {}
+ self.etapes = []
+ self.jdc_aux = None
+ self.fichier_err = "".join(l)
+ self.contexte_fichier_init = {}
+ try:
+ MCFils = self.getChild("FileName")
+ MCFils.setValeur(None)
+ except:
+ pass
+
+ # ATTENTION SURCHARGE : cette methode surcharge celle de processing (a garder en synchro)
+ # def makeInclude(self, unite=None, fname=None):
+ def makeInclude(self, unite=None, fname=None):
+ """
+ Inclut un fichier dont l'unite logique est unite
+ Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
+ Si l'INCLUDE est invalide, la methode doit produire une exception
+ Sinon on retourne None. Les concepts produits par l'INCLUDE sont
+ pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
+ """
+ # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
+ # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
+ # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
+ # if not unite and not fname:
+ # return
+ # 2020 on supprime unite
+ # attention cependant c est utilise pour poursuite
+ # PNPN a revoir
+ if not fname:
+ return
+
+ if not hasattr(self, "fichier_ini"):
+ # Si le fichier n'est pas defini on le demande
+ f, text = self.getFileMemo(
+ unite=unite, fname=fname, fic_origine=self.parent.nom
+ )
+ # On memorise le fichier retourne
+ self.fichier_ini = f
+ self.fichier_text = text
+ self.contexte_fichier_init = {}
+ self.fichier_unite = unite
+ self.fichier_err = None
+ try:
+ import Accas.extensions.jdc_include
+ except:
+ traceback.print_exc()
+ raise EficasException("pb import Accas.extensions")
+ self.JdC_aux = extensions.jdc_include.JdC_include
+
+ # print "makeInclude",self.fichier_ini,self.fichier_text
+ if f is None and not text:
+ self.fichier_err = tr("Le fichier INCLUDE n est pas defini")
+ self.parent.recordUnit(unite, self)
+ raise EficasException(self.fichier_err)
+
+ try:
+ self.makeContexteInclude(self.fichier_ini, self.fichier_text)
+ self.parent.recordUnit(unite, self)
+ except:
+ l = traceback.format_exception_only(
+ tr("Fichier invalide %s", sys.exc_info()[1])
+ )
+ if self.jdc.editor:
+ self.jdc.editor.afficheAlerte(
+ tr("Erreur lors de l'evaluation du fichier inclus"),
+ message=tr(
+ "Le contenu de ce fichier ne sera pas pris en compte\n"
+ + "".join(l)
+ ),
+ )
+ self.parent.recordUnit(unite, self)
+ self.g_context = {}
+ self.etapes = []
+ self.jdc_aux = None
+ self.fichier_err = "".join(l)
+ self.contexte_fichier_init = {}
+ raise EficasException(" ")
+
+ else:
+ # Si le fichier est deja defini on ne reevalue pas le fichier
+ # et on leve une exception si une erreur a ete enregistree
+ self.updateFichierInit(unite)
+ self.fichier_unite = unite
+ if self.fichier_err is not None:
+ raise EficasException(self.fichier_err)
+ # print ('self.g_context', self.g_context)
+
+ # ATTENTION SURCHARGE : cette methode surcharge celle de processing (a garder en synchro)
+ def makeContexte(self, fichier, text):
+ """
+ Cette methode sert a creer un contexte pour INCLUDE_MATERIAU
+ en interpretant un texte source Python
+ Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
+ """
+ # print "makeContexte",fichier
+ # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
+ # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
+ if hasattr(self, "mat"):
+ del self.mat
+ if (
+ not hasattr(self, "fichier_ini")
+ or self.fichier_ini != fichier
+ or self.fichier_mater != self.nom_mater
+ ):
+ # le fichier est nouveau ou change
+ self.fichier_ini = fichier
+ self.fichier_unite = fichier
+ self.fichier_mater = self.nom_mater
+ self.fichier_text = text
+ self.fichier_err = None
+ self.contexte_fichier_init = {}
+ # On specifie la classe a utiliser pour le JDC auxiliaire
+ try:
+ import Accas.extensions.jdc_include
+
+ self.JdC_aux = extensions.jdc_include.JdC_include
+ except:
+ raise EficasException(" ")
+ try:
+ self.makeContexteInclude(self.fichier_ini, self.fichier_text)
+ if not self.nom_mater in self.g_context:
+ # Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
+ self.g_context[self.nom_mater] = None
+ if self.parent:
+ self.parent.g_context[self.nom_mater] = None
+ except:
+ l = traceback.format_exception_only(
+ tr("Fichier invalide %s", sys.exc_info()[1])
+ )
+ self.fichier_err = "".join(l)
+ self.g_context = {}
+ # Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
+ if self.parent:
+ self.parent.g_context[self.nom_mater] = None
+ self.g_context[self.nom_mater] = None
+ # -------------
+ self.etapes = []
+ self.jdc_aux = None
+ self.contexte_fichier_init = {}
+ raise EficasException(" ")
+ else:
+ # le fichier est le meme on ne le reevalue pas
+ # et on leve une exception si une erreur a ete enregistree
+ if self.fichier_err is not None:
+ raise EficasException(self.fichier_err)
+
+ # ATTENTION SURCHARGE : cette methode surcharge celle de processing (a garder en synchro)
+ def updateSdprod(self, cr="non"):
+ # Cette methode peut etre appelee dans EFICAS avec des mots cles de
+ # la commande modifies. Ceci peut conduire a la construction ou
+ # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
+ # Il faut donc positionner le current_step avant l'appel
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(self)
+ valid = Accas.validation.V_MACRO_ETAPE.MACRO_ETAPE.updateSdprod(self, cr=cr)
+ CONTEXT.unsetCurrentStep()
+ return valid
+
+ # ATTENTION SURCHARGE: cette methode surcharge celle de processing a garder en synchro
+ def buildSd(self, nom):
+ """
+ Mmethode de processing surchargee pour poursuivre malgre tout
+ si une erreur se produit pendant la creation du concept produit
+ """
+ try:
+ sd = P_MACRO_ETAPE.MACRO_ETAPE.buildSd(self, nom)
+ except:
+ # return None
+ # except AsException,e:
+ # Une erreur s'est produite lors de la construction du concept
+ # Comme on est dans EFICAS, on essaie de poursuivre quand meme
+ # Si on poursuit, on a le choix entre deux possibilites :
+ # 1. on annule la sd associee a self
+ # 2. on la conserve mais il faut la retourner
+ # On choisit de l'annuler
+ # En plus il faut rendre coherents sdnom et sd.nom
+ self.sd = None
+ self.sdnom = None
+ self.state = "unchanged"
+ self.valid = 0
+
+ return self.sd
+
+ # ATTENTION SURCHARGE: cette methode surcharge celle de processing a garder en synchro
+ def makePoursuite(self):
+ """Cette methode est appelee par la fonction sd_prod de la macro POURSUITE"""
+ # print "makePoursuite"
+ if not hasattr(self, "fichier_ini"):
+ # Si le fichier n'est pas defini on le demande
+ f, text = self.getFileMemo(fic_origine=self.parent.nom)
+ # On memorise le fichier retourne
+ self.fichier_ini = f
+ self.fichier_unite = None
+ self.fichier_text = text
+ self.fichier_err = None
+ try:
+ import Accas.extensions.jdc_include
+ except:
+ traceback.print_exc()
+ raise EficasException(" ")
+ self.JdC_aux = extensions.jdc_include.JdC_poursuite
+ self.contexte_fichier_init = {}
+ # print "makePoursuite",self.fichier_ini,self.fichier_text
+
+ if f is None:
+ self.fichier_err = "Le fichier POURSUITE n'est pas defini"
+ self.jdc_aux = None
+ self.parent.recordUnit(None, self)
+ raise EficasException(self.fichier_err)
+
+ try:
+ self.makeContexteInclude(self.fichier_ini, self.fichier_text)
+ self.parent.recordUnit(None, self)
+ except:
+ l = traceback.format_exception_only(
+ "Fichier invalide", sys.exc_info()[1]
+ )
+ if self.jdc.editor:
+ self.jdc.editor.afficheAlerte(
+ tr("Erreur lors de l'evaluation du fichier poursuite"),
+ message=tr(
+ "Ce fichier ne sera pas pris en compte\n %s", "".join(l)
+ ),
+ )
+ self.parent.recordUnit(None, self)
+ self.g_context = {}
+ self.etapes = []
+ self.jdc_aux = None
+ self.fichier_err = "".join(l)
+ self.contexte_fichier_init = {}
+ raise EficasException(" ")
+
+ else:
+ # Si le fichier est deja defini on ne reevalue pas le fichier
+ # et on leve une exception si une erreur a ete enregistree
+ self.updateFichierInit(None)
+ if self.fichier_err is not None:
+ raise EficasException(self.fichier_err)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.accessor import A_MCCOMPO
+
+
+class MCBLOC(A_MCCOMPO.MCCOMPO):
+ def getNomDsXML(self):
+ return self.parent.getNomDsXML()
+
+ def getDicoForFancy(self):
+ listeNodes = []
+ for obj in self.mcListe:
+ lesNodes = obj.getDicoForFancy()
+ if not (isinstance(lesNodes, list)):
+ listeNodes.append(lesNodes)
+ else:
+ for leNode in lesNodes:
+ listeNodes.append(leNode)
+ return listeNodes
+
+ def getParentsJusqua(self, jusqua):
+ listeDesParents = []
+ aTraiter = self
+ while aTraiter != jusqua.getObject():
+ listeDesParents.append(aTraiter.parent)
+ aTraiter = aTraiter.parent
+ return listeDesParents
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+import string, types, sys
+from copy import copy
+import traceback
+
+from Accas.extensions.eficas_translation import tr
+from Accas.processing.P_MCSIMP import MCSIMP
+from Accas.processing.P_MCFACT import MCFACT
+from Accas.processing.P_MCBLOC import MCBLOC
+from Accas.processing.P_MCLIST import MCList
+from Accas.accessor import A_OBJECT
+from Accas.accessor import CONNECTOR
+from Accas.validation import V_MCCOMPO
+
+
+class MCCOMPO(A_OBJECT.OBJECT):
+ def getLabelText(self):
+ """
+ Retourne le label de self
+ utilise pour l'affichage dans l'arbre
+ """
+ return tr(self.nom)
+
+ def getListeMcOrdonnee(self, liste, dico):
+ """
+ Retourne la liste ordonnee (suivant le catalogue) des mots-cles
+ d'une entite composee dont le chemin complet est donne sous forme
+ d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
+ il faut encore rearranger cette liste (certains mots-cles deja
+ presents ne doivent plus etre proposes, regles ...)
+ """
+ return self.filtreListeMc(self.getListeMcOrdonneeBrute(liste, dico))
+
+ def getListeMcOrdonneeBrute(self, liste, dico):
+ """
+ Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
+ d'une entite composee dont le chemin complet est donne sous forme
+ d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
+ """
+ for arg in liste:
+ objet_cata = dico[arg]
+ dico = objet_cata.entites
+ l = []
+ specifique = 0
+ for obj in list(dico.keys()):
+ if not (hasattr(dico[obj], "cache")) or dico[obj].cache == 0:
+ l.append(obj)
+ else:
+ specifique = 1
+ if specifique == 1:
+ return l
+ return objet_cata.ordreMC
+
+ def filtreListeMc(self, liste_brute, avecCache=True):
+ """
+ Cette methode est appelee par EFICAS afin de presenter a
+ l'utilisateur la liste des enfants possibles de self actualisee
+ en fonction du contexte de self. En clair, sont supprimes de la
+ liste des possibles (fournie par la definition), les mots-cles
+ exclus par les regles de self et les mots-cles ne pouvant plus
+ etre repetes
+ si avecCache=False on n inclut pas les MC dont le statut = cache
+ """
+ liste = copy(liste_brute)
+ listeMcPresents = self.listeMcPresents()
+ # on enleve les mots-cles non permis par les regles
+ for regle in self.definition.regles:
+ # la methode purgeListe est a developper pour chaque regle qui
+ # influe sur la liste de choix a proposer a l'utilisateur
+ # --> EXCLUS,UN_PARMI,PRESENT_ABSENT
+ liste = regle.purgeListe(liste, listeMcPresents)
+ # on enleve les mots-cles dont l'occurrence est deja atteinte
+ liste_copy = copy(liste)
+ for k in liste_copy:
+ objet = self.getChild(k, restreint="oui")
+ if objet != None:
+ # l'objet est deja present : il faut distinguer plusieurs cas
+ if isinstance(objet, MCSIMP):
+ # un mot-cle simple ne peut pas etre repete
+ liste.remove(k)
+ elif isinstance(objet, MCBLOC):
+ # un bloc conditionnel ne doit pas apparaitre dans la liste de choix
+ liste.remove(k)
+ elif isinstance(objet, MCFACT):
+ # un mot-cle facteur ne peut pas etre repete plus de self.max fois
+ if objet.definition.max == 1:
+ liste.remove(k)
+ if not avecCache and objet.definition.statut in ("c", "d", "cache"):
+ liste.remove(k)
+ elif isinstance(objet, MCList):
+ try:
+ nb_occur_maxi = objet[0].definition.max
+ if len(objet) >= nb_occur_maxi:
+ liste.remove(k)
+ if not avecCache and objet[0].definition.statut == "cache":
+ liste.remove(k)
+ except:
+ pass
+ else:
+ # XXX CCAR : les MCNUPLET ne sont pas traites
+ if CONTEXT.debug:
+ print(" ", k, " est un objet de type inconnu :", type(objet))
+ else:
+ # l'objet est absent : on enleve de la liste les blocs
+ if (
+ self.definition.entites[k].statut == "c"
+ or self.definition.entites[k].statut == "cache"
+ ):
+ liste.remove(k)
+ if self.definition.entites[k].label == "BLOC":
+ liste.remove(k)
+ # Pour corriger les exces qui pourraient etre commis dans la methode purgeListe
+ # des regles, on essaie de compenser comme suit :
+ # on ajoute les mots cles facteurs presents dont l'occurence n'est pas atteinte
+ for k in listeMcPresents:
+ if k in liste:
+ continue
+ objet = self.getChild(k, restreint="oui")
+ if isinstance(objet, MCFACT):
+ # un mot-cle facteur ne peut pas etre repete plus de self.max fois
+ if objet.definition.max > 1:
+ liste.append(k)
+ if not avecCache and objet.definition.statut == "cache":
+ liste.remove(k)
+ elif isinstance(objet, MCList):
+ nb_occur_maxi = objet[0].definition.max
+ if len(objet) < nb_occur_maxi:
+ liste.append(k)
+ if not avecCache and objet[0].definition.statut == "cache":
+ liste.remove(k)
+ return liste
+
+ def calculOptionnel(self):
+ self.listeMc = []
+ self.listeMcRegle = []
+ self.dictToolTipMc = {}
+ genea = self.getGenealogie()
+ # Attention : les mots clefs listes (+sieurs fact )
+ # n ont pas toutes ces methodes. a priori pas appele mais
+ if self.nature != "MCLIST":
+ self.listeMc = self.getListeMcOrdonnee(genea, self.jdc.cata_ordonne_dico)
+ listeNomsPresents = self.dictMcPresents()
+ for regle in self.getRegles():
+ (monToolTip, regleOk) = regle.verif(listeNomsPresents)
+ if regleOk:
+ continue
+ for mc in regle.mcs:
+ self.listeMcRegle.append(mc)
+ self.dictToolTipMc[mc] = monToolTip
+ return (self.listeMc, self.listeMcRegle, self.dictToolTipMc)
+
+ def calculOptionnelInclutBlocs(self):
+ debug = 0
+ if debug:
+ print("-------------- calculOptionnelInclutBlocs", self.nom)
+ self.dictMCVenantDesBlocs = {}
+ liste, listeRouge, dictToolTipMc = self.calculOptionnel()
+ dictNomsPresents = self.dictMcPresents()
+ for mc in liste:
+ self.dictMCVenantDesBlocs[mc] = self
+ for mc in self.listeMcPresents():
+ obj = dictNomsPresents[mc]
+ if obj.nature != "MCBLOC":
+ continue
+ if debug:
+ print(mc, "est present")
+ (l, lr, d) = obj.calculOptionnelInclutBlocs()
+ # print ('optionnels', l)
+ liste = liste + l
+ listeRouge = listeRouge + lr
+ for k in d:
+ dicToolTipMC[k] = d[k]
+ for k, v in obj.dictMCVenantDesBlocs.items():
+ self.dictMCVenantDesBlocs[k] = v
+
+ if debug:
+ print("ccOptio", self.nom, self.dictMCVenantDesBlocs)
+ if debug:
+ print("fin calculOPtionnel", self.nom, "_____________")
+ return (liste, listeRouge, dictToolTipMc)
+ def listeMcPresents(self):
+ """
+ Retourne la liste des noms des mots-cles fils de self presents construite
+ a partir de self.mcListe
+ """
+ l = []
+ for v in self.mcListe:
+ k = v.nom
+ l.append(k)
+ return l
+
+ def getIndexChild(self, nom_fils):
+ """
+ Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
+ Permet de savoir a quelle position il faut ajouter un nouveau mot-cle
+ """
+ cata_ordonne = self.jdc.cata_ordonne_dico
+ liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(
+ self.getGenealogie(), cata_ordonne
+ )
+ liste_noms_mc_presents = self.listeMcPresents()
+ index = 0
+ for nom in liste_noms_mc_ordonnee:
+ if nom == nom_fils:
+ break
+ if nom not in liste_noms_mc_presents:
+ continue
+ index = index + 1
+ return index
+
+ def chercheIndiceDsLeContenu(self, objet):
+ # uniquement pour Pyxb
+ # ajoute la taille des les Blocs
+ # faut -il chercher plus loin ds les petits-enfants ?
+ if objet.nature == "MCList":
+ objet = objet[0]
+ leRang = 0
+ positionDsLaListe = 0
+ try:
+ positionDsLaListe = self.mcListe.index(objet)
+ positionDsLaListeDeFactSiFact = 0
+ except:
+ for mc in self.mcListe:
+ if mc.nature == "MCList":
+ try:
+ positionDsLaListeDeFactSiFact = mc.index(objet)
+ break
+ except:
+ positionDsLaListe = positionDsLaListe + 1
+ else:
+ positionDsLaListe = positionDsLaListe + 1
+ i = 0
+ while i < positionDsLaListe:
+ leRang = leRang + self.mcListe[i].longueurDsArbre()
+ i = i + 1
+ leRang = leRang + positionDsLaListeDeFactSiFact
+ return leRang
+
+ def ordonneListeMc(self, listeMc_a_ordonner, liste_noms_mc_ordonnee):
+ """
+ Retourne listeMc_a_ordonner ordonnee suivant l'ordre
+ donne par liste_noms_mc_ordonnee
+ """
+ liste = []
+ # on transforme liste_a_ordonner en un dictionnaire (plus facile a consulter)
+ d_mc = {}
+ for mc in listeMc_a_ordonner:
+ d_mc[mc.nom] = mc
+ # on construit la liste des objets ordonnes
+ for nom_mc in liste_noms_mc_ordonnee:
+ if nom_mc in d_mc:
+ liste.append(d_mc.get(nom_mc))
+ # on la retourne
+ return liste
+
+ def suppEntite(self, objet):
+ """
+ Supprime le fils 'objet' de self :
+ Retourne 1 si la suppression a pu etre effectuee,
+ Retourne 0 dans le cas contraire
+ """
+ # print ('suppEntite de MCCOMPO', self.nom,objet)
+ if not objet in self.mcListe:
+ # Impossible de supprimer objet. Il n'est pas dans mcListe
+ return 0
+
+ if objet.nom == "VariableProbabiliste":
+ if (
+ hasattr(objet[0], "variableDeterministe")
+ and objet[0].variableDeterministe
+ ):
+ objet[0].variableDeterministe.variableProbabiliste = None
+ objet[0].variableDeterministe.associeVariableUQ = False
+ self.initModif()
+ objet.delObjPyxb()
+ objet.deleteRef()
+ self.mcListe.remove(objet)
+ CONNECTOR.Emit(self, "supp", objet)
+ objet.deleteMcGlobal()
+ objet.updateConditionBloc()
+ objet.supprime()
+ while self.etape.doitEtreRecalculee == True:
+ # print (' je suis dans le while')
+ self.etape.doitEtreRecalculee = False
+ self.etape.deepUpdateConditionBlocApresSuppression()
+ self.etape.modified()
+ self.finModif()
+ return 1
+
+ def isOblig(self):
+ return 0
+
+ def addEntite(self, name, pos=None):
+ """
+ Ajoute le mot-cle name a la liste des mots-cles de
+ l'objet MCCOMPOSE
+ """
+ # print ('addEntite', name, pos)
+ self.initModif()
+ if type(name) == bytes or type(name) == str:
+ # on est en mode creation d'un motcle
+ if self.ispermis(name) == 0:
+ return 0
+ objet = self.definition.entites[name](val=None, nom=name, parent=self)
+ else:
+ # dans ce cas on est en mode copie d'un motcle
+ objet = name
+ # Appel de la methode qui fait le menage dans les references
+ # sur les concepts produits (verification que les concepts existent
+ # dans le contexte de la commande courante).
+ objet.verifExistenceSd()
+
+ # On verifie que l'ajout d'objet est autorise
+ if self.ispermis(objet) == 0:
+ self.jdc.editor.afficheAlerte(
+ tr("Erreur"),
+ tr(
+ "L'objet %(v_1)s ne peut etre un fils de %(v_2)s",
+ {"v_1": objet.nom, "v_2": self.nom},
+ ),
+ )
+ self.finModif()
+ return 0
+
+ # On cherche s'il existe deja un mot cle de meme nom
+ old_obj = self.getChild(objet.nom, restreint="oui")
+ if not old_obj:
+ # on normalize l'objet
+ objet = objet.normalize()
+ # Le mot cle n'existe pas encore. On l'ajoute a la position
+ # demandee (pos)
+ if pos == None:
+ self.mcListe.append(objet)
+ else:
+ self.mcListe.insert(pos, objet)
+ # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
+ objet.reparent(self)
+ if self.cata.modeleMetier:
+ if isinstance(objet, MCList):
+ objet[0].addObjPyxb(self.chercheIndiceDsLeContenu(objet))
+ else:
+ objet.addObjPyxb(self.chercheIndiceDsLeContenu(objet))
+ CONNECTOR.Emit(self, "add", objet)
+ objet.updateMcGlobal()
+ objet.updateConditionBloc()
+ self.finModif()
+ return objet
+ else:
+ # Le mot cle existe deja. Si le mot cle est repetable,
+ # on cree une liste d'objets. Dans le cas contraire,
+ # on emet un message d'erreur.
+ if not old_obj.isRepetable():
+ self.jdc.editor.afficheAlerte(
+ tr("Erreur"), tr("L'objet %s ne peut pas etre repete", objet.nom)
+ )
+ self.finModif()
+ return 0
+ else:
+ # une liste d'objets de meme type existe deja
+ old_obj.addEntite(objet)
+ if self.cata.modeleMetier:
+ if isinstance(objet, MCList):
+ objet[0].addObjPyxb(self.chercheIndiceDsLeContenu(objet))
+ else:
+ objet.addObjPyxb(self.chercheIndiceDsLeContenu(objet))
+ self.finModif()
+ return old_obj
+
+ def ispermis(self, fils):
+ """
+ Retourne 1 si l'objet de nom nom_fils
+ est bien permis, cad peut bien etre un fils de self,
+ Retourne 0 sinon
+ """
+ if type(fils) == bytes or type(fils) == str:
+ # on veut juste savoir si self peut avoir un fils de nom 'fils'
+ if fils in self.definition.entites:
+ return 1
+ else:
+ return 0
+ # elif type(fils) == types.InstanceType:
+ elif isinstance(fils, object):
+ # fils est un objet (commande,mcf,mclist)
+ # on est dans le cas d'une tentative de copie de l'objet
+ # on veut savoir si l'objet peut bien etre un fils de self :
+ # la verification du nom de suffit pas (plusieurs commandes
+ # ont le meme mot-cle facteur AFFE ... et c'est l'utilisateur
+ # qui choisit le pere d'ou un risque d'erreur)
+ if not fils.nom in self.definition.entites:
+ return 0
+ else:
+ if fils.parent.nom != self.nom:
+ return 0
+ return 1
+
+ def updateConcept(self, sd):
+ for child in self.mcListe:
+ child.updateConcept(sd)
+
+ def deleteConcept(self, sd):
+ """
+ Inputs :
+ - sd=concept detruit
+ Fonction :
+ Mettre a jour les fils de l objet suite a la disparition du
+ concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre que
+ de transmettre aux fils
+ """
+ for child in self.mcListe:
+ child.deleteConcept(sd)
+
+ def replaceConcept(self, old_sd, sd):
+ """
+ Inputs :
+ - old_sd=concept remplace
+ - sd = nouveau concept
+ Fonction :
+ Mettre a jour les fils de l objet suite au remplacement du
+ concept old_sd
+ """
+ for child in self.mcListe:
+ child.replaceConcept(old_sd, sd)
+
+ def getListeMcInconnus(self):
+ """
+ Retourne la liste des mots-cles inconnus dans self
+ """
+ l_mc = []
+ if self.reste_val != {}:
+ for k, v in self.reste_val.items():
+ l_mc.append([self, k, v])
+ for child in self.mcListe:
+ if child.isValid():
+ continue
+ l_child = child.getListeMcInconnus()
+ for mc in l_child:
+ l = [self]
+ l.extend(mc)
+ l_mc.append(l)
+ return l_mc
+
+ def deepUpdateConditionBlocApresSuppression(self):
+ self._updateConditionBloc()
+ for mcobj in self.mcListe:
+ if mcobj.nature == "MCList":
+ for obj in mcobj:
+ obj.deepUpdateConditionBlocApresSuppression()
+ obj.state = "modified"
+ elif hasattr(mcobj, "deepUpdateConditionBlocApresSuppression"):
+ mcobj.deepUpdateConditionBlocApresSuppression()
+
+ def deepUpdateConditionBlocApresCreation(self):
+ # idem deepUpdateConditionBloc sauf qu on cherche les MC qui
+ # avait ete laisse de cote par la construction
+ # Comme on est en construction, on ne devrait pas avoir a detruire de bloc
+ # si on vient d un xml invalide, il faudra probablement traiter les blocs deja crees
+ # reste_val est au niveau du MCCompo, il faut donc tout parcourir
+ # print ('dans deepUpdateConditionBlocApresCreation pour', self.nom)
+ if self.reste_val != {}:
+ self.buildMcApresGlobalEnCreation()
+ for mcobj in self.mcListe:
+ if mcobj.nature == "MCList":
+ for obj in mcobj:
+ obj.deepUpdateConditionBlocApresCreation()
+ obj.state = "modified"
+ elif hasattr(mcobj, "deepUpdateConditionBlocApresCreation"):
+ mcobj.deepUpdateConditionBlocApresCreation()
+ mcobj.state = "modified"
+ self.state = "modified"
+
+ def deepUpdateConditionBloc(self):
+ """
+ Parcourt l'arborescence des mcobject et realise l'update
+ des blocs conditionnels par appel de la methode updateConditionBloc
+ """
+ self._updateConditionBloc()
+ for mcobj in self.mcListe:
+ if hasattr(mcobj, "deepUpdateConditionBloc"):
+ mcobj.deepUpdateConditionBloc()
+ mcobj.state = "modified"
+ if self.nature == "PROCEDURE":
+ if self.doitEtreRecalculee:
+ self.doitEtreRecalculee = False
+ self.deepUpdateConditionBloc()
+
+ def updateConditionBloc(self):
+ """
+ Realise l'update des blocs conditionnels fils de self
+ et propage au parent
+ """
+ self._updateConditionBloc()
+ if self.parent:
+ self.parent.updateConditionBloc()
+
+ def _updateConditionBloc(self):
+ """
+ Realise l'update des blocs conditionnels fils de self
+ """
+ dict = self.creeDictCondition(self.mcListe, condition=1)
+ doitEtreReecrit = False
+ for k, v in self.definition.entites.items():
+ if v.label != "BLOC":
+ continue
+ globs = self.jdc and self.jdc.condition_context or {}
+ bloc = self.getChild(k, restreint="oui")
+ presence = v.verifPresence(dict, globs)
+ if presence and not bloc:
+ # le bloc doit etre present
+ # mais le bloc n'est pas present et il doit etre cree
+ pos = self.getIndexChild(k)
+ self.addEntite(k, pos)
+ # print ("AJOUT",k,pos)
+ if not presence and bloc:
+ # le bloc devrait etre absent
+ # le bloc est present : il faut l'enlever
+ # print ("SUPPRESSION BLOC",k,bloc)
+ self.suppEntite(bloc)
+ doitEtreReecrit = True
+
+ def verifConditionBloc(self):
+ """
+ 2021 : obsolete ?
+ Evalue les conditions de tous les blocs fils possibles
+ (en fonction du catalogue donc de la definition) de self
+ et retourne deux listes :
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
+ """
+ liste_ajouts = []
+ liste_retraits = []
+ dict = self.creeDictCondition(self.mcListe, condition=1)
+ for k, v in self.definition.entites.items():
+ if v.label == "BLOC":
+ globs = self.jdc and self.jdc.condition_context or {}
+ if v.verifPresence(dict, globs):
+ # le bloc doit etre present
+ if not self.getChild(k, restreint="oui"):
+ # le bloc n'est pas present et il doit etre cree
+ liste_ajouts.append(k)
+ else:
+ # le bloc doit etre absent
+ if self.getChild(k, restreint="oui"):
+ # le bloc est present : il faut l'enlever
+ liste_retraits.append(k)
+ return liste_ajouts, liste_retraits
+
+ def verifExistenceSd(self):
+ """
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la reference a ces concepts
+ """
+ for motcle in self.mcListe:
+ motcle.verifExistenceSd()
+
+ def updateMcGlobal(self):
+ """
+ Met a jour les mots cles globaux enregistres dans l'etape parente
+ et dans le jdc parent.
+ Un mot cle compose ne peut pas etre global. Il se contente de passer
+ la requete a ses fils.
+ """
+ for motcle in self.mcListe:
+ motcle.updateMcGlobal()
+
+ def deleteMcGlobal(self):
+ for motcle in self.mcListe:
+ motcle.deleteMcGlobal()
+ # PN : je ne comprends pas les 4 lignes suivantes
+ # du coup je les vire
+ # surtout en dehors dans le for ?
+ # 20201217
+ # try :
+ # print (motcle)
+ # motcle.updateMcGlobal()
+ # except :
+ # pass
+
+ def supprimeUserAssd(self):
+ for objUserAssd in self.userASSDCrees:
+ objUserAssd.supprime(self)
+
+ def initModifUp(self):
+ V_MCCOMPO.MCCOMPO.initModifUp(self)
+ CONNECTOR.Emit(self, "valid")
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.extensions.eficas_translation import tr
+from Accas.accessor import CONNECTOR
+from Accas.accessor import A_MCCOMPO
+from Accas.processing import P_MCFACT
+
+
+class MCFACT(A_MCCOMPO.MCCOMPO):
+ def isRepetable(self):
+ """
+ Indique si l'objet est repetable.
+ Retourne 1 si le mot-cle facteur self peut etre repete
+ Retourne 0 dans le cas contraire
+ """
+ objet = self.parent.getChild(self.nom)
+ lenDejaLa = len(objet)
+ if self.definition.max > 1 and lenDejaLa < self.definition.max:
+ return 1
+ else:
+ return 0
+
+ def isOblig(self):
+ if self.definition.statut != "f":
+ return 0
+ objet = self.parent.getChild(self.nom)
+ if len(objet) > self.definition.min:
+ return 0
+ else:
+ return 1
+
+ def getMinMax(self):
+ """
+ Retourne les valeurs min et max admissibles pour la valeur de self
+ """
+ return self.definition.min, self.definition.max
+
+ def getNomDsXML(self):
+ # en xml on a une sequence si max est superieur a 1
+ # sinon non
+ objet = self.parent.getChild(self.nom, restreint="oui")
+ if len(objet) > 1:
+ index = objet.getIndex(self)
+ nom = self.nom + "[" + str(index) + "]"
+ else:
+ if self.definition.max == 1:
+ nom = self.nom
+ else:
+ nom = self.nom + "[0]"
+ nomDsXML = self.parent.getNomDsXML() + "." + nom
+ return nomDsXML
+
+ def getStatutEtRepetable(self):
+ """
+ Retourne l index du MCFACT ds la MCList
+ """
+ objet = self.parent.getChild(self.nom, restreint="oui")
+ if len(objet) > 1:
+ index = objet.getIndex(self) + 1
+ else:
+ index = 1
+ if self.definition.max > index:
+ repetable = 1
+ else:
+ repetable = 0
+ if self.definition.min < index or self.definition.statut == "f":
+ statut = "f"
+ else:
+ statut = "o"
+ return (statut, repetable)
+
+ def getLabelText(self):
+ """
+ Retourne le label de self suivant qu'il s'agit d'un MCFACT
+ isole ou d'un MCFACT appartenant a une MCList :
+ utilisee pour l'affichage dans l'arbre
+ """
+ objet = self.parent.getChild(self.nom, restreint="oui")
+ # objet peut-etre self ou une MCList qui contient self ...
+ if objet is None or objet is self:
+ return tr("Erreur - mclist inexistante : %s", self.nom)
+
+ try:
+ if len(objet) > 1:
+ index = (
+ objet.getIndex(self) + 1
+ ) # + 1 a cause de la numerotation qui commence a 0
+ return tr(self.nom) + "_" + repr(index) + ":"
+ else:
+ return tr(self.nom)
+ except:
+ return tr("Erreur - mot cle facteur de nom : %s", self.nom)
+
+ def getGenealogiePrecise(self):
+ nom = self.getLabelText()
+ if nom[-1] == ":":
+ nom = nom[0:-1]
+ if self.parent:
+ l = self.parent.getGenealogiePrecise()
+ l.append(nom.strip())
+ return l
+ else:
+ return [nom.strip()]
+
+ def getMCPath(self):
+ objet = self.parent.getChild(self.nom, restreint="oui")
+ if objet is None or objet is self:
+ return "mauvais MCPath"
+ if len(objet) > 1:
+ index = objet.getIndex(self)
+ else:
+ index = 0
+ nom = self.nom
+ if self.parent:
+ l = self.parent.getMCPath()
+ else:
+ l = []
+ l.append(nom.strip())
+ l.append("@index " + str(index) + " @")
+ return l
+
+ def initModif(self):
+ """
+ Met l'etat de l'objet a modified et propage au parent
+ qui vaut None s'il n'existe pas
+ """
+ self.state = "modified"
+ parent = hasattr(self, "alt_parent") and self.alt_parent or self.parent
+ if parent:
+ parent.initModif()
+
+ def finModif(self):
+ """
+ Methode appelee apres qu'une modification a ete faite afin de declencher
+ d'eventuels traitements post-modification
+ """
+ # print "finModif",self
+ # pour les objets autres que les commandes, aucun traitement specifique
+ # on remonte l'info de fin de modif au parent
+ CONNECTOR.Emit(self, "valid")
+ parent = hasattr(self, "alt_parent") and self.alt_parent or self.parent
+ if parent:
+ parent.finModif()
+
+ def normalize(self):
+ """Retourne le MCFACT normalise. Pour un MCFACT isole, l'objet normalise
+ est une MCLIST de longueur 1 qui contient ce MCFACT
+ """
+ new_obj = self.definition.list_instance()
+ new_obj.init(nom=self.nom, parent=None)
+ new_obj.append(self)
+ return new_obj
+
+ def supprime(self):
+ self.alt_parent = None
+ P_MCFACT.MCFACT.supprime(self)
+
+ def getDicoForFancy(self):
+ # print ('MCFACT getDicoForFancy ')
+ monDico = {}
+ leNom = self.nom
+
+ leNom = self.getLabelText()
+ monDico["statut"] = self.definition.statut
+ monDico["nomCommande"] = self.nom
+ if self.state == "undetermined":
+ self.isValid()
+
+ monDico["title"] = leNom
+ monDico["key"] = self.idUnique
+ monDico["classeAccas"] = self.nature
+ monDico["validite"] = self.getValid()
+ if not (monDico["validite"]):
+ monDico["validite"] = 0
+
+ (statut, repetable) = self.getStatutEtRepetable()
+ monDico["statut"] = statut
+ monDico["repetable"] = repetable
+ if monDico["validite"] == 0 and monDico["statut"] == "f":
+ monDico["validite"] = 2
+
+ listeNodes = []
+ for obj in self.mcListe:
+ lesNodes = obj.getDicoForFancy()
+ if not (isinstance(lesNodes, list)):
+ listeNodes.append(lesNodes)
+ else:
+ for leNode in lesNodes:
+ listeNodes.append(leNode)
+ monDico["children"] = listeNodes
+ if self.nature != "MCSIMP" and self.nature != "MCLIST":
+ monDico["infoOptionnels"] = self.calculOptionnelInclutBlocs()
+ return monDico
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+import types, traceback
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+from copy import copy
+from Accas.accessor import CONNECTOR
+
+
+class MCList:
+ def isMCList(self):
+ """
+ Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut)
+ """
+ return 1
+
+ def getIndex(self, objet):
+ """
+ Retourne la position d'objet dans la liste self
+ """
+ return self.data.index(objet)
+
+ def ajoutPossible(self):
+ """
+ Methode booleenne qui retourne 1 si on peut encore ajouter une occurrence
+ de l'element que contient self, 0 sinon
+ """
+ max = self.data[0].definition.max
+ if max == "**" or max == float("inf"):
+ return 1
+ else:
+ if len(self) < max:
+ return 1
+ else:
+ return 0
+
+ def isRepetable(self):
+ """
+ Indique si l'objet est repetable.
+ Retourne 1 si le mot-cle facteur self peut etre repete
+ Retourne 0 dans le cas contraire
+ """
+ if self.data[0].definition.max > 1:
+ # marche avec '**'
+ return 1
+ else:
+ return 0
+
+ def getDicoObjetsCompletsPourTree(self):
+ # print ('MCList getDicoObjetsCompletsPourTree pour ', self)
+ listeDict = []
+ for i in self.data:
+ listeDict.append(i.getDicoObjetsCompletsPourTree())
+ return listeDict
+
+ def getDicoForFancy(self):
+ listeDict = []
+ nbFactDejaLa = len(self.data)
+ for i in self.data:
+ dico = i.getDicoForFancy()
+ if nbFactDejaLa > i.definition.min:
+ dico["statut"] = "f"
+ if nbFactDejaLa < i.definition.max:
+ dico["repetable"] = 1
+ else:
+ dico["repetable"] = 0
+ listeDict.append(dico)
+ return listeDict
+ def isOblig(self):
+ """
+ Une MCList n'est jamais obligatoire (meme si le MCFACT qu'elle represente l'est
+ """
+ return self.data[0].definition.statut == "o"
+
+ def suppEntite(self, obj):
+ """
+ Supprime le mot cle facteur obj de la MCLIST
+ """
+ if obj not in self:
+ return 0
+
+ self.initModif()
+ self.remove(obj)
+ CONNECTOR.Emit(self, "supp", obj)
+ self.updateConditionBloc()
+ obj.delObjPyxb()
+ obj.supprime()
+ self.etape.modified()
+ self.finModif()
+ if obj.nom == "VariableProbabiliste":
+ if obj.variableDeterministe:
+ obj.variableDeterministe.variableProbabiliste = None
+ obj.variableDeterministe.associeVariableUQ = False
+ return 1
+
+ def addEntite(self, obj, pos=None):
+ """
+ Ajoute le mot cle facteur obj a la MCLIST a la position pos
+ Retourne None si l'ajout est impossible
+ """
+ if type(obj) == bytes or type(obj) == str:
+ # on est en mode creation d'un motcle
+ raise EficasException(tr("traitement non-prevu"))
+
+ if not self.ajoutPossible():
+ self.jdc.editor.afficheAlerte(
+ tr("Erreur"), tr("L'objet {} ne peut pas etre ajoute").format(obj.nom)
+ )
+ return None
+
+ if self.nom != obj.nom:
+ return None
+
+ if obj.isMCList():
+ obj = obj.data[0]
+
+ # traitement du copier coller seulement
+ # Les autres cas d'ajout sont traites dans MCFACT
+ self.initModif()
+ obj.verifExistenceSd()
+ obj.reparent(self.parent)
+ if pos is None:
+ self.append(obj)
+ else:
+ self.insert(pos, obj)
+ CONNECTOR.Emit(self, "add", obj)
+ self.finModif()
+ self.updateConditionBloc()
+ return obj
+
+ def listeMcPresents(self):
+ return []
+
+ def updateConcept(self, sd):
+ for child in self.data:
+ child.updateConcept(sd)
+ def demandeUpdateOptionnels(self):
+ for child in self.data:
+ child.demandeUpdateOptionnels()
+
+ def deleteRef(self):
+ for child in self.data:
+ child.deleteRef()
+
+ def deleteConcept(self, sd):
+ """
+ Inputs :
+ - sd=concept detruit
+ Fonction : Mettre a jour les fils de l objet suite a la disparition
+ du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
+ """
+ for child in self.data:
+ child.deleteConcept(sd)
+
+ def replaceConcept(self, old_sd, sd):
+ """
+ Inputs :
+ - old_sd=concept remplace
+ - sd=nouveau concept
+ Fonction : Mettre a jour les fils de l objet suite au remplacement
+ du concept old_sd
+ """
+ for child in self.data:
+ child.replaceConcept(old_sd, sd)
+
+ def getDocu(self):
+ return self.data[0].definition.getDocu()
+
+ def getListeMcInconnus(self):
+ """
+ Retourne la liste des mots-cles inconnus dans self
+ """
+ l_mc = []
+ for mcfact in self.data:
+ if mcfact.isValid():
+ continue
+ l_child = mcfact.getListeMcInconnus()
+ for mc in l_child:
+ l = [self]
+ l.extend(mc)
+ l_mc.append(l)
+ return l_mc
+
+ def verifConditionRegles(self, liste_presents):
+ """
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
+ """
+ # Sans objet pour une liste de mots cles facteurs
+ return []
+
+ def deepUpdateConditionBloc(self):
+ """
+ Parcourt l'arborescence des mcobject et realise l'update
+ des blocs conditionnels par appel de la methode updateConditionBloc
+ """
+ # print "deepUpdateConditionBloc",self
+ for mcfact in self.data:
+ mcfact.deepUpdateConditionBloc()
+
+ def updateConditionBloc(self):
+ """
+ Propage la mise a jour des conditions au parent.
+ Une liste ne fait pas de traitement sur les conditions
+ """
+ if self.parent:
+ self.parent.updateConditionBloc()
+
+ def verifConditionBloc(self):
+ """
+ Evalue les conditions de tous les blocs fils possibles
+ (en fonction du catalogue donc de la definition) de self et
+ retourne deux listes :
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
+ """
+ # Sans objet pour une liste de mots cles facteurs (a voir !!!)
+ return [], []
+
+ def initModif(self):
+ """
+ Met l'etat de l'objet a modified et propage au parent
+ qui vaut None s'il n'existe pas
+ """
+ self.state = "modified"
+ if self.parent:
+ self.parent.initModif()
+
+ def finModif(self):
+ """
+ Methode appelee apres qu'une modification a ete faite afin de declencher
+ d'eventuels traitements post-modification
+ """
+ # print "finModif",self
+ CONNECTOR.Emit(self, "valid")
+ if self.parent:
+ self.parent.finModif()
+
+ def getGenealogiePrecise(self):
+ if self.parent:
+ return self.parent.getGenealogiePrecise()
+ else:
+ return []
+
+ def getMCPath(self):
+ if self.parent:
+ return self.parent.getMCPath()
+ else:
+ return []
+
+ def getGenealogie(self):
+ """
+ Retourne la liste des noms des ascendants.
+ Un objet MCList n'est pas enregistre dans la genealogie.
+ XXX Meme si le MCFACT fils ne l'est pas lui non plus ????
+ """
+ if self.parent:
+ return self.parent.getGenealogie()
+ else:
+ return []
+
+ def getListeMcOrdonneeBrute(self, liste, dico):
+ """
+ Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
+ d'une entite composee dont le chemin complet est donne sous forme
+ d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
+ """
+ for arg in liste:
+ objet_cata = dico[arg]
+ dico = objet_cata.entites
+ return objet_cata.ordreMC
+
+ def verifExistenceSd(self):
+ """
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la reference a ces concepts
+ """
+ for motcle in self.data:
+ motcle.verifExistenceSd()
+
+ def getFr(self):
+ """
+ Retourne la chaine d'aide contenue dans le catalogue
+ en tenant compte de la langue
+ """
+ try:
+ return self.data[0].getFr()
+ except:
+ return ""
+
+ def normalize(self):
+ """
+ Retourne l'objet normalise. Une liste est deja normalisee
+ """
+ return self
+
+ def updateMcGlobal(self):
+ """
+ Met a jour les mots cles globaux enregistres dans l'etape parente
+ et dans le jdc parent.
+ Une liste ne peut pas etre globale. Elle se contente de passer
+ la requete a ses fils.
+ """
+ for motcle in self.data:
+ motcle.updateMcGlobal()
+
+ def deleteMcGlobal(self):
+ for motcle in self.data:
+ motcle.deleteMcGlobal()
+
+ # def __del__(self):
+ # print "__del__",self
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+import types
+import traceback
+from copy import copy
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+from Accas.processing.P_utils import repr_float
+from Accas.accessor import CONNECTOR
+
+# Attention : les classes ASSD,.... peuvent etre surchargees
+# dans le package Accas. Il faut donc prendre des precautions si
+# on utilise les classes de processing pour faire des tests (isxxxx, ...)
+# Si on veut creer des objets comme des CO avec les classes du processing
+# ils n'auront pas les conportements des autres packages (pb!!!)
+# Il vaut mieux les importer d'Accas mais probleme d'import circulaire,
+# on ne peut pas les importer au debut.
+# On fait donc un import local quand c'est necessaire (peut occasionner
+# des pbs de prformance).
+from Accas.processing.P_ASSD import ASSD, assd
+from Accas.processing.P_GEOM import GEOM, geom
+from Accas.processing.P_CO import CO
+
+# fin attention
+
+from Accas.extensions import parametre
+from Accas.extensions import param2
+from Accas.accessor import A_OBJECT
+from Accas.accessor import CONNECTOR
+from Accas.accessor.A_VALIDATOR import ValError, listProto
+from Accas.validation import V_MCSIMP
+
+
+class MCSIMP(A_OBJECT.OBJECT):
+ def isValid(self, cr="non"):
+ if self.state == "unchanged":
+ return self.valid
+ for type_permis in self.definition.type:
+ # if hasattr(type_permis, "__class__") and type_permis.__class__.__name__ == 'Matrice':
+ if hasattr(type_permis, "typElt"):
+ self.monType = type_permis
+ return self.valideMatrice(cr=cr)
+ validite = V_MCSIMP.MCSIMP.isValid(self, cr=cr)
+
+ if self.definition.siValide != None and validite:
+ self.definition.siValide(self)
+ return validite
+
+ def getNomConcept(self):
+ p = self
+ while p.parent:
+ try:
+ nomconcept = p.getSdname()
+ return nomconcept
+ except:
+ try:
+ nomconcept = p.object.getSdname()
+ return nomconcept
+ except:
+ pass
+ p = p.parent
+ return ""
+
+ def getText(self):
+ """
+ Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
+ pointe par self
+ """
+
+ if self.valeur == None:
+ return None
+ elif type(self.valeur) == float:
+ # traitement d'un flottant isole
+ txt = str(self.valeur)
+ clefobj = self.getNomConcept()
+ if clefobj in self.jdc.appliEficas.dict_reels:
+ if self.valeur in self.jdc.appliEficas.dict_reels[clefobj]:
+ txt = self.jdc.appliEficas.dict_reels[clefobj][self.valeur]
+ elif type(self.valeur) in (list, tuple):
+ if self.valeur == [] or self.valeur == ():
+ return str(self.valeur)
+ # traitement des listes
+ txt = "("
+ sep = ""
+ for val in self.valeur:
+ if type(val) == float:
+ clefobj = self.getNomConcept()
+ if clefobj in self.jdc.appliEficas.dict_reels:
+ if val in self.jdc.appliEficas.dict_reels[clefobj]:
+ txt = (
+ txt
+ + sep
+ + self.jdc.appliEficas.dict_reels[clefobj][val]
+ )
+ else:
+ txt = txt + sep + str(val)
+ else:
+ txt = txt + sep + str(val)
+ else:
+ if isinstance(val, tuple):
+ texteVal = "("
+ for i in val:
+ if isinstance(i, bytes) or isinstance(i, str):
+ texteVal = texteVal + "'" + str(i) + "',"
+ else:
+ texteVal = texteVal + str(i) + ","
+ texteVal = texteVal[:-1] + ")"
+ else:
+ if isinstance(val, bytes) or isinstance(val, str):
+ texteVal = "'" + str(val) + "'"
+ else:
+ texteVal = str(val)
+ txt = txt + sep + texteVal
+
+ ## if len(txt) > 200:
+ ## #ligne trop longue, on tronque
+ ## txt=txt+" ..."
+ ## break
+ sep = ","
+ # cas des listes de tuples de longueur 1
+ if isinstance(val, tuple) and len(self.valeur) == 1:
+ txt = txt + ","
+ txt = txt + ")"
+ else:
+ # traitement des autres cas
+ txt = str(self.valeur)
+
+ # txt peut etre une longue chaine sur plusieurs lignes.
+ # Il est possible de tronquer cette chaine au premier \n et
+ # de limiter la longueur de la chaine a 30 caracteres. Cependant
+ # ceci provoque une perte d'information pour l'utilisateur
+ # Pour le moment on retourne la chaine telle que
+ return txt
+
+ def getVal(self):
+ """
+ Retourne une chaine de caractere representant la valeur de self
+ """
+ val = self.valeur
+ if type(val) == float:
+ clefobj = self.getNomConcept()
+ if clefobj in self.jdc.appliEficas.dict_reels:
+ if val in self.jdc.appliEficas.appliEficas.dict_reels[clefobj]:
+ return self.jdc.appliEficas.dict_reels[clefobj][val]
+ if type(val) != tuple:
+ try:
+ return val.getName()
+ except:
+ return val
+ else:
+ if val == () or val == []:
+ return val
+ s = "( "
+ for item in val:
+ try:
+ s = s + item.getName() + ","
+ except:
+ s = s + repr(item) + ","
+ s = s + " )"
+ return s
+
+ def waitBool(self):
+ for typ in self.definition.type:
+ try:
+ if typ == bool:
+ return True
+ except:
+ pass
+ return False
+
+ def waitCo(self):
+ """
+ Methode booleenne qui retourne 1 si l'objet attend un objet ASSD
+ qui n'existe pas encore (type CO()), 0 sinon
+ """
+ for typ in self.definition.type:
+ if type(typ) == type or isinstance(typ, type):
+ if issubclass(typ, CO):
+ return 1
+ return 0
+
+ def waitAssd(self):
+ """
+ Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD ou UserASSD
+ ou derive, 0 sinon
+ """
+ for typ in self.definition.type:
+ if type(typ) == type or isinstance(typ, type):
+ if issubclass(typ, ASSD) and not issubclass(typ, GEOM):
+ return 1
+ return 0
+
+ def waitUserAssd(self):
+ """
+ Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD
+ ou derive, 0 sinon
+ """
+ from Accas import UserASSD
+ for typ in self.definition.type:
+ if type(typ) == type or isinstance(typ, type):
+ if issubclass(typ, UserASSD):
+ return 1
+ return 0
+
+ def waitUserAssdMultiple(self):
+ from Accas import UserASSDMultiple
+ for typ in self.definition.type:
+ if type(typ) == type or isinstance(typ, type):
+ if issubclass(typ, UserASSDMultiple):
+ return 1
+ return 0
+
+ def waitUserAssdOrAssdMultipleEnCreation(self):
+ for typ in self.definition.type:
+ if typ == "createObject":
+ return 1
+ return 0
+
+ def waitAssdOrGeom(self):
+ """
+ Retourne 1 si le mot-cle simple attend un objet de type
+ assd, ASSD, geom ou GEOM
+ Retourne 0 dans le cas contraire
+ """
+ for typ in self.definition.type:
+ if type(typ) == type or isinstance(typ, type):
+ if typ.__name__ in ("GEOM", "ASSD", "geom", "assd") or issubclass(
+ typ, GEOM
+ ):
+ return 1
+ return 0
+
+ def waitGeom(self):
+ """
+ Retourne 1 si le mot-cle simple attend un objet de type GEOM
+ Retourne 0 dans le cas contraire
+ """
+ for typ in self.definition.type:
+ if type(typ) == type or isinstance(typ, type):
+ if issubclass(typ, GEOM):
+ return 1
+ return 0
+
+ def waitTxm(self):
+ """
+ Retourne 1 si le mot-cle simple attend un objet de type TXM
+ Retourne 0 dans le cas contraire
+ """
+ for typ in self.definition.type:
+ if typ == "TXM":
+ return 1
+ return 0
+
+ def waitTuple(self):
+ for ss_type in self.definition.type:
+ if repr(ss_type).find("Tuple") != -1:
+ return 1
+ return 0
+
+ def waitChaineAvecBlancs(self):
+ if self.definition.avecBlancs:
+ return 1
+ return 0
+
+ def combienEltDsTuple(self):
+ for ss_type in self.definition.type:
+ if hasattr(ss_type, "ntuple"):
+ return ss_type.ntuple
+ return O
+
+ def waitMatrice(self):
+ if hasattr(self, "isAMatrice"):
+ return self.isAMatrice
+ for typ in self.definition.type:
+ try:
+ if hasattr(typ, "typElt"):
+ self.isAMatrice = 1
+ return 1
+ except:
+ pass
+ self.isAMatrice = 0
+ return 0
+
+ def getListeValeurs(self):
+ """ """
+ if self.valeur == None:
+ return []
+ elif type(self.valeur) == tuple:
+ return list(self.valeur)
+ elif type(self.valeur) == list:
+ return self.valeur
+ else:
+ return [self.valeur]
+
+ def isOblig(self):
+ return self.definition.statut == "o"
+
+ def isImmuable(self):
+ return self.definition.homo == "constant"
+
+ def isInformation(self):
+ return self.definition.homo == "information"
+
+ def validVal(self, valeur):
+ """
+ Verifie que la valeur passee en argument (valeur) est valide
+ sans modifier la valeur courante
+ """
+ lval = listProto.adapt(valeur)
+ if lval is None:
+ valid = 0
+ mess = tr("None n'est pas une valeur autorisee")
+ else:
+ try:
+ for val in lval:
+ self.typeProto.adapt(val)
+ self.intoProto.adapt(val)
+ self.cardProto.adapt(lval)
+ if self.definition.validators:
+ self.definition.validators.convert(lval)
+ valid, mess = 1, ""
+ except ValError as e:
+ mess = str(e)
+ valid = 0
+ return valid, mess
+
+ def validValeur(self, new_valeur):
+ """
+ Verifie que la valeur passee en argument (new_valeur) est valide
+ sans modifier la valeur courante (evite d'utiliser setValeur et est plus performant)
+ """
+ validite, mess = self.validVal(new_valeur)
+ return validite
+
+ def validValeurPartielle(self, new_valeur):
+ """
+ Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide
+ sans modifier la valeur courante du mot cle
+ """
+ validite = 1
+ try:
+ for val in new_valeur:
+ self.typeProto.adapt(val)
+ self.intoProto.adapt(val)
+ # on ne verifie pas la cardinalite
+ if self.definition.validators:
+ validite = self.definition.validators.valideListePartielle(
+ new_valeur
+ )
+ except ValError as e:
+ validite = 0
+
+ return validite
+
+ def updateConditionBloc(self):
+ """Met a jour les blocs conditionnels dependant du mot cle simple self"""
+ if self.definition.position == "global":
+ self.etape.deepUpdateConditionBloc()
+ self.etape.demandeUpdateOptionnels()
+ elif self.definition.position == "reCalculeEtape":
+ # print ('je passe par updateConditionBloc pour ', self.nom)
+ self.etape.deepUpdateConditionBloc()
+ self.etape.demandeRedessine()
+ elif self.definition.position == "global_jdc":
+ self.jdc.deepUpdateConditionBloc(self)
+ self.etape.demandeRedessine()
+ elif self.definition.position == "inGetAttribut":
+ self.jdc.deepUpdateConditionBloc(self)
+ else:
+ self.parent.updateConditionBloc()
+
+ def demandeUpdateOptionnels(self):
+ pass
+ def setValeur(self, new_valeur, evaluation="oui"):
+ self.initModif()
+ self.valeur = new_valeur
+ self.val = new_valeur
+ if (
+ self.valeur
+ and self.waitUserAssd()
+ and not (self.waitUserAssdOrAssdMultipleEnCreation())
+ ):
+ if type(self.valeur) in (list, tuple):
+ for v in self.valeur:
+ v.ajoutUtilisePar(self)
+ else:
+ self.valeur.ajoutUtilisePar(self)
+ if self.isValid() and hasattr(self, "objPyxb") and self.objPyxb:
+ self.setValeurObjPyxb(new_valeur)
+ self.updateConditionBloc()
+ if self.definition.metAJour != None:
+ self.updateAutresMotsClefs()
+ self.etape.modified()
+ self.finModif()
+ return 1
+
+ def evalValeur(self, new_valeur):
+ """
+ Essaie d'evaluer new_valeur comme une SD, une declaration Python
+ ou un EVAL: Retourne la valeur evaluee (ou None) et le test de reussite (1 ou 0)
+ """
+ sd = self.jdc.getSdAvantEtape(new_valeur, self.etape)
+ # sd = self.jdc.getContexteAvant(self.etape).get(new_valeur,None)
+ if sd is not None:
+ return sd, 1
+ lsd = self.jdc.chercheListAvant(self.etape, new_valeur)
+ if lsd:
+ return lsd, 1
+ else:
+ d = {}
+ # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
+ d["EVAL"] = Accas.EVAL
+ try:
+ objet = eval(new_valeur, d)
+ return objet, 1
+ except Exception:
+ itparam = self.chercheItemParametre(new_valeur)
+ if itparam:
+ return itparam, 1
+ try:
+ object = eval(new_valeur.valeur, d)
+ except:
+ pass
+ if CONTEXT.debug:
+ traceback.print_exc()
+ return None, 0
+
+ def evalVal(self, new_valeur):
+ """
+ Tente d'evaluer new_valeur comme un objet du jdc (par appel a evalValItem)
+ ou comme une liste de ces memes objets
+ Si new_valeur contient au moins un separateur (,), tente l'evaluation sur
+ la chaine splittee
+ """
+ if new_valeur in ("True", "False") and "TXM" in self.definition.type:
+ valeur = self.evalValItem(str(new_valeur))
+ return new_valeur
+ if type(new_valeur) in (list, tuple):
+ valeurretour = []
+ for item in new_valeur:
+ valeurretour.append(self.evalValItem(item))
+ return valeurretour
+ else:
+ valeur = self.evalValItem(new_valeur)
+ return valeur
+
+ def evalValItem(self, new_valeur):
+ """
+ Tente d'evaluer new_valeur comme un concept, un parametre, un objet Python ou un UserASSD
+ Si c'est impossible retourne new_valeur inchange
+ argument new_valeur : string (nom de concept, de parametre, expression ou simple chaine)
+ """
+ if new_valeur in list(self.jdc.sdsDict.keys()) and self.waitUserAssd():
+ valeur = self.jdc.sdsDict[new_valeur]
+ return valeur
+ elif self.etape and self.etape.parent:
+ valeur = self.etape.parent.evalInContext(new_valeur, self.etape)
+ return valeur
+ else:
+ try:
+ valeur = eval(new_valeur)
+ return valeur
+ except:
+ # traceback.print_exc()
+ return new_valeur
+ pass
+
+ def chercheItemParametre(self, new_valeur):
+ try:
+ nomparam = new_valeur[0 : new_valeur.find("[")]
+ indice = new_valeur[new_valeur.find("[") + 1 : new_valeur.find("]")]
+ for p in self.jdc.params:
+ if p.nom == nomparam:
+ if int(indice) < len(p.getValeurs()):
+ itparam = parametre.ITEM_PARAMETRE(p, int(indice))
+ return itparam
+ return None
+ except:
+ return None
+
+ def updateConcept(self, sd):
+ if not self.waitAssd():
+ return
+ if type(self.valeur) in (list, tuple):
+ if sd in self.valeur:
+ newVal = []
+ for v in self.valeur:
+ newVal.append(v.nom)
+ self.initModif()
+ if hasattr(self, "objPyxb") and self.objPyxb:
+ self.setValeurObjPyxb(newVal)
+ self.finModif()
+ else:
+ if sd == self.valeur:
+ self.initModif()
+ if hasattr(self, "objPyxb") and self.objPyxb:
+ self.setValeurObjPyxb(sd.nom)
+ self.finModif()
+
+ def deleteConcept(self, sd):
+ """
+ Inputs :
+ - sd=concept detruit
+ Fonction :
+ Met a jour la valeur du mot cle simple suite a la disparition
+ du concept sd
+ Attention aux matrices
+ """
+ ##PNPNPN a tester
+ if type(self.valeur) == tuple:
+ if sd in self.valeur:
+ self.initModif()
+ self.valeur = list(self.valeur)
+ while sd in self.valeur:
+ self.valeur.remove(sd)
+ if hasattr(self, "objPyxb") and self.objPyxb:
+ newVal = []
+ for v in self.valeur:
+ newVal.append(v.nom)
+ if newVal == []:
+ self.delObjPyxb()
+ else:
+ self.setValeurObjPyxb(sd.nom)
+ self.finModif()
+ elif type(self.valeur) == list:
+ if sd in self.valeur:
+ self.initModif()
+ while sd in self.valeur:
+ self.valeur.remove(sd)
+ self.finModif()
+ else:
+ if self.valeur == sd:
+ self.initModif()
+ self.valeur = None
+ self.val = None
+ if hasattr(self, "objPyxb") and self.objPyxb:
+ self.setValeurObjPyxb()
+ self.finModif()
+ # Glut Horrible pour les matrices OT ???
+ # if sd.__class__.__name__== "variable":
+ # for type_permis in self.definition.type:
+ # if type(type_permis) == types.InstanceType:
+ # a voir en python 3
+ # if type_permis.__class__.__name__ == 'Matrice' :
+ # self.state="changed"
+ # self.isValid()
+
+ def replaceConcept(self, old_sd, sd):
+ """
+ Inputs :
+ - old_sd=concept remplace
+ - sd=nouveau concept
+ Fonction :
+ Met a jour la valeur du mot cle simple suite au remplacement
+ du concept old_sd
+ """
+ # print ("replaceConcept",old_sd,sd)
+ if type(self.valeur) == tuple:
+ if old_sd in self.valeur:
+ self.initModif()
+ self.valeur = list(self.valeur)
+ i = self.valeur.index(old_sd)
+ self.valeur[i] = sd
+ self.finModif()
+ elif type(self.valeur) == list:
+ if old_sd in self.valeur:
+ self.initModif()
+ i = self.valeur.index(old_sd)
+ self.valeur[i] = sd
+ self.finModif()
+ else:
+ if self.valeur == old_sd:
+ self.initModif()
+ self.valeur = sd
+ self.val = sd
+ self.finModif()
+
+ def setValeurCo(self, nomCO):
+ """
+ Affecte a self l'objet de type CO et de nom nomCO
+ """
+ step = self.etape.parent
+ if nomCO == None or nomCO == "":
+ new_objet = None
+ else:
+ # Avant de creer un concept il faut s'assurer du contexte : step
+ # courant
+ sd = step.getSdAutourEtape(nomCO, self.etape, avec="oui")
+ if sd:
+ # Si un concept du meme nom existe deja dans la portee de l'etape
+ # on ne cree pas le concept
+ return 0, tr("un concept de meme nom existe deja")
+ # Il n'existe pas de concept de meme nom. On peut donc le creer
+ # Il faut neanmoins que la methode NommerSdProd de step gere les
+ # contextes en mode editeur
+ # Normalement la methode de processing doit etre surchargee
+ # On declare l'etape du mot cle comme etape courante pour nommerSDProd
+ cs = CONTEXT.getCurrentStep()
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(step)
+ step.setEtapeContext(self.etape)
+ new_objet = Accas.CO(nomCO)
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(cs)
+ self.initModif()
+ self.valeur = new_objet
+ self.val = new_objet
+ # On force l'enregistrement de new_objet en tant que concept produit
+ # de la macro en appelant getType_produit avec force=1
+ self.etape.getType_produit(force=1)
+ self.finModif()
+ step.resetContext()
+ # print "setValeurCo",new_objet
+ return 1, tr("Concept cree")
+
+ def verifExistenceSd(self):
+ """
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la referea ces concepts
+ """
+ # print "verifExistenceSd"
+ # Attention : possible probleme avec include
+ # A priori il n'y a pas de raison de retirer les concepts non existants
+ # avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro
+ l_sd_avant_etape = list(self.jdc.getContexteAvant(self.etape).values())
+ if type(self.valeur) in (tuple, list):
+ l = []
+ for sd in self.valeur:
+ if isinstance(sd, ASSD):
+ if sd in l_sd_avant_etape or self.etape.getSdprods(sd.nom) is sd:
+ l.append(sd)
+ else:
+ l.append(sd)
+ if len(l) < len(self.valeur):
+ self.initModif()
+ self.valeur = tuple(l)
+ self.finModif()
+ else:
+ if isinstance(self.valeur, ASSD):
+ if (
+ self.valeur not in l_sd_avant_etape
+ and self.etape.getSdprods(self.valeur.nom) is None
+ ):
+ self.initModif()
+ self.valeur = None
+ self.finModif()
+
+ def renommeSdCree(self, nouveauNom):
+ # print ( 'dans renommeSdCree', self.jdc.sdsDict, self.valeur)
+ if nouveauNom in self.jdc.sdsDict:
+ return (0, "concept deja existant")
+ if self.valeur == None:
+ return (0, "pb sur la valeur")
+ else:
+ self.valeur.renomme(nouveauNom)
+ return (1, "concept renomme")
+
+ def renommeSdCreeDsListe(self, objASSD, nouveauNom):
+ # print ( 'dans renommeSdCree', self.jdc.sdsDict, self.valeur, nouveauNom)
+ if nouveauNom in self.jdc.sdsDict:
+ return (0, "concept deja existant")
+ objASSD.renomme(nouveauNom)
+ return (1, "concept renomme")
+
+ def getMinMax(self):
+ """
+ Retourne les valeurs min et max admissibles pour la valeur de self
+ """
+ return self.definition.min, self.definition.max
+
+ def getType(self):
+ """
+ Retourne le type attendu par le mot-cle simple
+ """
+ return self.definition.type
+
+ def deleteMcGlobal(self):
+ """Retire self des declarations globales"""
+ # on est oblige de verifier si le nom est dans etape
+ # car parfois l ordre des creations/destruction n est pas clair
+ # quand on a des blocs freres qui contiennent le meme mc global
+ # cas de NumericalMethod dans VIMMP
+ if self.definition.position == "global":
+ etape = self.getEtape()
+ if etape and self.nom in etape.mc_globaux:
+ if etape.mc_globaux[self.nom] == self:
+ del etape.mc_globaux[self.nom]
+ elif self.definition.position == "reCalculeEtape":
+ etape = self.getEtape()
+ if etape:
+ if self.nom in etape.mc_globaux:
+ if etape.mc_globaux[self.nom] == self:
+ del etape.mc_globaux[self.nom]
+ self.etape.doitEtreRecalculee = True
+ # print ('deleteMcGlobal je mets doitEtreRecalculee = True avec', self.nom ,' pour ', etape.nom)
+ elif self.definition.position == "global_jdc":
+ if self.nom in self.jdc.mc_globaux:
+ try:
+ del self.jdc.mc_globaux[self.nom]
+ except:
+ print("!!!!!!!! Souci delete mc_globaux")
+
+ def updateMcGlobal(self):
+ """
+ Met a jour les mots cles globaux enregistres dans l'etape parente
+ et dans le jdc parent.
+ Un mot cle simple peut etre global.
+ """
+ if self.definition.position == "global":
+ etape = self.getEtape()
+ if etape:
+ etape.mc_globaux[self.nom] = self
+ elif self.definition.position == "reCalculeEtape":
+ etape = self.getEtape()
+ if etape:
+ etape.mc_globaux[self.nom] = self
+ etape.doitEtreRecalculee = True
+ print(
+ "je mets doitEtreRecalculee = True avec",
+ self.nom,
+ " pour ",
+ etape.nom,
+ )
+ print("j ajoute au mc_globaux")
+ elif self.definition.position == "global_jdc":
+ if self.jdc:
+ self.jdc.mc_globaux[self.nom] = self
+
+ def nbrColonnes(self):
+ genea = self.getGenealogie()
+ if "VALE_C" in genea and "DEFA_FONCTION" in genea:
+ return 3
+ if "VALE" in genea and "DEFA_FONCTION" in genea:
+ return 2
+ return 0
+
+ def valideItem(self, item):
+ """Valide un item isole. Cet item est candidata l'ajout a la liste existante"""
+ valid = 1
+ try:
+ # on verifie le type
+ self.typeProto.adapt(item)
+ # on verifie les choix possibles
+ self.intoProto.adapt(item)
+ # on ne verifie pas la cardinalite
+ if self.definition.validators:
+ valid = self.definition.validators.verifItem(item)
+ except ValError as e:
+ # traceback.print_exc()
+ valid = 0
+ return valid
+
+ def verifType(self, item):
+ """Verifie le type d'un item de liste"""
+ try:
+ # on verifie le type
+ self.typeProto.adapt(item)
+ # on verifie les choix possibles
+ self.intoProto.adapt(item)
+ # on ne verifie pas la cardinalite mais on verifie les validateurs
+ if self.definition.validators:
+ if hasattr(self.definition.validators, "set_MCSimp"):
+ self.definition.validators.set_MCSimp(self)
+ valid = self.definition.validators.verifItem(item)
+ comment = ""
+ valid = 1
+ except ValError as e:
+ # traceback.print_exc()
+ comment = tr(e.__str__())
+ valid = 0
+ except Exception as e:
+ comment = tr(e.__str__())
+ valid = 0
+ return valid, comment
+
+ def valideMatrice(self, cr):
+ ok = 1
+ commentaire = ""
+ if self.valeur == None:
+ self.setValid(0)
+ return 0
+
+ if self.monType.methodeCalculTaille != None:
+ MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,))
+
+ if len(self.valeur) == self.monType.nbLigs:
+ for i in range(len(self.valeur)):
+ if len(self.valeur[i]) != self.monType.nbCols:
+ ok = 0
+ else:
+ ok = 0
+
+ if not ok:
+ self.setValid(0)
+ if cr == "oui":
+ self.cr.fatal(
+ tr(
+ "La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d",
+ {"n_lign": self.monType.nbLigs, "n_col": self.monType.nbCols},
+ )
+ )
+ return 0
+
+ for i in range(self.monType.nbLigs):
+ for j in range(self.monType.nbCols):
+ val = self.valeur[i][j]
+ ok, commentaire = self.monType.verifItem(str(val), self.parent)
+ if (
+ self.monType.typElt not in ("TXM", "I", "R")
+ and type(val) != self.monType.typElt
+ ):
+ ok = 0
+ commentaire = "mauvais type"
+ self.valeur = None
+ if not ok:
+ self.setValid(0)
+ if cr == "oui":
+ self.cr.fatal(tr(commentaire))
+ return 0
+ self.setValid(1)
+ return 1
+
+ def valideMatriceOT(self, cr):
+ # Attention, la matrice contient comme dernier tuple l ordre des variables
+ if self.valideEnteteMatrice() == False:
+ self.setValid(0)
+ if cr == "oui":
+ self.cr.fatal(tr("La matrice n'a pas le bon entete"))
+ return 0
+ if self.monType.methodeCalculTaille != None:
+ MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,))
+ try:
+ # if 1 :
+ ok = 0
+ if len(self.valeur) == self.monType.nbLigs + 1:
+ ok = 1
+ for i in range(len(self.valeur) - 1):
+ if len(self.valeur[i]) != self.monType.nbCols:
+ ok = 0
+ if ok:
+ self.setValid(1)
+ return 1
+ except:
+ # else :
+ pass
+ if cr == "oui":
+ self.cr.fatal(
+ tr(
+ "La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d",
+ {"n_lign": self.monType.nbLigs, "n_col": self.monType.nbCols},
+ )
+ )
+ self.setValid(0)
+ return 0
+
+ def nbDeVariables(self):
+ listeVariables = self.jdc.getVariables(self.etape)
+ self.monType.nbLigs = len(listeVariables)
+ self.monType.nbCols = len(listeVariables)
+
+ def valideEnteteMatrice(self):
+ if self.jdc.getDistributions(self.etape) == () or self.valeur == None:
+ return 0
+ if self.jdc.getDistributions(self.etape) != self.valeur[0]:
+ return 0
+ return 1
+
+ def changeEnteteMatrice(self):
+ a = [
+ self.jdc.getDistributions(self.etape),
+ ]
+ for t in self.valeur[1:]:
+ a.append(t)
+ self.valeur = a
+
+ def nbDeDistributions(self):
+ listeVariables = self.jdc.getDistributions(self.etape)
+ self.monType.nbLigs = len(listeVariables)
+ self.monType.nbCols = len(listeVariables)
+
+ def getNomDsXML(self):
+ nomDsXML = self.parent.getNomDsXML() + "." + self.nom
+ return nomDsXML
+
+ def verifTypeIhm(self, val, cr="non"):
+ try:
+ val.eval()
+ return 1
+ except:
+ traceback.print_exc()
+ pass
+ return self.verifType(val, cr)
+
+ def verifTypeliste(self, val, cr="non"):
+ verif = 0
+ for v in val:
+ verif = verif + self.verifTypeIhm(v, cr)
+ return verif
+
+ def initModifUp(self):
+ V_MCSIMP.MCSIMP.initModifUp(self)
+ CONNECTOR.Emit(self, "valid")
+
+ def deleteRef(self):
+ if self.valeur == None or self.valeur == []:
+ return
+ if not type(self.valeur) in (list, tuple):
+ lesValeurs = (self.valeur,)
+ else:
+ lesValeurs = self.valeur
+ for val in lesValeurs:
+ if self.definition.creeDesObjets:
+ val.deleteReference(self)
+ else:
+ if hasattr(val, "enleveUtilisePar"):
+ val.enleveUtilisePar(self)
+
+ def updateAutresMotsClefs(self):
+ # print ('updateAutresMotsClefs')
+ for nomMC, Xpath in self.definition.metAJour:
+ exp = Xpath + '.getChild("' + nomMC + '")'
+ try:
+ lesMotsClefs = eval(exp)
+ except:
+ lesMotsClefs = []
+ if not type(lesMotsClefs) in (list, tuple):
+ lesMotsClefs = (lesMotsClefs,)
+ if isinstance(lesMotsClefs, MCSIMP):
+ lesMotsClefs = (lesMotsClefs,)
+ listeEtapesDejaRedessinees = []
+ listeMotsClefsAppel = []
+ for leMotCle in lesMotsClefs:
+ leMotCle.state = "changed"
+ if not leMotCle.isValid():
+ leMotCle.val = None
+ if leMotCle.etape not in listeEtapesDejaRedessinees:
+ listeEtapesDejaRedessinees.append(leMotCle.etape)
+ listeMotsClefsAppel.append(leMotCle)
+ for leMotCle in listeMotsClefsAppel:
+ leMotCle.demandeRedessine()
+
+ # print ('fin updateAutresMotsClefs')
+
+ def UQPossible(self):
+ # Plus facile de mettre cette methode dans le SIMP, car on connait son nom
+ # reflechir au TUI
+ if not hasattr(self.cata, "dictUQ"):
+ return False
+ if not (self.nom in self.cata.dictUQ.keys()):
+ return False
+ if not hasattr(self.cata, "dictUQConditions"):
+ return True
+ if not (self.nom in self.cata.dictUQConditions.keys()):
+ return True
+ maFonction = self.cata.dictUQConditions[self.nom][0]
+ argsLoi = self.cata.dictUQConditions[self.nom][1]
+ argsLoi["obj"] = self
+ return maFonction(**argsLoi)
+
+ def isUQActivate(self):
+ # valide uniquement pour les MCSIMP
+ # a reflechir a la relecture du .comm
+ return self.associeVariableUQ
+
+ def lieVariableUQ(self):
+ # print ('je passe dans lieVariableUQ')
+ self.associeVariableUQ = True
+ etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude")
+ if etapeIncertitude == []:
+ self.jdc.editor.tree.racine.appendChild("ExpressionIncertitude", "last")
+ etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude")
+ # Ou la la, que c est generique
+ # ajouter un op_construction
+ etapeIncertitude[0].buildSd()
+ etapeIncertitude = etapeIncertitude[0]
+ incertitudeInput = etapeIncertitude.getChildOrChildInBloc("Input")
+ nodeVariableProbabiliste = incertitudeInput.node.appendChild(
+ "VariableProbabiliste", "first"
+ )
+ # le buildChildren a une mcliste --> on est oblige de mettre first mais en fait c est last
+ # PN a cooriger
+ if nodeVariableProbabiliste.item.object.nature == "MCFACT":
+ newVariable = nodeVariableProbabiliste.item.object
+ else:
+ newVariable = nodeVariableProbabiliste.item.object[-1]
+ newVariable.variableDeterministe = self
+ self.variableProbabiliste = newVariable
+
+ if self.etape.nature == "OPERATEUR":
+ itemObjet = newVariable.addEntite("ObjectName", 0)
+ itemObjet.definition.addInto(self.etape.sd.nom)
+ itemObjet.setValeur(self.etape.sd.nom)
+ itemModelVariable = newVariable.getChild("ModelVariable")
+ itemModelVariable.setValeur(self.nom)
+
+ itemConsigne = newVariable.getChild("Consigne")
+ itemConsigne.setValeur(
+ "la valeur entrée pour {} est {}".format(self.nom, self.valeur)
+ )
+
+ itemXPath = newVariable.getChild("MCPath")
+ itemXPath.setValeur(self.getMCPath())
+ # print (itemXPath)
+
+ self.definition.siValide = self.changeValeursRefUQ
+
+ def changeValeursRefUQ(self, motClef):
+ debug = 0
+ if debug:
+ print("changeValeursRefUQ", motClef)
+ if debug:
+ print(self.nom)
+ # la premiere fois, si on a des MCFACT, la variable probabiliste n est pas encore a jour
+ if not hasattr(motClef, "variableProbabiliste"):
+ if debug:
+ print("pb ds changeValeursRefUQ")
+ return
+ itemConsigne = motClef.variableProbabiliste.getChild("Consigne")
+ itemConsigne.setValeur(
+ "la valeur entrée pour {} est {}".format(motClef.nom, motClef.valeur)
+ )
+
+ def delieVariableUQ(self):
+ debug = 0
+ if debug:
+ print("delieVariableUQ pour", self)
+ self.associeVariableUQ = False
+ # Attention, on n a pas le MCLIST mais le MCLIST(0) dans la variableProbabiliste
+ # si self est le seul alors on enleve la MCLIST du MCCOMPO
+ mcVP = self.variableProbabiliste.parent.getChild("VariableProbabiliste")
+ if len(mcVP) == 1:
+ ret = self.variableProbabiliste.parent.suppEntite(mcVP)
+ else:
+ ret = mcVP.suppEntite(self.variableProbabiliste)
+ return ret
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+
+from Accas.accessor import CONNECTOR
+import re
+
+conceptRE = re.compile(r"[a-zA-Z_]\w*$")
+
+
+class OBJECT:
+ from Accas.processing.P_CO import CO
+ from Accas.processing.P_ASSD import assd
+
+ def isMCList(self):
+ """
+ Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut)
+ """
+ return 0
+
+ def getRegles(self):
+ """
+ Retourne les regles de self
+ """
+ if hasattr(self, "definition"):
+ return self.definition.regles
+ elif hasattr(self, "regles"):
+ return self.regles
+ else:
+ return []
+
+ def initModif(self):
+ """
+ Met l'etat de l'objet a modified et propage au parent
+ qui vaut None s'il n'existe pas
+ """
+ self.state = "modified"
+ if self.parent:
+ self.parent.initModif()
+
+ def finModif(self):
+ """
+ Methode appelee apres qu'une modification a ete faite afin de declencher
+ d'eventuels traitements post-modification
+ """
+ # print "finModif",self
+ # pour les objets autres que les commandes, aucun traitement specifique
+ # on remonte l'info de fin de modif au parent
+ CONNECTOR.Emit(self, "valid")
+ if self.parent:
+ self.parent.finModif()
+
+ def isRepetable(self):
+ """
+ Indique si l'objet est repetable
+ """
+ return 0
+
+ def listeMcPresents(self):
+ """
+ Retourne la liste des noms des mots cles presents
+ """
+ return []
+
+ def getDocu(self):
+ return self.definition.getDocu()
+
+ def getListeMcInconnus(self):
+ """
+ Retourne la liste des mots-cles inconnus dans self
+ """
+ return []
+
+ def verifConditionRegles(self, liste_presents):
+ """
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
+ """
+ liste = []
+ for regle in self.definition.regles:
+ liste = regle.verifConditionRegle(liste, liste_presents)
+ return liste
+
+ def verifConditionBloc(self):
+ """
+ Evalue les conditions de tous les blocs fils possibles
+ (en fonction du catalogue donc de la definition) de self et
+ retourne deux listes :
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
+ """
+ return [], []
+
+ def getGenealogiePrecise(self):
+ if self.parent:
+ l = self.parent.getGenealogiePrecise()
+ l.append(self.nom.strip())
+ return l
+ else:
+ return [self.nom.strip()]
+
+ def getMCPath(self):
+ if self.parent:
+ l = self.parent.getMCPath()
+ l.append(self.nom.strip())
+ return l
+ else:
+ # a priori on ne devrait pas passer la
+ print("Erreur dans getMCPath de A_OBJECT")
+ return [self.nom.strip()]
+
+ def getObjetByMCPath(self, MCPath):
+ debug = 0
+ if debug:
+ print("getObjetByMCPath pour", self, self.nom, MCPath)
+ nomFils = MCPath[0]
+ if debug:
+ print("self", self.nom)
+ if debug:
+ print("MCPath restant", MCPath[1:])
+ if MCPath[1:] == [] or MCPath[1:] == ():
+ if debug:
+ print("objFils", self.getChildOrChildInBloc(nomFils))
+ return self.getChildOrChildInBloc(nomFils)
+ else:
+ objetFils = self.getChildOrChildInBloc(nomFils)
+ if debug:
+ print("dans else", self, self.nom, objetFils, nomFils)
+ if MCPath[1].startswith("@index "):
+ indexObj = MCPath[1].split(" ")[1]
+ indexObj = int(indexObj.split(" ")[0])
+ if debug:
+ print("index de l objet", indexObj)
+ objetFils = objetFils.data[indexObj]
+ if debug:
+ print("objetFils cas Mclist", objetFils)
+ if MCPath[2:] == [] or MCPath[2:] == ():
+ return objetFils
+ else:
+ return objetFils.getObjetByMCPath(MCPath[2:])
+ return objetFils.getObjetByMCPath(MCPath[1:])
+
+ def getGenealogie(self):
+ """
+ Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC
+ ou ETAPE) de self jusqu'au premier objet etape rencontre
+ """
+ if self.parent:
+ l = self.parent.getGenealogie()
+ l.append(self.nom.strip())
+ return l
+ else:
+ return [self.nom.strip()]
+
+ def getFr(self):
+ """
+ Retourne la chaine d'aide contenue dans le catalogue
+ en tenant compte de la langue
+ """
+ try:
+ # if 1 :
+ c = getattr(self.definition, self.jdc.lang)
+ return c
+ except:
+ # else:
+ try:
+ c = getattr(self.definition, "fr")
+ return c
+ except:
+ return ""
+
+ def updateConcept(self, sd):
+ pass
+
+ def normalize(self):
+ """Retourne l'objet normalise. En general self sauf si
+ pour etre insere dans l'objet pere il doit etre
+ wrappe dans un autre objet (voir mot cle facteur).
+ """
+ return self
+
+ def deleteMcGlobal(self):
+ return
+
+ def updateMcGlobal(self):
+ return
+
+ # def __del__(self):
+ # print "__del__",self
+
+ def nommeSd(self):
+ # surcharge dans A_ETAPE.py
+ if nom in dir(self.jdc.cata):
+ return (0, nom + tr("mot reserve"))
+ if not conceptRE.match(nom):
+ return 0, tr("Un nom de concept doit etre un identificateur Python")
+ self.initModif()
+ # self.getSdProd()
+ # self.sd.nom = nom
+ # self.sdnom=nom
+ # self.parent.updateConceptAfterEtape(self,self.sd)
+ # self.finModif()
+ # return 1, tr("Nommage du concept effectue")
+
+ def deleteRef(self):
+ # est surcharge dans MC_SIMP et dans MC_List
+ # print ('je suis dans deleteRef pour', self.nom)
+ for obj in self.mcListe:
+ obj.deleteRef()
+
+ def supprimeUserAssd(self):
+ pass
+
+ def getDicoForFancy(self):
+ # print ('OBJECT getDicoForFancy ',self, self.nature)
+ monDico = {}
+ leNom = self.nom
+
+ if self.nature == "MCFACT":
+ leNom = self.getLabelText()
+ monDico["statut"] = self.definition.statut
+ monDico["nomCommande"] = self.nom
+
+ if self.nature == "MCLIST":
+ monDico["validite"] = 0
+ elif self.nature == "MCBLOC":
+ monDico["validite"] = 0
+ else:
+ monDico["validite"] = self.getValid()
+ if monDico["validite"] == None:
+ monDico["validite"] = 0
+
+ if self.nature == "OPERATEUR" or self.nature == "PROCEDURE":
+ monDico["statut"] = "f"
+ if self.nature == "OPERATEUR":
+ if hasattr(self, "sdnom") and self.sdnom != "sansnom":
+ monDico["sdnom"] = self.sdnom
+ else:
+ monDico["sdnom"] = ""
+ if monDico["validite"] == 0:
+ monDico["validite"] = 2
+ monDico["title"] = leNom
+ monDico["key"] = self.idUnique
+ monDico["classeAccas"] = self.nature
+
+ listeNodes = []
+ # Cas d un fichier vide
+ if not hasattr(self, "mcListe"):
+ self.mcListe = []
+ for obj in self.mcListe:
+ lesNodes = obj.getDicoForFancy()
+ if not (isinstance(lesNodes, list)):
+ listeNodes.append(lesNodes)
+ else:
+ for leNode in lesNodes:
+ listeNodes.append(leNode)
+ monDico["children"] = listeNodes
+ print (self.nature)
+ if self.nature != "MCSIMP" and self.nature != "MCLIST" and self.nature != "JDC":
+ monDico["infoOptionnels"] = self.calculOptionnelInclutBlocs()
+ return monDico
+
+ def getNomClassWeb(self):
+ # code mort
+ laClasse = self.nature
+ if self.isValid():
+ laClasse += "Valide"
+ else:
+ laClasse += "NonValide"
+ return laClasse
+
+ def demandeUpdateOptionnels(self):
+ CONNECTOR.Emit(self, "demandeUpdateOptionnels")
+ for mc in self.mcListe:
+ mc.demandeUpdateOptionnels()
+ def demandeRedessine(self):
+ # print ('demandeRedessine pour', self.nom, self, tout)
+ CONNECTOR.Emit(self, "redessine")
+
+ def getIndexDsParent(self):
+ return self.parent.mcListe.index(self)
+
+
+class ErrorObj(OBJECT):
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+
+from Accas.accessor import A_REGLE
+
+
+class PRESENT_ABSENT(A_REGLE.REGLE):
+ def purgeListe(self, liste_a_purger, listeMcPresents):
+ regle_active = 0
+ if self.mcs[0] in listeMcPresents:
+ regle_active = 1
+ if not regle_active:
+ return liste_a_purger
+
+ # Il ne faut pas purger le mot cle present
+ for mc in self.mcs[1:]:
+ if mc in liste_a_purger:
+ liste_a_purger.remove(mc)
+ return liste_a_purger
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+
+from Accas.accessor import A_REGLE
+
+
+class PRESENT_PRESENT(A_REGLE.REGLE):
+ def verifConditionRegle(self, liste, l_mc_presents):
+ mc0 = self.mcs[0]
+ for mc_present in l_mc_presents:
+ if mc_present == mc0:
+ for mc in self.mcs[1:]:
+ nb = l_mc_presents.count(mc)
+ if nb == 0:
+ liste.append(mc)
+ return liste
+ return liste
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.accessor import A_ETAPE
+
+
+# import rajoutes suite a l'ajout de buildSd --> a resorber
+import sys
+import traceback, types
+from Accas.processing import P_PROC_ETAPE
+from Accas.processing import P_Exception
+from Accas.processing.P_Exception import AsException
+from Accas.extensions.eficas_exception import EficasException
+
+
+class PROC_ETAPE(A_ETAPE.ETAPE):
+ def getSdname(self):
+ return ""
+
+ def getSdprods(self, nom_sd):
+ """
+ Fonction : retourne le concept produit par l etape de nom nom_sd
+ s il existe sinon None
+ Une PROC ne produit aucun concept
+ """
+ return None
+
+ def supprimeSdProds(self):
+ """
+ Fonction: Lors d'une destruction d'etape, detruit tous les concepts produits
+ Une procedure n'en a aucun
+ """
+ return
+
+ def deleteConcept(self, sd):
+ """
+ Fonction : Mettre a jour les mots cles de l etape
+ suite a la disparition du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
+
+ Inputs :
+ - sd=concept detruit
+ """
+ for child in self.mcListe:
+ child.deleteConcept(sd)
+
+ def replaceConcept(self, old_sd, sd):
+ """
+ Fonction : Mettre a jour les mots cles de l etape
+ suite au remplacement du concept old_sd
+
+ Inputs :
+ - old_sd=concept remplace
+ - sd=nouveau concept
+ """
+ for child in self.mcListe:
+ child.replaceConcept(old_sd, sd)
+
+ def getMCPath(self):
+ index = self.jdc.getIndex(self)
+ return [self.nom, "@index " + str(index) + " @"]
+
+ def delieIncertitude(self):
+ mcVP = self.getChild("Input").getChild("VariableProbabiliste")
+ for vp in mcVP:
+ vp.variableDeterministe.variableProbabilite = None
+ vp.variableDeterministe.associeVariableUQ = False
+ vp.variableDeterministe.definition.siValide = None
+
+ # ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
+ def buildSd(self):
+ """
+ Mmethode de processing surchargee pour poursuivre malgre tout
+ si une erreur se produit pendant la creation du concept produit
+ """
+ try:
+ sd = P_PROC_ETAPE.PROC_ETAPE.buildSd(self)
+ except AsException:
+ # Une erreur s'est produite lors de la construction du concept
+ # Comme on est dans EFICAS, on essaie de poursuivre quand meme
+ # Si on poursuit, on a le choix entre deux possibilites :
+ # 1. on annule la sd associee a self
+ # 2. on la conserve mais il faut la retourner
+ # En plus il faut rendre coherents sdnom et sd.nom
+ self.sd = None
+ self.sdnom = None
+ self.state = "unchanged"
+ self.valid = 0
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+
+
+class REGLE:
+ def getText(self):
+ text = self.__class__.__name__ + " :\n"
+ for mc in self.mcs:
+ text = text + "\t" + mc.strip() + "\n"
+ return text
+
+ def purgeListe(self, liste_a_purger, listeMcPresents):
+ """
+ Cette methode doit retirer de la liste liste_a_purger
+ les elements qui ne doivent plus apparaitre en fonction du contexte
+ """
+ # Dans le cas general on ne touche pas a la liste
+ return liste_a_purger
+
+ def hasOperande(self, nom):
+ # On peut faire aussi try:self.mcs.index(nom);return 1;except:return 0
+ for mc in self.mcs:
+ if mc == nom:
+ return 1
+ return 0
+
+ def verifConditionRegle(self, liste, l_mc_presents):
+ return []
+
+
+# def enregistreXML(self,root,catalogueXml):
+# import xml.etree.ElementTree as ET
+# regleXml=ET.SubElement(root,'regles')
+# txt=""
+# for mot in self.getText().split('\n'):
+# mot.replace(' ','')
+# txt=txt + mot + " "
+# regleXml.text= txt
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+
+class A_Matrice:
+ def activeCouleur(self):
+ self.dictCouleurs = {}
+ self.indiceCouleur = 1
+ self.listeCouleurs = (
+ (10, 186, 181),
+ (204, 204, 255),
+ (121, 248, 248),
+ (254, 231, 240),
+ (250, 234, 115),
+ (254, 191, 210),
+ (248, 142, 85),
+ (133, 193, 126),
+ (210, 202, 236),
+ (225, 206, 154),
+ (187, 174, 152),
+ (240, 195, 0),
+ (242, 255, 255),
+ (239, 239, 239),
+ (149, 165, 149),
+ (150, 131, 236),
+ (201, 160, 220),
+ (103, 159, 90),
+ (176, 242, 182),
+ (233, 201, 177),
+ )
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+
+from Accas.accessor import A_REGLE
+
+
+class UN_PARMI(A_REGLE.REGLE):
+ def purgeListe(self, liste_a_purger, listeMcPresents):
+ regle_active = 0
+ for mc_present in listeMcPresents:
+ if mc_present in self.mcs:
+ regle_active = 1
+ break
+ if not regle_active:
+ return liste_a_purger
+
+ # Si un des mots cles est present, on les enleve tous
+ # sauf celui ci
+ for mc in self.mcs:
+ if mc in liste_a_purger and mc not in listeMcPresents:
+ liste_a_purger.remove(mc)
+ return liste_a_purger
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from Accas.processing.P_VALIDATOR import *
+
+
+class Compulsory(Compulsory):
+ def hasInto(self):
+ return 0
+
+ def valideListePartielle(self, liste_courante=None):
+ return 1
+
+
+class OrdList(OrdList):
+ def valideListePartielle(self, liste_courante=None):
+ """
+ Methode de Accas.validation de liste partielle pour le validateur OrdList
+ """
+ try:
+ self.convert(liste_courante)
+ valid = 1
+ except:
+ valid = 0
+ return valid
+
+
+class compareAutreMC(Valid):
+ # ----------------------------
+ def __init__(self, frere=None):
+ Valid.__init__(self, frere=frere)
+ self.nomFrere = frere
+
+ def set_MCSimp(self, MCSimp):
+ debug = 1
+ if debug:
+ print("je passe la pour ", self, MCSimp.nom)
+ self.MCSimp = MCSimp
+
+
+class infFrereMC(compareAutreMC):
+ # -------------------------------
+ def convert(self, valeur):
+ # on sort de cardProto on a une liste
+ valeur = valeur[0]
+ try:
+ MCFrere = self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ except:
+ return valeur
+ if not MCFrere:
+ return valeur
+ if MCFrere == None:
+ return valeur
+ if MCFrere.valeur == None:
+ return valeur
+ if MCFrere.valeur < valeur:
+ raise CataError(
+ "la valeur de " + self.nomFrere + " est inferieure a la valeur entree "
+ )
+ return valeur
+
+ def verifItem(self, valeur):
+ try:
+ MCFrere = self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ except:
+ return valeur
+ if not MCFrere:
+ return valeur
+ if MCFrere == None:
+ return valeur
+ if MCFrere.valeur == None:
+ return valeur
+ if MCFrere.valeur < valeur:
+ raise CataError(
+ "la valeur de "
+ + self.nomFrere
+ + " est inferieure a la valeur entree et doit etre superieure"
+ )
+ return 0
+ return 1
+
+ def infoErreurItem(self, valeur):
+ return (
+ "la valeur de "
+ + self.nomFrere
+ + " est inferieure a la valeur entree et doit etre superieure"
+ )
+
+ def info(self):
+ return (
+ "la valeur de "
+ + self.nomFrere
+ + " est inferieure a la valeur entree et doit etre superieure"
+ )
+
+
+class supFrereMC(compareAutreMC):
+ # --------------------------------
+ def convert(self, valeur):
+ # on sort de cardProto on a une liste
+ valeur = valeur[0]
+ MCFrere = self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ if not MCFrere:
+ return valeur
+ if MCFrere == None:
+ return valeur
+ if MCFrere.valeur > valeur:
+ raise CataError(
+ "la valeur de "
+ + self.nomFrere
+ + " est superieure a la valeur entree et doit etre inferieure"
+ )
+ return valeur
+
+ def verifItem(self, valeur):
+ MCFrere = self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ if not MCFrere:
+ return 1
+ if MCFrere == None:
+ return 1
+ if MCFrere.valeur > valeur:
+ raise CataError(
+ "la valeur de "
+ + self.nomFrere
+ + " est superieure a la valeur entree et doit etre inferieure"
+ )
+ return 0
+ return 1
+
+ def infoErreurItem(self, valeur):
+ return (
+ "la valeur de "
+ + self.nomFrere
+ + " est superieure a la valeur entree et doit etre inferieure"
+ )
+
+ def info(self):
+ return "la valeur de " + self.nomFrere + " est superieure a la valeur entree "
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+# Installation de tous les fichiers Python du repertoire et des sous-repertoires (sauf CVS)
+install ( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ DESTINATION ${CMAKE_INSTALL_PREFIX}
+ FILES_MATCHING PATTERN *.py
+ PATTERN CVS EXCLUDE
+ )
+
+
+### Local Variables:
+### mode: cmake
+### End:
--- /dev/null
+# i -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ La classe CONNECTOR sert a enregistrer les observateurs d'objets et a delivrer
+ les messages emis a ces objets.
+
+ Le principe general est le suivant : un objet (subscriber) s'enregistre aupres du
+ connecteur global (theconnector) pour observer un objet emetteur de messages (publisher)
+ sur un canal donne (channel). Il demande a etre notifie par appel d'une fonction (listener).
+ La sequence est donc :
+
+ - enregistrement du subscriber pour le publisher : theconnector.Connect(publisher,channel,listener,args)
+ - emission du message par le publisher : theconnector.Emit(publisher,channel,cargs)
+
+ args et cargs sont des tuples contenant les arguments de la fonction listener qui sera appelee
+ comme suit::
+
+ listener(cargs+args)
+"""
+import traceback
+from copy import copy
+import weakref
+
+
+class ConnectorError(Exception):
+ pass
+
+
+class CONNECTOR:
+ def __init__(self):
+ self.connections = {}
+
+ def Connect(self, object, channel, function, args):
+ # print ("Connect",object, channel, function, args)
+ idx = id(object)
+ # if self.connections.has_key(idx):
+ if idx in self.connections:
+ channels = self.connections[idx]
+ else:
+ channels = self.connections[idx] = {}
+
+ # if channels.has_key(channel):
+ if channel in channels:
+ receivers = channels[channel]
+ else:
+ receivers = channels[channel] = []
+
+ for funct, fargs in receivers[:]:
+ if funct() is None:
+ receivers.remove((funct, fargs))
+ elif (function, args) == (funct(), fargs):
+ receivers.remove((funct, fargs))
+
+ receivers.append((ref(function), args))
+
+ def Disconnect(self, object, channel, function, args):
+ try:
+ receivers = self.connections[id(object)][channel]
+ except KeyError:
+ raise ConnectorError(
+ "no receivers for channel %s of %s" % (channel, object)
+ )
+
+ for funct, fargs in receivers[:]:
+ if funct() is None:
+ receivers.remove((funct, fargs))
+
+ for funct, fargs in receivers:
+ if (function, args) == (funct(), fargs):
+ receivers.remove((funct, fargs))
+ if not receivers:
+ # the list of receivers is empty now, remove the channel
+ channels = self.connections[id(object)]
+ del channels[channel]
+ if not channels:
+ # the object has no more channels
+ del self.connections[id(object)]
+ return
+
+ raise ConnectorError(
+ "receiver %s%s is not connected to channel %s of %s"
+ % (function, args, channel, object)
+ )
+
+ def Emit(self, object, channel, *args):
+ # print "Emit",object, channel, args
+ try:
+ receivers = self.connections[id(object)][channel]
+ except KeyError:
+ return
+ # print "Emit",object, channel, receivers
+ # Attention : copie pour eviter les pbs lies aux deconnexion reconnexion
+ # pendant l'execution des emit
+ for rfunc, fargs in copy(receivers):
+ try:
+ func = rfunc()
+ if func:
+ # print (func,args,fargs)
+ # rint args + fargs
+ # apply(func, args + fargs)
+ if args + fargs == ():
+ func()
+ else:
+ func(args + fargs)
+ else:
+ # Le receveur a disparu
+ if (rfunc, fargs) in receivers:
+ receivers.remove((rfunc, fargs))
+ except:
+ traceback.print_exc()
+
+
+def ref(target, callback=None):
+ # if hasattr(target,"im_self"):
+ # return BoundMethodWeakref(target)
+ if hasattr(target, "__self__"):
+ return BoundMethodWeakref(target)
+ else:
+ return weakref.ref(target, callback)
+
+
+class BoundMethodWeakref(object):
+ def __init__(self, callable):
+ # self.Self=weakref.ref(callable.im_self)
+ # self.Func=weakref.ref(callable.im_func)
+ self.Self = weakref.ref(callable.__self__)
+ self.Func = weakref.ref(callable.__func__)
+
+ def __call__(self):
+ target = self.Self()
+ if not target:
+ return None
+ func = self.Func()
+ if func:
+ return func.__get__(self.Self())
+
+
+_the_connector = CONNECTOR()
+Connect = _the_connector.Connect
+Emit = _the_connector.Emit
+Disconnect = _the_connector.Disconnect
+
+if __name__ == "__main__":
+
+ class A:
+ pass
+
+ class B:
+ def add(self, a):
+ print(("--------------------------------add ", self, a))
+
+ def __del__(self):
+ print(("__del__", self))
+
+ def f(a):
+ print((f, a))
+
+ a = A()
+ b = B()
+ c = B()
+
+ Connect(a, "add", b.add, ())
+ Connect(a, "add", b.add, ())
+ Connect(a, "add", c.add, ())
+ Connect(a, "add", f, ())
+
+ Emit(a, "add", 1)
+
+ print("del b")
+ del b
+
+ Emit(a, "add", 1)
+ print("del f")
+ del f
+
+ Emit(a, "add", 1)
+ Disconnect(a, "add", c.add, ())
+ Emit(a, "add", 1)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce package contient les fonctionnalites supplementaires necessaires
+ pour l'editeur graphique EFICAS
+"""
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from Accas.accessor import A_ASSD
+from Accas.accessor import A_LASSD
+from Accas.accessor import A_FONCTION
+from Accas.processing import P_ASSD
+from Accas.processing import P_GEOM
+from Accas.processing import P_FONCTION
+from Accas.processing import P_CO
+from Accas.processing import P_UserASSD
+from Accas.processing import P_UserASSDMultiple
+
+# On ajoute la classe ASSD dans l'heritage multiple pour recreer
+# une hierarchie d'heritage identique a celle de Noyau
+# pour faire en sorte que isinstance(o,ASSD) marche encore apres
+# derivation
+
+
+class ASSD(A_ASSD.ASSD, P_ASSD.ASSD):
+ pass
+
+
+# class LASSD(A_LASSD.LASSD,N_LASSD.LASSD):pass
+class LASSD(A_LASSD.LASSD):
+ pass
+
+
+class UserASSD(P_UserASSD.UserASSD, ASSD):
+ pass
+
+
+class UserASSDMultiple(P_UserASSDMultiple.UserASSDMultiple, UserASSD):
+ pass
+
+
+class assd(P_ASSD.assd, A_ASSD.assd, ASSD):
+ pass
+
+
+class FONCTION(P_FONCTION.FONCTION, A_FONCTION.FONCTION, ASSD):
+ def __init__(self, etape=None, sd=None, reg="oui"):
+ P_FONCTION.FONCTION.__init__(self, etape=etape, sd=sd, reg=reg)
+ A_FONCTION.FONCTION.__init__(self, etape=etape, sd=sd, reg=reg)
+
+
+class formule(A_FONCTION.formule, P_FONCTION.formule, ASSD):
+ def __init__(self, etape=None, sd=None, reg="oui"):
+ P_FONCTION.formule.__init__(self, etape=etape, sd=sd, reg=reg)
+ A_FONCTION.formule.__init__(self, etape=etape, sd=sd, reg=reg)
+
+
+class formule_c(formule):
+ pass
+
+
+# On conserve fonction (ceinture et bretelles)
+# fonction n'existe plus dans P_FONCTION on le remplace par formule
+class fonction(P_FONCTION.formule, A_FONCTION.fonction, ASSD):
+ """obsolete class : use formule instead"""
+
+ def __init__(self, etape=None, sd=None, reg="oui"):
+ P_FONCTION.formule.__init__(self, etape=etape, sd=sd, reg=reg)
+ A_FONCTION.fonction.__init__(self, etape=etape, sd=sd, reg=reg)
+
+
+class GEOM(P_GEOM.GEOM, A_ASSD.GEOM, ASSD):
+ pass
+
+
+class geom(P_GEOM.geom, A_ASSD.geom, ASSD):
+ pass
+
+
+class CO(P_CO.CO, A_ASSD.CO, ASSD):
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.validation import V_AU_MOINS_UN
+from Accas.accessor import A_REGLE
+
+
+class AU_MOINS_UN(V_AU_MOINS_UN.AU_MOINS_UN, A_REGLE.REGLE, P_REGLE.REGLE):
+ """
+ Accas.classes class for catalog rule AU_MOINS_UN
+ __init__ is in P_REGLE.REGLE
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.validation import V_AU_PLUS_UN
+from Accas.accessor import A_REGLE
+
+
+class AU_PLUS_UN(V_AU_PLUS_UN.AU_PLUS_UN, A_REGLE.REGLE, P_REGLE.REGLE):
+ """
+ Accas.classes class for catalog rule AU_PLUS_UN
+ class instantiation automatically invokes REGLE.__init__()
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.accessor import A_REGLE, A_AVANT
+
+
+class AVANT(A_AVANT.A_AVANT, A_REGLE.REGLE, P_REGLE.REGLE):
+ """
+ Accas.classes class for catalog rule AVANT
+ class instantiation automatically invokes REGLE.__init__()
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.validation import V_A_CLASSER
+from Accas.accessor import A_A_CLASSER
+
+
+class A_CLASSER(V_A_CLASSER.A_CLASSER, P_REGLE.REGLE, A_A_CLASSER.A_CLASSER):
+ """
+ Accas.classes class for catalog rule C_CLASSER
+ It is absolutely necessary that V_A_CLASSER be first in the inheritance
+ """
+
+ # to do --> prevoir un X_A_CLASSER pour la projection XSD
+ # Est-ce possible en 1ere passe ou faut-il modifier pendant une 2nd passe ?
+ # ajouter une methode dump a tous les objets ?
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_BLOC
+from Accas.accessor import A_ENTITE
+from Accas.classes import C_MCBLOC
+from Efi2Xsd.AccasXsd import X_BLOC
+
+
+class BLOC(P_BLOC.BLOC, X_BLOC, A_ENTITE.ENTITE):
+ """
+ Accas.classes class for catalog definition keyword BLOC
+ """
+
+ class_instance = C_MCBLOC.MCBLOC
+
+ def __init__(self, *tup, **args):
+ A_ENTITE.ENTITE.__init__(self)
+ P_BLOC.BLOC.__init__(self, *tup, **args)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.validation import V_ENSEMBLE
+from Accas.accessor import A_REGLE
+
+
+class ENSEMBLE(A_REGLE.REGLE, V_ENSEMBLE.ENSEMBLE, P_REGLE.REGLE):
+ """
+ Accas.classes class for catalog rule ENSEMBLE
+ class instantiation automatically invokes REGLE.__init__()
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_ETAPE
+from Accas.validation import V_ETAPE
+from Accas.accessor import A_ETAPE
+from Efi2Xsd.MCAccasXML import X_ETAPE
+
+
+class ETAPE(A_ETAPE.ETAPE, V_ETAPE.ETAPE, X_ETAPE, P_ETAPE.ETAPE):
+ """
+ parent class for PROC, MACRO and OPER (JDD object)
+ """
+
+ def __init__(self, oper=None, reuse=None, args={}):
+ P_ETAPE.ETAPE.__init__(self, oper, reuse, args)
+ V_ETAPE.ETAPE.__init__(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.accessor import A_EVAL
+
+
+class EVAL(A_EVAL.EVAL):
+ """
+ class used to evaluate parameter
+ """
+
+ def __init__(self, str):
+ A_EVAL.EVAL.__init__(self, str)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.validation import V_EXCLUS
+from Accas.accessor import A_EXCLUS
+
+
+class EXCLUS(A_EXCLUS.EXCLUS, V_EXCLUS.EXCLUS, P_REGLE.REGLE):
+ """
+ Accas.classes class for catalog rule EXCLUS
+ class instantiation automatically invokes REGLE.__init__()
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_FACT
+from Accas.accessor import A_ENTITE
+from Accas.classes import C_MCFACT
+from Accas.classes import C_MCLIST
+from Efi2Xsd.AccasXsd import X_FACT
+
+
+class FACT(P_FACT.FACT, X_FACT, A_ENTITE.ENTITE):
+ """
+ Accas.classes class for catalog definition keyword FACT
+ """
+
+ class_instance = C_MCFACT.MCFACT
+ list_instance = C_MCLIST.MCList
+
+ def __init__(self, *tup, **args):
+ A_ENTITE.ENTITE.__init__(self)
+ P_FACT.FACT.__init__(self, *tup, **args)
+
+
+from Accas.processing import P_OBJECT
+from Accas.accessor import A_OBJECT
+
+
+class ErrorObj(A_OBJECT.ErrorObj, P_OBJECT.ErrorObj):
+ pass
+
+
+P_OBJECT.ErrorObj = ErrorObj
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.accessor import A_FICHIER
+
+
+class Fichier(A_FICHIER.Fichier):
+ """
+ This empty class is replaced by the class eficas.SalomeEntry
+ (defined in Salome EFICAS module) when Eficas is launched in Salome context.
+ It handles the objects that can be selected from Salome object browser.
+ """
+
+ def __init__(self, *tup, **args):
+ A_FICHIER.FICHIER.__init__(self, *tup, **args)
+
+ # To do --> a travailler pour ajouter tous les types de fichier (existant ou non, avec un chemin relatif pour etre vraiment utilise hors salome
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_FORM
+from Accas.accessor import A_ENTITE
+from Accas.classes import C_FORM_ETAPE
+
+
+class FORM(P_FORM.FORM, A_ENTITE.ENTITE):
+ """
+ Accas.classes class for catalog definition keyword FORMULE
+ """
+
+ class_instance = C_FORM_ETAPE.FORM_ETAPE
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from Accas.processing import P_FORM_ETAPE
+from Accas.validation import V_MACRO_ETAPE
+from Accas.accessor import A_FORM_ETAPE
+
+
+class FORM_ETAPE(
+ A_FORM_ETAPE.FORM_ETAPE, V_MACRO_ETAPE.MACRO_ETAPE, P_FORM_ETAPE.FORM_ETAPE
+):
+ """
+ specific class for Aster FORM_ETAPE
+ most likely as MACRO
+ """
+
+ def __init__(self, oper=None, reuse=None, args={}):
+ P_FORM_ETAPE.FORM_ETAPE.__init__(self, oper, reuse, args)
+ V_MACRO_ETAPE.MACRO_ETAPE.__init__(self)
+ A_FORM_ETAPE.FORM_ETAPE.__init__(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_JDC
+from Accas.validation import V_JDC
+from Accas.extensions import jdc
+from Accas.accessor import A_JDC
+from Efi2Xsd.MCAccasXML import X_JDC
+
+
+class JDC(jdc.JDC, A_JDC.JDC, X_JDC, V_JDC.JDC, P_JDC.JDC):
+ """
+ parent class for dataset object (JDC)
+ """
+
+
+ def __init__(self, *pos, **args):
+ P_JDC.JDC.__init__(self, *pos, **args)
+ X_JDC.__init__(self)
+ V_JDC.JDC.__init__(self)
+ A_JDC.JDC.__init__(self)
+ jdc.JDC.__init__(self)
+ self.icmd = 0
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.classes import C_JDC
+from Accas.processing import P_JDC_CATA
+from Accas.accessor import A_JDC_CATA
+from Efi2Xsd.AccasXsd import X_JDC_CATA
+
+
+class JDC_CATA(A_JDC_CATA.JDC_CATA, P_JDC_CATA.JDC_CATA, X_JDC_CATA):
+ """
+ Accas.classes class that defines a catalog object that is object which will be used
+ to control conformity of the dataset with its definition
+ """
+
+ class_instance = C_JDC.JDC
+
+ def __init__(self, *pos, **kw):
+ # print (pos)
+ # print (kw)
+ P_JDC_CATA.JDC_CATA.__init__(self, *pos, **kw)
+ A_JDC_CATA.JDC_CATA.__init__(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from Accas.processing.P_utils import Singleton
+from Accas import JDC_CATA
+
+
+class JDC_CATA_SINGLETON(Singleton, JDC_CATA):
+ """
+ class used for defining catalogs which can be either standalone
+ either imported by another catalog
+ the steps are recorded in the correct JDC_CATA
+ """
+
+ def __init__(self, *pos, **kw):
+ if hasattr(self, "initialised"):
+ return
+ self.initialised = True
+ JDC_CATA.__init__(self, *pos, **kw)
+
+ # to do : reflechir pour les imports des drivers a utiliser le nom du code
+ # de maniere a pour pourvoir utiliser n importe lequel des driver pour lire
+ # le XML
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_MACRO
+from Accas.accessor import A_ENTITE
+from Accas.classes import C_MACRO_ETAPE
+
+
+class MACRO(P_MACRO.MACRO, A_ENTITE.ENTITE):
+ """
+ parent class of MACRO definition
+ unused class that could/should be reactivated
+ """
+
+ class_instance = C_MACRO_ETAPE.MACRO_ETAPE
+
+ def __init__(self, *tup, **args):
+ A_ENTITE.ENTITE.__init__(self)
+ P_MACRO.MACRO.__init__(self, *tup, **args)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_MACRO_ETAPE
+from Accas.validation import V_MACRO_ETAPE
+from Accas.accessor import A_MACRO_ETAPE
+from Accas.classes.C_ASSD import CO
+from Efi2Xsd.MCAccasXML import X_MCCOMPO
+
+
+class MACRO_ETAPE(
+ A_MACRO_ETAPE.MACRO_ETAPE,
+ X_MCCOMPO,
+ V_MACRO_ETAPE.MACRO_ETAPE,
+ P_MACRO_ETAPE.MACRO_ETAPE,
+):
+ """
+ parent class of MACRO objects
+ unused class that could/should be reactivated
+ a macro is a set of command
+ differs from step (PROC or OPER) for supervision
+ """
+
+ typeCO = CO
+
+ def __init__(self, oper=None, reuse=None, args={}):
+ P_MACRO_ETAPE.MACRO_ETAPE.__init__(self, oper, reuse, args)
+ V_MACRO_ETAPE.MACRO_ETAPE.__init__(self)
+ A_MACRO_ETAPE.MACRO_ETAPE.__init__(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_MCBLOC
+from Accas.validation import V_MCBLOC
+from Accas.accessor import A_MCBLOC
+from Efi2Xsd.MCAccasXML import X_MCBLOC
+
+
+class MCBLOC(A_MCBLOC.MCBLOC, P_MCBLOC.MCBLOC, X_MCBLOC, V_MCBLOC.MCBLOC):
+ """
+ class of BLOC objet
+ """
+
+ def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction=None):
+ P_MCBLOC.MCBLOC.__init__(
+ self,
+ val,
+ definition,
+ nom,
+ parent,
+ dicoPyxbDeConstruction=dicoPyxbDeConstruction,
+ )
+ V_MCBLOC.MCBLOC.__init__(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_MCFACT
+from Accas.validation import V_MCFACT
+from Accas.accessor import A_MCFACT
+from Efi2Xsd.MCAccasXML import X_MCFACT
+
+
+class MCFACT(A_MCFACT.MCFACT, P_MCFACT.MCFACT, X_MCFACT, V_MCFACT.MCFACT):
+ """
+ class of FACT object (MCFACT = mot clef FACTEUR)
+ """
+
+ def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction=None):
+ P_MCFACT.MCFACT.__init__(
+ self,
+ val,
+ definition,
+ nom,
+ parent,
+ dicoPyxbDeConstruction=dicoPyxbDeConstruction,
+ )
+ V_MCFACT.MCFACT.__init__(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+# ======================================================================
+from Accas.processing import P_MCLIST
+from Accas.validation import V_MCLIST
+from Accas.accessor import A_MCLIST
+from Efi2Xsd.MCAccasXML import X_MCLIST
+
+
+class MCList(A_MCLIST.MCList, P_MCLIST.MCList, X_MCLIST, V_MCLIST.MCList):
+ """
+ class of keywords which are also lists
+ overload the python list class
+ """
+
+ def __init__(self):
+ P_MCLIST.MCList.__init__(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.extensions import mcnuplet
+from Accas.accessor import A_MCCOMPO
+
+
+class MCNUPLET(mcnuplet.MCNUPLET, A_MCCOMPO.MCCOMPO):
+ def __init__(self, *pos, **args):
+ mcnuplet.MCNUPLET.__init__(self, *pos, **args)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_MCSIMP
+from Accas.validation import V_MCSIMP
+from Accas.accessor import A_MCSIMP
+from Efi2Xsd.MCAccasXML import X_MCSIMP
+
+
+class MCSIMP(A_MCSIMP.MCSIMP, P_MCSIMP.MCSIMP, X_MCSIMP, V_MCSIMP.MCSIMP):
+ """
+ class for SIMP object (MCSIMP = mot clef simp)
+ """
+
+ def __init__(self, val, definition, nom, parent, objPyxbDeConstruction=None):
+ # le defaut de objPyxbDeConstruction permet de lire les comm
+ # avec des modeles sans equivalent XSD
+ P_MCSIMP.MCSIMP.__init__(
+ self, val, definition, nom, parent, objPyxbDeConstruction
+ )
+ V_MCSIMP.MCSIMP.__init__(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.validation import V_MEME_NOMBRE
+from Accas.accessor import A_REGLE
+
+
+class MEME_NOMBRE(V_MEME_NOMBRE.MEME_NOMBRE, A_REGLE.REGLE, P_REGLE.REGLE):
+ """
+ Accas.classes class for catalog rule MEME_NOMBRE
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.extensions import nuplet
+from Accas.classes import C_MCLIST
+from Accas.classes import C_MCNUPLET
+
+
+class NUPL(nuplet.NUPL):
+ class_instance = C_MCNUPLET.MCNUPLET
+ list_instance = C_MCLIST.MCList
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_OPER
+from Accas.accessor import A_ENTITE
+from Accas.classes import C_ETAPE
+from Efi2Xsd.AccasXsd import X_OPER
+
+
+class OPER(P_OPER.OPER, X_OPER, A_ENTITE.ENTITE):
+ """
+ Accas.classes class for catalog definition keyword OPER
+ """
+
+ class_instance = C_ETAPE.ETAPE
+
+ def __init__(self, *tup, **args):
+ A_ENTITE.ENTITE.__init__(self)
+ P_OPER.OPER.__init__(self, *tup, **args)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.validation import V_PRESENT_ABSENT
+from Accas.accessor import A_PRESENT_ABSENT
+
+
+class PRESENT_ABSENT(
+ A_PRESENT_ABSENT.PRESENT_ABSENT, V_PRESENT_ABSENT.PRESENT_ABSENT, P_REGLE.REGLE
+):
+ """
+ Accas.classes class for catalog rule PRESENT_ABSENT
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.validation import V_PRESENT_PRESENT
+from Accas.accessor import A_PRESENT_PRESENT
+
+
+class PRESENT_PRESENT(
+ A_PRESENT_PRESENT.PRESENT_PRESENT, V_PRESENT_PRESENT.PRESENT_PRESENT, P_REGLE.REGLE
+):
+ """
+ Accas.classes class for catalog rule PRESENT_PRESENT
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_PROC
+from Accas.accessor import A_ENTITE
+from Accas.classes import C_PROC_ETAPE
+from Efi2Xsd.AccasXsd import X_PROC
+
+
+class PROC(P_PROC.PROC, X_PROC, A_ENTITE.ENTITE):
+ """
+ Accas.classes class for catalog definition keyword PROC
+ """
+
+ class_instance = C_PROC_ETAPE.PROC_ETAPE
+
+ def __init__(self, *tup, **args):
+ # print (tup)
+ # print (args)
+ A_ENTITE.ENTITE.__init__(self)
+ P_PROC.PROC.__init__(self, *tup, **args)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_PROC_ETAPE
+from Accas.validation import V_PROC_ETAPE
+from Accas.accessor import A_PROC_ETAPE
+from Efi2Xsd.MCAccasXML import X_MCCOMPO
+
+
+class PROC_ETAPE(
+ A_PROC_ETAPE.PROC_ETAPE, V_PROC_ETAPE.PROC_ETAPE, X_MCCOMPO, P_PROC_ETAPE.PROC_ETAPE
+):
+ """
+ Accas.classes class for dataset object PROC_ETAPE
+ """
+
+ def __init__(self, oper=None, args={}):
+ P_PROC_ETAPE.PROC_ETAPE.__init__(self, oper=oper, args=args)
+ V_PROC_ETAPE.PROC_ETAPE.__init__(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+
+class SalomeEntry:
+ """
+ This empty class is replaced by the class eficas.SalomeEntry
+ (defined in Salome EFICAS module) when Eficas is launched in Salome context.
+ It handles the objects that can be selected from Salome object browser.
+ from builtins import object
+ class SalomeEntry(object):
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from Accas.accessor import A_REGLE
+from Accas.processing import P_SENSIBILITE
+
+
+class REUSE_SENSIBLE(A_REGLE.REGLE, P_SENSIBILITE.REUSE_SENSIBLE):
+ """
+ obsolete class which was used by the supervisor
+ """
+
+ pass
+
+
+class CONCEPT_SENSIBLE(A_REGLE.REGLE, P_SENSIBILITE.CONCEPT_SENSIBLE):
+ """
+ obsolete class which was used by the supervisor
+ """
+
+ pass
+
+
+class DERIVABLE(A_REGLE.REGLE, P_SENSIBILITE.DERIVABLE):
+ """
+ obsolete class which was used by the supervisor
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_SIMP
+from Accas.accessor import A_ENTITE
+from Accas.classes import C_MCSIMP
+from Efi2Xsd.AccasXsd import X_SIMP
+
+
+class SIMP(P_SIMP.SIMP, X_SIMP, A_ENTITE.ENTITE):
+ """
+ Accas.classes class for catalog definition keyword SIMP
+ """
+
+ class_instance = C_MCSIMP.MCSIMP
+
+ def __init__(self, *tup, **args):
+ # print (tup)
+ # print (args)
+ A_ENTITE.ENTITE.__init__(self)
+ P_SIMP.SIMP.__init__(self, *tup, **args)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from Accas.processing import P_TUPLE
+from Accas.accessor import A_TUPLE
+
+
+class Tuple(P_TUPLE.P_Tuple):
+ """
+ Accas.classes class for catalog definition keyword Tuple
+ """
+ pass
+
+
+class Matrice(A_TUPLE.A_Matrice, P_TUPLE.P_Matrice):
+ """
+ Accas.classes class for catalog definition keyword Matrice
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.processing import P_REGLE
+from Accas.validation import V_UN_PARMI
+from Accas.accessor import A_UN_PARMI
+
+
+class UN_PARMI(A_UN_PARMI.UN_PARMI, V_UN_PARMI.UN_PARMI, P_REGLE.REGLE):
+ """
+ Accas.classes class for catalog rule UN_PARMI
+ """
+
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas.accessor.A_VALIDATOR import *
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+# Installation de tous les fichiers Python du repertoire et des sous-repertoires (sauf CVS)
+install ( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ DESTINATION ${CMAKE_INSTALL_PREFIX}
+ FILES_MATCHING PATTERN *.py
+ PATTERN CVS EXCLUDE
+ )
+
+
+### Local Variables:
+### mode: cmake
+### End:
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
--- /dev/null
+#! /usr/bin/env python
+# -*- coding:utf-8 -*-
+# /* This file is part of MED.
+# *
+# * COPYRIGHT (C) 1999 - 2013 EDF R&D, CEA/DEN
+# * MED is free software: you can redistribute it and/or modify
+# * it under the terms of the GNU Lesser General Public License as published by
+# * the Free Software Foundation, either version 3 of the License, or
+# * (at your option) any later version.
+# *
+# * MED is distributed in the hope that it will be useful,
+# * but WITHOUT ANY WARRANTY; without even the implied warranty of
+# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# * GNU Lesser General Public License for more details.
+# *
+# * You should have received a copy of the GNU Lesser General Public License
+# * along with MED. If not, see <http://www.gnu.org/licenses/>.
+# */
+
+
+import sys
+sys.path.append('/home/A96028/Salome/V7_main/tools/install/Medfichier-307-hdf51810/lib/python2.7/site-packages')
+
+from med.medfile import *
+from med.medmesh import *
+from med.medfamily import *
+from med.medfilter import *
+
+
+def getGroupes(filename,debug=0) :
+ listeGroupes=[]
+ maa=""
+
+ dicoNumFam={}
+
+ try :
+ fid = MEDfileOpen(filename,MED_ACC_RDONLY)
+ except :
+ return ("Pb a la lecture du fichier", listeGroupes,maa)
+
+
+ # /* Lecture des infos concernant le premier maillage */
+ maa, sdim, mdim, type, desc, dtunit, sort, nstep, rep, nomcoo,unicoo = MEDmeshInfo(fid, 1)
+ if debug :
+ print "Maillage de nom : |%s| de dimension : %ld , et de type %s\n"%(maa,mdim,type)
+ print "Maillage de nom : |%s| , de dimension : %ld , et de type %s\n"%(maa,mdim,type)
+ print "\t -Dimension de l'espace : %ld\n"%(sdim)
+ print "\t -Description du maillage : %s\n"%(desc)
+ print "\t -Noms des axes : |%s|\n"%(nomcoo)
+ print "\t -Unités des axes : |%s|\n"%(unicoo)
+ print "\t -Type de repère : %s\n"%(rep)
+ print "\t -Nombre d'étape de calcul : %ld\n"%(nstep)
+ print "\t -Unité des dates : |%s|\n"%(dtunit)
+
+ # /* Lecture du nombre de familles */
+ nfam = MEDnFamily(fid,maa)
+ if debug :
+ print "Nombre de familles : %d \n"%(nfam)
+
+ # /* Lecture de chaque famille */
+ for i in xrange(0,nfam):
+
+ # /* Lecture du nombre de groupe */
+ ngro = MEDnFamilyGroup(fid,maa,i+1)
+ if debug :
+ print "Famille %d a %d groupes \n"%(i+1,ngro)
+
+ gro = MEDCHAR(MED_LNAME_SIZE*ngro+1)
+
+ nomfam,numfam,gro = MEDfamilyInfo(fid,maa,i+1,gro)
+ if debug :
+ print "Famille de nom %s et de numero %d : \n"%(nomfam,numfam)
+ print "Attributs : \n"
+
+ for j in xrange(0,ngro):
+ # print "gro = %s\n"%(gro[j*MED_LNAME_SIZE:j*MED_LNAME_SIZE+MED_LNAME_SIZE])
+ groupSplit=gro[j*MED_LNAME_SIZE:j*MED_LNAME_SIZE+MED_LNAME_SIZE]
+ groupeName="".join(groupSplit).split("\x00")[0]
+ groupeName=groupeName.replace(' ','')
+ if groupeName[0:7]=="CENTRE_" : dicoNumFam[groupeName]=numfam
+ if groupeName not in listeGroupes : listeGroupes.append(groupeName)
+
+
+ #print dicoNumFam
+ #print listeGroupes
+
+ # /* Lecture des Numeros de Familles */
+
+ nnoe, chgt, trsf = MEDmeshnEntity(fid,maa,MED_NO_DT,MED_NO_IT, MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE)
+ nufano = MEDINT(nnoe)
+ MEDmeshEntityFamilyNumberRd(fid,maa, MED_NO_DT, MED_NO_IT, MED_NODE,MED_NONE,nufano)
+ dicoNumNode={}
+ for groupe in dicoNumFam.keys():
+ famille=dicoNumFam[groupe]
+ i=0
+ while i < nufano.size():
+ if nufano[i]==famille :
+ dicoNumNode[groupe]=i+1
+ break
+ i=i+1
+
+
+ #print dicoNumNode
+ dicoCoord={}
+ for groupe in dicoNumNode.keys() :
+ flt=MEDINT(1)
+ flt[0]=dicoNumNode[groupe]
+ coo1=MEDFLOAT(3)
+ filter=med_filter()
+ err=MEDfilterEntityCr( fid, nnoe, 1, sdim, MED_ALL_CONSTITUENT, MED_FULL_INTERLACE, MED_COMPACT_PFLMODE, MED_NO_PROFILE,1 , flt, filter)
+ MEDmeshNodeCoordinateAdvancedRd(fid, maa, MED_NO_DT, MED_NO_IT, filter, coo1)
+ MEDfilterClose(filter)
+ dicoCoord[groupe]=coo1
+# dicoCoord['CENTRE_saxBas']=(0,0,28.5e-3)
+# dicoCoord['CENTRE_saxHaut']=(0,0,31.5e-3)
+
+ MEDfileClose(fid)
+ return ("",listeGroupes,maa,dicoCoord)
+
+if __name__ == "__main__":
+ filename="/home/A96028/Carmel/Pascale/Domaine_Bidouille.med"
+ #filename="/home/A96028/Carmel/nouveauMed/Domaine.med"
+ print getGroupes(filename)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from builtins import str
+import os, traceback
+import re
+
+from Accas.processing.P_CR import CR
+from Accas.processing.P_Exception import AsException
+from Accas.processing import P_OBJECT
+from Accas.accessor import A_OBJECT
+from Accas.extensions.eficas_translation import tr
+
+
+class COMMANDE_COMM(P_OBJECT.OBJECT, A_OBJECT.OBJECT):
+ """
+ Cette classe sert a definir les objets de type Commande commentarisee
+ """
+
+ nature = "COMMANDE_COMMENTARISEE"
+ idracine = "_comm"
+
+ def __init__(self, texte="", parent=None, reg="oui"):
+ self.valeur = texte
+ if not parent:
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
+ else:
+ self.jdc = self.parent = parent
+ if hasattr(self.parent, "etape"):
+ self.etape = self.parent.etape
+ else:
+ self.etape = None
+ self.definition = self
+ self.nom = ""
+ self.niveau = self.parent.niveau
+ self.actif = 1
+ self.state = "unchanged"
+ # self.appel = P_utils.calleeWhere(niveau=2)
+ if reg == "oui":
+ self.register()
+
+ def isValid(self):
+ return 1
+
+ def report(self):
+ """
+ Genere l'objet rapport (classe CR)
+ """
+ self.cr = CR()
+ if not self.isValid():
+ self.cr.warn(tr("Objet commande commentarise invalide"))
+ return self.cr
+
+ def copy(self):
+ """
+ Retourne une copie de self cad un objet COMMANDE_COMM
+ """
+ # XXX self.texte ne semble pas exister ???
+ return COMMANDE_COMM(self.texte, parent=self.parent, reg="non")
+
+ def initModif(self):
+ self.state = "modified"
+ self.parent.initModif()
+
+ def setValeur(self, new_valeur):
+ """
+ Remplace la valeur de self(si elle existe) par new_valeur)
+ """
+ self.valeur = new_valeur
+ self.initModif()
+
+ def getValeur(self):
+ """
+ Retourne la valeur de self, cad le texte de la commande commentarisee
+ """
+ return self.valeur
+
+ def register(self):
+ """
+ Enregistre la commande commenatrisee dans la liste des etapes de son parent lorsque celui-ci
+ est un JDC
+ """
+ self.parent.register(self)
+
+ def isOblig(self):
+ """
+ Indique si self est obligatoire ou non : retourne toujours 0
+ """
+ return 0
+
+ def ident(self):
+ """
+ Retourne le nom interne associe a self
+ Ce nom n'est jamais vu par l'utilisateur dans EFICAS
+ """
+ return self.nom
+
+ def isRepetable(self):
+ """
+ Indique si self est repetable ou non : retourne toujours 1
+ """
+ return 1
+
+ def getAttribut(self, nom_attribut):
+ """
+ Retourne l'attribut de nom nom_attribut de self (ou herite)
+ """
+ if hasattr(self, nom_attribut):
+ return getattr(self, nom_attribut)
+ else:
+ return None
+
+ def getFr(self):
+ """
+ Retourne l'attribut fr de self.definition
+ """
+ if self.jdc.code == "ASTER":
+ return self.definition.fr
+ try:
+ return getattr(self.definition, self.jdc.lang)
+ except:
+ return ""
+
+ def listeMcPresents(self):
+ return []
+
+ def supprime(self):
+ """
+ Methode qui supprime toutes les boucles de references afin que l'objet puisse
+ etre correctement detruit par le garbage collector
+ """
+ self.parent = None
+ self.etape = None
+ self.jdc = None
+ self.niveau = None
+ self.definition = None
+ self.valeur = None
+ self.val = None
+ self.appel = None
+
+ def supprimeSdProds(self):
+ pass
+
+ def updateContext(self, d):
+ """
+ Update le dictionnaire d avec les concepts ou objets produits par self
+ --> ne fait rien pour une commande en commentaire
+ """
+ pass
+
+ def deleteConcept(self, sd):
+ pass
+
+ def replaceConcept(self, old_sd, sd):
+ pass
+
+ def getSdprods(self, nom_sd):
+ return None
+
+ def unComment(self):
+ """
+ Cette methode a pour but de decommentariser l'objet courant,
+ cad de retourner un tuple contenant :
+ - l'objet CMD associe
+ - le nom de la sdprod eventuellement produite (sinon None)
+ """
+ # on recupere le contexte avant la commande commentarisee
+ context_ini = self.jdc.getContexteAvant(self)
+ try:
+ # on essaie de creer un objet JDC...
+ CONTEXT.unsetCurrentStep()
+ if re.search("Fin Commentaire", self.valeur):
+ self.valeur = self.valeur.replace("Fin Commentaire", "")
+ J = self.jdc.__class__(
+ procedure=self.valeur,
+ definition=self.jdc.definition,
+ cata=self.jdc.cata,
+ cata_ord_dico=self.jdc.cata_ordonne_dico,
+ context_ini=context_ini,
+ )
+ J.analyse()
+ except Exception as e:
+ traceback.print_exc()
+ # self.jdc.set_context()
+ raise AsException(tr("Erreur"), e.__str__())
+ if len(J.cr.crfatal) > 0:
+ # des erreurs fatales ont ete rencontrees
+ # self.jdc.set_context()
+ print("erreurs fatales !!!")
+ raise AsException(tr("Erreurs fatales"), "".join(J.cr.crfatal))
+ if not J.etapes:
+ # des erreurs ont ete rencontrees
+ raise AsException(tr("Impossible reconstruire commande\n"), str(J.cr))
+ # self.jdc.set_context()
+
+ new_etape = J.etapes[0]
+ if new_etape.sd:
+ nom_sd = new_etape.sd.nom
+ else:
+ nom_sd = None
+ # new_etape=new_etape.copy()
+ # print "unComment",new_etape.sd
+
+ pos = self.parent.etapes.index(self)
+ # L'ordre d'appel est important : suppEntite fait le menage des concepts dans les etapes suivantes
+ self.parent.addEntite(new_etape, pos)
+ self.parent.suppEntite(self)
+ return new_etape, nom_sd
+
+ def active(self):
+ """
+ Rend l'etape courante active
+ """
+ self.actif = 1
+
+ def inactive(self):
+ """
+ Rend l'etape courante inactive
+ """
+ self.actif = 0
+
+ def isActif(self):
+ """
+ Booleenne qui retourne 1 si self est valide, 0 sinon
+ """
+ return self.actif
+
+ def verifConditionBloc(self):
+ """
+ Evalue les conditions de tous les blocs fils possibles
+ (en fonction du catalogue donc de la definition) de self et
+ retourne deux listes :
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
+ """
+ return [], []
+
+ def verifConditionRegles(self, liste_presents):
+ """
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
+ """
+ return []
+
+ def reparent(self, parent):
+ """
+ Cette methode sert a reinitialiser la parente de l'objet
+ """
+ self.parent = parent
+ self.jdc = parent.getJdcRoot()
+ self.etape = self
+
+ def verifExistenceSd(self):
+ """
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la reference a ces concepts
+ --> sans objet pour les commandes commentarisees
+ """
+ pass
+
+ def controlSdprods(self, d):
+ """sans objet pour les commandes commentarisees"""
+ pass
+
+ def close(self):
+ pass
+
+ def resetContext(self):
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient la classe COMMENTAIRE qui sert dans EFICAS
+ pour gerer les commentaires dans un JDC
+"""
+
+from Accas.processing.P_CR import CR
+from Accas.processing import P_OBJECT
+from Accas.accessor import A_OBJECT
+from Accas.extensions.eficas_translation import tr
+
+
+class COMMENTAIRE(P_OBJECT.OBJECT, A_OBJECT.OBJECT):
+ """
+ Cette classe permet de creer des objets de type COMMENTAIRE
+ """
+
+ nature = "COMMENTAIRE"
+ idracine = "_comm"
+
+ def __init__(self, valeur, parent=None):
+ # parent est un objet de type OBJECT (ETAPE ou MC ou JDC...)
+ self.valeur = valeur
+ if not parent:
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
+ else:
+ self.jdc = self.parent = parent
+ # La classe COMMENTAIRE n'a pas de definition. On utilise self
+ # pour completude
+ self.definition = self
+ self.nom = ""
+ self.niveau = self.parent.niveau
+ self.actif = 1
+ self.state = "unchanged"
+ self.register()
+ self.fenetreIhm = None
+
+ def register(self):
+ """
+ Enregistre le commentaire dans la liste des etapes de son parent
+ lorsque celui-ci est un JDC
+ """
+ if self.parent.nature == "JDC":
+ # le commentaire est entre deux commandes:
+ # il faut l'enregistrer dans la liste des etapes
+ self.parent.register(self)
+
+ def copy(self):
+ c = COMMENTAIRE(valeur=self.valeur, parent=self.jdc)
+ return c
+
+ def isValid(self):
+ """
+ Retourne 1 si self est valide, 0 sinon
+ Retourne toujours 1 car un commentaire est toujours valide
+ """
+ return 1
+
+ def isOblig(self):
+ """Indique si self est obligatoire ou non : retourne toujours 0"""
+ return 0
+
+ def isRepetable(self):
+ """Indique si self est repetable ou non : retourne toujours 1"""
+ return 1
+
+ def active(self):
+ """
+ Rend l'etape courante active
+ """
+ self.actif = 1
+
+ def inactive(self):
+ """
+ Rend l'etape courante inactive
+ NB : un commentaire est toujours actif !
+ """
+ self.actif = 1
+
+ def isActif(self):
+ """
+ Booleenne qui retourne 1 si self est valide, 0 sinon
+ """
+ return self.actif
+
+ def supprime(self):
+ """
+ Methode qui supprime toutes les boucles de references afin que
+ l'objet puisse etre correctement detruit par le garbage collector
+ """
+ self.parent = None
+ self.jdc = None
+ self.definition = None
+ self.niveau = None
+
+ def listeMcPresents(self):
+ return []
+
+ def getValeur(self):
+ """Retourne la valeur de self, cad le contenu du commentaire"""
+ try:
+ return self.valeur
+ except:
+ return None
+
+ def setValeur(self, new_valeur):
+ """
+ Remplace la valeur de self(si elle existe) par new_valeur
+ """
+ self.valeur = new_valeur
+ self.initModif()
+
+ def initModif(self):
+ self.state = "modified"
+ if self.parent:
+ self.parent.initModif()
+
+ def supprimeSdProds(self):
+ pass
+
+ def updateContext(self, d):
+ """
+ Update le dictionnaire d avec les concepts ou objets produits par self
+ --> ne fait rien pour un commentaire
+ """
+ pass
+
+ def report(self):
+ """Genere l'objet rapport (classe CR)"""
+ self.cr = CR()
+ if not self.isValid():
+ self.cr.warn(tr("Objet commentaire non valorise"))
+ return self.cr
+
+ def ident(self):
+ """Retourne le nom interne associe a self
+ Ce nom n'est jamais vu par l'utilisateur dans EFICAS
+ """
+ return self.nom
+
+ def deleteConcept(self, sd):
+ pass
+
+ def replaceConcept(self, old_sd, sd):
+ pass
+
+ def verifConditionBloc(self):
+ """
+ Evalue les conditions de tous les blocs fils possibles
+ (en fonction du catalogue donc de la definition) de self et
+ retourne deux listes :
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
+ """
+ return [], []
+
+ def verifConditionRegles(self, liste_presents):
+ """
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
+ """
+ return []
+
+ def getSdprods(self, nom_sd):
+ """
+ Retourne les concepts produits par la commande
+ """
+ return None
+
+ def verifExistenceSd(self):
+ pass
+
+ def getFr(self):
+ """
+ Retourne le commentaire lui meme tronque a la 1ere ligne
+ """
+ return self.valeur.split("\n", 1)[0]
+
+ def controlSdprods(self, d):
+ """sans objet"""
+ pass
+
+ def close(self):
+ pass
+
+ def resetContext(self):
+ pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# copyright 2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr -- mailto:contact@logilab.fr
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+Creates the ``EficasException`` class for the EDF Eficas application.
+This class supports the internationalization mechanism provided in
+the ```` module.
+"""
+
+
+class EficasException(Exception):
+ """
+ ``EficasException`` class, which embeds the translation mechanism.
+ In case the input message is already passed through the translation
+ mechanism, the translation mechanism defined in this class would
+ have no effect, since its input would not be among the source
+ strings to be translated.
+ """
+
+ def __init__(self, msg=""):
+ """
+ Initializes the EficasException instances. The output message,
+ stored in the ``args`` attribute, is fitted with the translation
+ mechanism.
+ """
+ Exception.__init__(self)
+ # import sys, os
+ # sys.path.append(os.path.realpath(".."))
+ from Accas.extensions.eficas_translation import tr
+
+ self.args = (tr(msg),)
+
+
+if __name__ == "__main__":
+ import sys
+
+ raise EficasException(sys.argv[1])
--- /dev/null
+# -*- coding: utf-8 -*-
+# copyright 2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr -- mailto:contact@logilab.fr
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+eficas_translation is used for internationalizing strings via the Qt
+mechanism.
+Handles unformatted and formatted strings, according to all formatting schemes:
+via dictionaries, tuples, or atoms.
+revoir la fonction tr pour avoir un tr sans qt
+
+"""
+import re
+from Accas.extensions.eficas_exception import EficasException
+
+regex = re.compile(r"% *[0-9]+")
+
+def _reformat_qstring_from_tuple(qstring, params):
+ """
+ _reformat_qstring_from_tuple(string, tuple) -> string
+
+ Module-internal method.
+ Returns a formatted string from an unformatted string
+ and a tuple specifying the parameters of the string.
+ """
+ from PyQt5.QtCore import QRegExp
+
+ reg = QRegExp("\%\.[1-9]{1,2}f")
+ for p, j in zip(params, list(range(len(params)))):
+ try:
+ i += 1 + qstring[i + 1 :].indexOf("%")
+ except NameError:
+ i = qstring.indexOf("%")
+ if i == reg.indexIn(qstring):
+ precision = reg.cap(0).split(".")[1].split("f")[0]
+ qstring = (
+ qstring[: i + 2 + len(precision)].replace(
+ "%." + precision, "%" + str(1 + j)
+ )
+ + qstring[i + 3 + len(precision) :]
+ )
+ qstring = regex.sub("{}", qstring)
+ # qstring = qstring.format(QString.number(float(params[j]), 'f', int(precision)))
+ qstring = qstring.format(float(params[j]))
+ else:
+ qstring = (
+ qstring[: i + 1].replace("%", "%" + str(1 + j))
+ + qstring[i + 2 :]
+ )
+ if isinstance(params[j], str):
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(params[j])
+ elif isinstance(params[j], float):
+ qstring = regex.sub("{}", qstring)
+ # qstring = qstring.format(QString.number(params[j], 'f',\ len(unicode(params[j]).\
+ # split('.')[1])))
+ qstring = qstring.format(params[j])
+ elif isinstance(params[j], int):
+ qstring = regex.sub("{}", qstring)
+ # qstring = qstring.format(QString.number(params[j], 10))
+ qstring = qstring.format(params[j])
+ elif isinstance(params[j], list):
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(repr(params[j]))
+ else:
+ raise EficasException(
+ "TypeError: eficas_translation.translation: \
+ Unicode, list or number expected!"
+ )
+ return qstring
+
+
+def _reformat_qstring_from_dict(qstring, params):
+ """
+ _reformat_qstring_from_dict(string, dict) -> string
+
+ Module-internal method.
+ Returns a formatted string from an unformatted string
+ and a dictionary specifying the parameters of the string.
+ """
+ from PyQt5.QtCore import QRegExp
+
+ for p, j in zip(params, list(range(len(params)))):
+ p_reg = QRegExp("\%\(" + p + "\)\.[1-9]{1,2}f")
+ p_index = p_reg.indexIn(qstring)
+ if p_index != -1:
+ precision = p_reg.cap(0).split(".")[1].split("f")[0]
+ # qstring = qstring.replace("%(" + p + ")." + precision + "f",\
+ # "%" + unicode(1 + j)).\
+ # arg(QString.number(float(params[p]), \
+ # 'f', \
+ # int(precision)))
+ qstring = qstring.replace(
+ "%(" + p + ")." + precision + "f", "%" + str(1 + j)
+ )
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(float(params[p]))
+ else:
+ qstring.remove(QRegExp("\\)[sdf]{1}"))
+ qstring = qstring.replace("%(" + p, "%" + str(1 + j))
+ if isinstance(params[p], str):
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(params[p])
+ elif isinstance(params[p], float):
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(params[p])
+ # qstring = qstring.format(QString.number(params[p], 'f', \
+ # len(unicode(params[p]).split('.')[1])))
+ elif isinstance(params[p], int):
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(params[p])
+ elif isinstance(params[p], list):
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(repr(params[p]))
+ else:
+ raise EficasException(
+ "TypeError: eficas_translation.translation: \
+ Improper string parameter type."
+ )
+ return qstring
+
+
+def _reformat_qstring_from_atom(qstring, params):
+ """
+ _reformat_qstring_from_atom(string, int-or-float) -> string
+
+ Module-internal method.
+ Returns a formatted string from an unformatted string
+ and an integer or a float specifying the parameter of
+ the string.
+ """
+ from PyQt5.QtCore import QRegExp
+
+ reg = QRegExp("\%\.[1-9]{1,2}f")
+ if qstring.count("%") == 0:
+ qstring.append("%1")
+ try:
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(str(params))
+ except AttributeError:
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(params)
+ elif qstring.count("%") == 1:
+ i = qstring.indexOf("%")
+ if i == reg.indexIn(qstring):
+ precision = reg.cap(0).split(".")[1].split("f")[0]
+ qstring = (
+ qstring[: i + 2 + len(precision)].replace("%." + precision, "%1")
+ + qstring[i + 3 + len(precision) :]
+ )
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format((params))
+ # qstring = qstring.format(QString.number(float(params), 'f',\
+ # int(precision)))
+ else:
+ qstring = qstring[: i + 1].replace("%", "%1") + qstring[i + 2 :]
+ if isinstance(params, (str, str)):
+ qstring = qstring.format(_preprocess_atom(params))
+ elif isinstance(params, float):
+ # qstring = qstring.format(QString.number(params, 'f', \
+ # len(unicode(params).\
+ # split('.')[1])))
+ qstring = qstring.format(params)
+ elif isinstance(params, int):
+ qstring = regex.sub("{}", qstring)
+ # qstring = qstring.format(QString.number(params, 10))
+ qstring = qstring.format(params)
+ else:
+ raise EficasException(
+ "TypeError: eficas_translation.translation: Unicode, \
+ string or number expected!"
+ )
+ return qstring
+
+
+def _reformat_qstring_from_list(qstring, params):
+ """
+ _reformat_qstring_from_list(string, tuple) -> string
+
+ Module-internal method.
+ Returns a formatted string from an unformatted string
+ and a list whose concatenation specifies the parameter
+ of the string.
+ """
+ # XXX to add further functionality, e.g. list processing
+ # when ``%`` not at the end.
+ if qstring.count("%") == 1 and str(qstring).strip()[:-1].endswith("%"):
+ qstring = qstring[: qstring.indexOf("%") + 1].append("1")
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(" ".join(map(str, params)))
+ elif qstring.count("%") == 0:
+ qstring.append("%1")
+ qstring = regex.sub("{}", qstring)
+ qstring = qstring.format(" ".join(map(str, params)))
+ else:
+ raise EficasException(
+ "ValueError: eficas_translation.translation: \
+ At most one '%' expected!"
+ )
+ return qstring
+
+
+def _preprocess_atom(string):
+ """
+ _preprocess_atom(string-or-number-or-unicode) -> unicode
+ Test if input is a Unicode object or a number; if so, then return it;
+ otherwise, test if the input is a string; if so, then try to create
+ a Unicode object out of it. To this end, assume the string is encoded
+ in utf-8; if this fails, then assume the string is encoded in Latin-9.
+ """
+ if isinstance(string, (str, int, float, complex)):
+ return string
+ elif isinstance(string, str):
+ return _str_toUnicode(string)
+ else:
+ raise EficasException(
+ "TypeError: Expected number, string or\
+ Unicode object!"
+ )
+
+
+def _str_toUnicode(string):
+ """
+ _str_toUnicode(string) -> unicode
+ Tries to create a Unicode object out of the input string; assumes
+ the string is UTF-8 encoded; if not, then assume the string is
+ Latin-9 encoded.
+ """
+ try:
+ string = str(string, "utf-8")
+ except UnicodeDecodeError:
+ try:
+ string = str(string, "iso-8859-15")
+ except UnicodeDecodeError:
+ raise EficasException(
+ "UnicodeDecodeError: UTF-8, Latin-1 \
+ or Latin-9 expected"
+ )
+ return string
+
+
+def tr(string, *args):
+ """tr(string-or-unicode, iterable-or-float-or-int) -> unicode
+ tr(string-or-unicode) -> unicode
+
+ Returns a formatted Unicode object from an unformatted
+ string or Unicode object with formatting specifications, and,
+ optionally, an iterable or an int or float.
+ Lets Python do the string formatting.
+ revoir le else pour avoir un tr sans qt
+ """
+ try:
+ from PyQt5.QtWidgets import QApplication
+ except:
+ return string
+
+ string = _preprocess_atom(string)
+ if len(args) == 0:
+ r = str(QApplication.translate("@default", string))
+ elif len(args) == 1:
+ if isinstance(args[0], (dict, tuple)):
+ if string.count("%") == len(args[0]):
+ r = str(QApplication.translate("@default", string)) % args[0]
+ elif string.count("%") == 1 and string.count("%(") == 0:
+ r = str(
+ QApplication.translate("@default", string)
+ ) % _preprocess_atom(repr(args[0]))
+ elif string.count("%") == 0:
+ r = (str(QApplication.translate("@default", string)), args[0])
+ else:
+ raise EficasException(
+ "ValueError: eficas_translation.translate.tr: \
+ Improper input string formatting"
+ )
+ elif isinstance(args[0], (str, str, int, float, complex)):
+ if string.count("%") == 1:
+ r = str(
+ QApplication.translate("@default", string)
+ ) % _preprocess_atom(args[0])
+ else:
+ r = str(
+ QApplication.translate("@default", string)
+ ) + str(_preprocess_atom(args[0]))
+ elif isinstance(args[0], list) or args[0] is None:
+ if string.count("%") == 1:
+ r = str(
+ QApplication.translate("@default", string)
+ ) % _preprocess_atom(repr(args[0]))
+ else:
+ r = (str(QApplication.translate("@default", string)), args[0])
+
+ else:
+ raise EficasException(
+ "ValueError: eficas_translation.translation.tr: \
+ Wrong type for formatted string \
+ arguments: %s"
+ % type(args[0])
+ )
+ else:
+ raise EficasException(
+ "ValueError: eficas_translation.translation.tr: \
+ Wrong formatted string arguments"
+ )
+ return r
+
+
+def tr_qt(string, *args):
+ """tr_qt(string, iterable-or-float-or-int) -> unicode
+ t_qtr(string) -> unicode
+
+ Returns a formatted string from an unformatted
+ Unicode string with formatting specifications, and,
+ optionally, an iterable or an int or float.
+ Lets PyQt do the string formatting. To this end,
+ a conversion from Python to Qt string formatting
+ syntax is performed."""
+ string = _preprocess_atom(string)
+ from PyQt5.QtWidgets import QApplication
+
+ if len(args) == 0:
+ r = QApplication.translate("@default", string)
+ elif len(args) == 1:
+ r = QApplication.translate("@default", string)
+ if isinstance(args[0], (dict, tuple)):
+ if r.count("%") == len(args[0]):
+ if isinstance(args[0], dict):
+ r = _reformat_qstring_from_dict(r, args[0])
+ elif isinstance(args[0], tuple):
+ r = _reformat_qstring_from_tuple(r, args[0])
+ # XXX Pay attention to this: distinguish between tuple,
+ # dict and dict with key given in string.
+ elif r.count("%") in range(2) and r.count("%(") == 0:
+ r = _reformat_qstring_from_atom(r, _preproces_atom(repr(args[0])))
+ else:
+ raise EficasException(
+ "ValueError: eficas_translation.translation.tr_qt: \
+ Improper formatting string parameters"
+ )
+ elif isinstance(args[0], (str, str, int, float, complex)):
+ r = _reformat_qstring_from_atom(r, args[0])
+ elif isinstance(args[0], list):
+ r = _reformat_qstring_from_list(r, args[0])
+ elif args[0] is None:
+ r = _reformat_qstring_from_atom(
+ r, _preprocess_string_from_atom(repr(args[0]))
+ )
+ else:
+ raise EficasException(
+ "ValueError: eficas_translation.translation.tr_qt: \
+ Wrong string formatting parameter types"
+ )
+ else:
+ raise EficasException(
+ "ValueError: eficas_translation.translation.tr_qt: \
+ Improper formatted string parameter set"
+ )
+ return str(r)
+
+
+if __name__ == "__main__":
+ import sys
+
+ tr(sys.argv[1], *args)
+ tr_qt(sys.argv[1], *args)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient la classe ETAPE_NIVEAU qui sert a
+ concretiser les niveaux au sein d'un JDC
+"""
+import traceback
+from Accas.processing import P_OBJECT
+
+
+class ETAPE_NIVEAU(P_OBJECT.OBJECT):
+ def __init__(self, niveau, parent):
+ self.parent = parent
+ self.jdc = self.parent.getJdcRoot()
+ self.niveau = self
+ self.definition = niveau
+ self.etapes = []
+ self.etapes_niveaux = []
+ self.dict_niveaux = {}
+ self.editmode = 0
+ self.state = "undetermined"
+ self.buildNiveaux()
+
+ def buildNiveaux(self):
+ for niveau in self.definition.lNiveaux:
+ etape_niveau = ETAPE_NIVEAU(niveau, self)
+ self.etapes_niveaux.append(etape_niveau)
+ self.dict_niveaux[niveau.nom] = etape_niveau
+
+ def register(self, etape):
+ """
+ Enregistre la commande etape :
+ - si editmode = 0 : on est en mode relecture d'un fichier de commandes
+ auquel cas on ajoute etape a la fin de la liste self.etapes
+ - si editmode = 1 : on est en mode ajout d'etape depuis eficas auquel cas
+ cette methode ne fait rien, c'est addEntite qui enregistre etape
+ a la bonne place dans self.etapes
+ """
+ if self.editmode:
+ return
+ self.etapes.append(etape)
+
+ def unregister(self, etape):
+ """
+ Desenregistre l'etape du niveau
+ """
+ self.etapes.remove(etape)
+
+ def ident(self):
+ return self.definition.label
+
+ def isActif(self):
+ # print 'Niveau : ',self.definition.nom
+ # print '\tactif =',self.definition.actif
+ if self.definition.actif == 1:
+ return 1
+ else:
+ # self.actif est une condition a evaluer dans un certain contexte ...
+ d = self.creeDictValeurs()
+ try:
+ t = eval(self.definition.actif, d)
+ return t
+ except:
+ traceback.print_exc()
+ return 0
+
+ def creeDictValeurs(self):
+ """
+ Retourne le dictionnaire des freres aines de self compose des couples :
+ {nom_frere isValid()}
+ """
+ d = {}
+ for niveau in self.parent.etapes_niveaux:
+ if niveau is self:
+ break
+ d[niveau.definition.nom] = niveau.isValid()
+ return d
+
+ def isValid(self):
+ """Methode booleenne qui retourne 0 si le niveau est invalide, 1 sinon"""
+ if self.etapes_niveaux == []:
+ if len(self.etapes) == 0:
+ return self.definition.valide_vide
+ else:
+ for etape in self.etapes:
+ if not etape.isValid():
+ return 0
+ return 1
+ else:
+ for etape_niveau in self.etapes_niveaux:
+ if not etape_niveau.isValid():
+ return 0
+ return 1
+
+ def accept(self, visitor):
+ visitor.visitETAPE_NIVEAU(self)
+
+ def addEntite(self, name, pos_rel):
+ self.editmode = 1
+ try:
+ pos_abs = self.jdc.getNbEtapesAvant(self) + pos_rel
+ cmd = self.jdc.addEntite(name, pos_abs)
+ self.etapes.insert(pos_rel, cmd)
+ self.editmode = 0
+ return cmd
+ except:
+ traceback.print_exc()
+ self.editmode = 0
+ return None
+
+ def suppEntite(self, etape):
+ """Classe ETAPE_NIVEAU
+ Supprime une etape
+ """
+ self.jdc.suppEntite(etape)
+
+ def getFr(self):
+ """
+ Retourne le texte d'aide dans la langue choisie
+ """
+ try:
+ return getattr(self.definition, self.jdc.lang)
+ except:
+ return ""
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from builtins import str
+from builtins import object
+
+import re, sys, types
+
+from Accas.processing.P_CR import CR
+from Accas.extensions.eficas_translation import tr
+
+
+# def group(*choices): return '(' + ''.join(choices, '|') + ')'
+# def any(*choices): return apply(group, choices) + '*'
+# def maybe(*choices): return apply(group, choices) + '?'
+
+Intnumber = r"[1-9]\d*"
+Exponent = r"[eEdD][-+]?\d+"
+Expfloat = r"[1-9]\d*" + Exponent
+# Pointfloat = group(r'\d+\.\d*', r'\.\d+') + maybe(Exponent)
+# Floatnumber = group(Pointfloat, Expfloat)
+Pointfloat = r"(\d+\.\d*|\.\d+)([eEdD][-+]?\d+)?"
+Floatnumber = r"((\d+\.\d*|\.\d+)([eEdD][-+]?\d+)?|[1-9]\d*[eEdD][-+]?\d+)"
+
+
+pat_number = re.compile(r"^([+-]?)([0-9]+)(\.\d*)?(.*)")
+pat_number_complet = re.compile(r"^([+-]?)([0-9]+)(\.\d*)?([eEdD][+-]?\d+)(.*)")
+pat_constante = re.compile(r"^([+-]?)([a-zA-Z][a-zA-Z_0-9]*\s*)(.*)")
+
+
+def cmp_function(arg1, arg2):
+ """
+ Fonction de comparaison permettant de classer les listes de
+ fonctions unaires et binaires selon la longueur de leurs arguments
+ On classe les arguments les plus longs en premier
+ """
+ if len(arg1) > len(arg2):
+ return -1
+ elif len(arg1) == len(arg2):
+ return 0
+ else:
+ return 1
+
+
+class InterpreteurException(Exception):
+ """
+ Classe servant a definir les exceptions levees par l'interpreteur de formule
+ """
+
+ def __init__(self, args=None):
+ self.args = args
+
+ def __str__(self):
+ return str(self.args)
+
+
+class Interpreteur_Formule(object):
+ """
+ Cette classe sert a construire un interpreteur de formules Aster
+ """
+
+ l_fonctions_binaires = ["+", "-", "*", "/", "**", "=", "MOD", "MIN", "MAX", "ATAN2"]
+ l_fonctions_unaires = [
+ "+",
+ "-",
+ "INT",
+ "REAL",
+ "AIMAG",
+ "ABS",
+ "SQRT",
+ "EXP",
+ "LOG",
+ "LOG10",
+ "SIN",
+ "COS",
+ "TAN",
+ "ASIN",
+ "ACOS",
+ "ATAN",
+ "SINH",
+ "COSH",
+ "TANH",
+ "HEAVYSID",
+ ]
+ l_constantes = ["PI", "RD_RG", "DG_RD"]
+
+ def __init__(self, formule=None, constantes=[], fonctions=[], parent=None):
+ """
+ Constructeur d'interpreteurs de formule Aster
+ - formule = tuple (nom,type,arguments,corps)
+ - constantes = liste des noms de constantes externes
+ - fonctions_unaires = dictionnaire {nom_fonction externe : nb arguments de cette fonction}
+ """
+ self.new_constantes = constantes
+ self.new_fonctions_unaires = fonctions
+ self.cr = CR()
+ self.l_operateurs = []
+ self.parent = parent
+ self.l_children = []
+ if formule:
+ self.setFormule(formule)
+ if self.parent:
+ self.parent.enregistre(self)
+
+ def setFormule(self, formule):
+ """
+ Stocke formule (tuple) dans l'attribut t_formule
+ Methode externe
+ """
+ # if type(formule) != types.TupleType:
+ if type(formule) != types.tuple:
+ raise InterpreteurException(
+ tr("La formule passee a l'interpreteur doit etre sous forme de tuple")
+ )
+ self.t_formule = formule
+ # self.initCr()
+ self.modifyListes()
+ self.ordonneListes()
+
+ def initCr(self):
+ """
+ Initialise le cr,cad valorise les chaines debut et fin
+ """
+ nom = self.t_formule[0]
+ if nom:
+ if nom[0] in ("+", "-"):
+ nom = nom[1:]
+ self.cr.debut = tr("Debut Fonction %s", nom)
+ self.cr.fin = tr("Fin Fonction %s", nom)
+
+ def str(self):
+ """
+ Retourne une liste de chaines de caracteres representant la formule
+ """
+ l_txt = []
+ l_txt.append(self.t_formule[0])
+ for oper in self.l_operateurs:
+ # oper est ici une liste decrivant oper
+ txt = []
+ for elem in oper:
+ txt.append(str(elem))
+ l_txt.append(txt)
+ return l_txt
+
+ def report(self, decalage=1):
+ """
+ Retourne le rapport de FORMULE
+ """
+ txt = self.cr.report()
+ return txt
+
+ def enregistre(self, fils):
+ """
+ Enregistre un operateur fils dans la liste des children
+ """
+ self.l_children.append(fils)
+ self.cr.add(fils.cr)
+
+ def isValid(self):
+ """
+ Booleenne qui retourne 1 si la formule est valide, 0 sinon
+ Methode externe
+ """
+ self.l_operateurs = []
+ self.cr.purge() # on vide le cr
+ self.initCr() # on initialise le cr
+ self.interpreteFormule()
+ return self.cr.estvide()
+
+ def interpreteFormule(self):
+ """
+ Realise l'interpretation du corps de la formule
+ """
+ texte = self.t_formule[3]
+ if not texte:
+ return
+ if type(texte) != list:
+ texte = [
+ texte,
+ ]
+ for text_arg in texte:
+ text_arg = text_arg.replace("\n", "")
+ # Enleve les espaces
+ text_arg = text_arg.replace(" ", "")
+ try:
+ self.l_operateurs.append(self.splitOperateurs(text_arg))
+ except InterpreteurException as e:
+ self.cr.fatal(e.__str__())
+
+ def modifyListes(self):
+ """
+ Modifie la liste des constantes en lui ajoutant le nom des parametres
+ de la fonction a interpreter
+ """
+ args = self.t_formule[2]
+ # l'interpreteur de formule sert aussi a evaluer les EVAL
+ # dans ce cas il n'y a pas d'arguments puisque pas de fonction ...
+ if args:
+ args = args[1:-1] # on enleve les parentheses ouvrante et fermante
+ l_args = args.split(",")
+ for arg in l_args:
+ typ, nom = arg.split(":")
+ nom = nom.strip()
+ self.l_constantes.append(nom)
+ # on considere que les fonctions unaires de base sont toutes a un seul argument :
+ l_f = []
+ self.d_fonctions_unaires = {}
+ for fct in self.l_fonctions_unaires:
+ self.d_fonctions_unaires[fct] = 1
+ # on ajoute les constantes externes
+ for cte in self.new_constantes:
+ self.l_constantes.append(cte)
+ # on ajoute les fonctions unaires externes au dictionnaire des fonctions unaires
+ for new_fonc in self.new_fonctions_unaires:
+ self.d_fonctions_unaires[new_fonc[0]] = self.getNbArgs(new_fonc)
+ # self.d_fonctions_unaires.update(self.new_fonctions_unaires)
+ self.l_fonctions_unaires = list(self.d_fonctions_unaires.keys())
+
+ def ordonneListes(self):
+ """
+ Ordonne les listes de fonctions unaires et binaires
+ """
+ self.l_fonctions_binaires.sort(cmp_function)
+ self.l_fonctions_unaires.sort(cmp_function)
+ self.l_constantes.sort(cmp_function)
+
+ def splitOperateurs(self, texte):
+ """
+ Splite le texte passe en argument en operateurs plus elementaires.
+ N'analyse pas l'interieur des operateurs (ne fait qu'une passe)
+ """
+ l_operateurs = []
+ texte = texte.strip()
+ # on recherche un nombre en debut de texte
+ try:
+ oper, reste = self.chercheNombre(texte)
+ except InterpreteurException as e:
+ raise InterpreteurException(e.__str__())
+ if not oper:
+ # on recherche une constante en debut de texte
+ try:
+ oper, reste = self.chercheConstante(texte)
+ except InterpreteurException as e:
+ raise InterpreteurException(e.__str__())
+ if not oper:
+ # on recherche une expression entre parentheses...
+ try:
+ oper, reste = self.chercheExpressionEntreParentheses(texte)
+ except InterpreteurException as e:
+ raise InterpreteurException(e.__str__())
+ if not oper:
+ # on recherche le debut d'un operateur unaire en debut de texte
+ try:
+ oper, reste = self.chercheOperateurUnaire(texte)
+ except InterpreteurException as e:
+ raise InterpreteurException(e.__str__())
+ if not oper:
+ type_objet, nom_objet = self.getType(texte)
+ if type_objet == "constante":
+ raise InterpreteurException(
+ "Constante %s inconnue" % nom_objet
+ )
+ elif type_objet == "fonction":
+ raise InterpreteurException(
+ "Fonction %s inconnue dans %s" % (nom_objet, texte)
+ )
+ else:
+ raise InterpreteurException(
+ "Impossible d'interpreter : %s" % texte
+ )
+ # on a trouve un operateur (nombre, constante ou unaire)
+ # il faut encore verifier que l'on est en fin de texte ou qu'il est bien suivi
+ # d'un operateur binaire
+ l_operateurs.append(oper)
+ if reste:
+ texte = reste.strip()
+ oper, reste = self.chercheOperateurBinaire(texte)
+ if not oper:
+ # on a un reste et pas d'operateur binaire --> erreur
+ raise InterpreteurException(
+ "L'operateur %s doit etre suivi d'un operateur binaire"
+ % l_operateurs[-1]
+ )
+ else:
+ # on a bien trouve un operateur binaire:
+ l_operateurs.append(oper)
+ # il faut recommencer l'analyse du reste par splitOperateurs ...
+ try:
+ l_op = self.splitOperateurs(reste)
+ except InterpreteurException as e:
+ raise InterpreteurException(e.__str__())
+ l_operateurs.extend(l_op)
+ return l_operateurs
+ else:
+ # on a fini d'analyser texte
+ return l_operateurs
+
+ def chercheNombre(self, texte):
+ """
+ Cherche un nombre en debut de texte
+ Retourne ce nombre et le reste ou None et le texte initial
+ Peut lever une InterpreteurException dans le cas ou le nombre n'est pas valide
+ """
+ texte = texte.strip()
+ m = pat_number_complet.match(texte)
+ if m:
+ # on a trouve un nombre avec exposant
+ l_groups = m.groups()
+ sgn = l_groups[0]
+ nb = l_groups[1]
+ if l_groups[2]:
+ nb = nb + l_groups[2]
+ if l_groups[3]:
+ nb = nb + l_groups[3]
+ nombre = sgn + nb
+ return nombre, l_groups[4]
+ else:
+ m = pat_number.match(texte)
+ if m:
+ # on a trouve un nombre sans exposant
+ l_groups = m.groups()
+ sgn = l_groups[0]
+ nb = l_groups[1]
+ if l_groups[2]:
+ nb = nb + l_groups[2]
+ nombre = sgn + nb
+ # il faut verifier si ce nombre n'est pas suivi d'un exposant incomplet ...
+ reste = l_groups[3].strip()
+ if reste == "":
+ return nombre, l_groups[3]
+ if reste[0] in ("e", "E", "d", "D"):
+ raise InterpreteurException(
+ "La syntaxe de l'exposant de %s est erronee " % nb
+ )
+ else:
+ return nombre, l_groups[3]
+ else:
+ # on n'a pas trouve de nombre
+ return None, texte
+
+ def chercheConstanteOld(self, texte):
+ """
+ Recherche une constante en debut de texte parmi la liste des constantes.
+ Retourne le texte representant la constante et le reste du texte ou
+ Retourne None,texte si aucune constante trouvee
+ """
+ txt = None
+ texte = texte.strip()
+ for cte in self.l_constantes:
+ index = texte.find(cte)
+ # if index == 0 : print 'on a trouve %s dans %s en %d' %(cte,texte,index)
+ if index == 0:
+ txt = cte
+ zz, reste = texte.split(cte, 1)
+ break
+ if txt:
+ return txt, reste
+ else:
+ # aucune constante trouvee
+ return None, texte
+
+ def chercheConstante(self, texte):
+ """
+ Recherche une constante en debut de texte parmi la liste des constantes.
+ Retourne le texte representant la constante et le reste du texte ou
+ Retourne None,texte si aucune constante trouvee
+ """
+ txt = None
+ texte = texte.strip()
+ m = pat_constante.match(texte)
+ if m:
+ # on a trouve un identificateur en debut de texte
+ l_groups = m.groups()
+ sgn = l_groups[0]
+ identificateur = l_groups[1].strip()
+ reste = l_groups[2]
+ # il faut verifier qu'il ne s'agit pas d'un appel a une fonction
+ if reste:
+ if reste[0] == "(":
+ # --> appel de fonction
+ return None, texte
+ # il faut encore verifier qu'elle est bien dans la liste des constantes...
+ if identificateur not in self.l_constantes:
+ raise InterpreteurException(
+ "La constante %s est inconnue dans %s" % (identificateur, texte)
+ )
+ else:
+ return sgn + identificateur, reste
+ else:
+ # aucune constante trouvee
+ return None, texte
+
+ def chercheArgs(self, texte):
+ """
+ Cherche au debut de texte une liste d'arguments entre parentheses
+ """
+ if texte[0] != "(":
+ return None, texte
+ else:
+ n = 0
+ cpt = 1
+ while cpt != 0:
+ n = n + 1
+ if n >= len(texte):
+ # on a atteint la fin de texte sans avoir trouve la parenthese fermante --> erreur
+ raise InterpreteurException(
+ "Manque parenthese fermante dans %s" % texte
+ )
+ if texte[n] == "(":
+ cpt = cpt + 1
+ elif texte[n] == ")":
+ cpt = cpt - 1
+ if n + 1 < len(texte):
+ return texte[0 : n + 1], texte[n + 1 :]
+ else:
+ # on a fini d'analyser le texte : reste = None
+ return texte, None
+
+ def chercheOperateurUnaireOld(self, texte):
+ """
+ Cherche dans texte un operateur unaire
+ """
+ txt = None
+ texte = texte.strip()
+ for oper in self.l_fonctions_unaires:
+ index = texte.find(oper)
+ if index == 0:
+ txt = oper
+ zz, reste = texte.split(oper, 1)
+ break
+ if txt:
+ # print 'on a trouve :',txt
+ operateur = txt
+ texte = reste
+ try:
+ args, reste = self.chercheArgs(texte)
+ except InterpreteurException as e:
+ raise InterpreteurException(e.__str__())
+ if not args:
+ # operateur unaire sans arguments
+ raise InterpreteurException(
+ "operateur unaire %s sans arguments" % operateur
+ )
+ else:
+ # operateur = operateur+args
+ args = self.splitArgs(txt, args, self.d_fonctions_unaires[operateur])
+ formule_operateur = (txt, "", self.t_formule[2], args)
+ operateur = Interpreteur_Formule(
+ formule=formule_operateur,
+ constantes=self.new_constantes,
+ fonctions_unaires=self.new_fonctions_unaires,
+ parent=self,
+ )
+ operateur.interpreteFormule()
+ texte = reste
+ return operateur, reste
+ else:
+ # aucun operateur unaire trouve
+ return None, texte
+
+ def chercheOperateurUnaire(self, texte):
+ """
+ Cherche dans texte un operateur unaire
+ """
+ txt = None
+ texte = texte.strip()
+ m = pat_constante.match(texte)
+ if m:
+ # on a trouve un identificateur en debut de texte
+ # il faut encore verifier que l'on a bien a faire a un appel de fonction ...
+ l_groups = m.groups()
+ sgn = l_groups[0]
+ identificateur = l_groups[1].strip()
+ reste = l_groups[2]
+ try:
+ args, reste = self.chercheArgs(reste)
+ except InterpreteurException as e:
+ raise InterpreteurException(e.__str__())
+ if not args:
+ # operateur unaire sans arguments
+ # en principe on ne doit jamais etre dans ce cas car il est deja trappe par chercheConstante ...
+ raise InterpreteurException(
+ "Fonction %s sans arguments !" % identificateur
+ )
+ else:
+ # il faut encore verifier que l'on a bien a faire a une fonction connue
+ if identificateur not in self.l_fonctions_unaires:
+ raise InterpreteurException(
+ "Fonction %s inconnue dans %s !" % (identificateur, texte)
+ )
+ args = self.splitArgs(
+ identificateur, args, self.d_fonctions_unaires[identificateur]
+ )
+ formule_operateur = (sgn + identificateur, "", self.t_formule[2], args)
+ operateur = Interpreteur_Formule(
+ formule=formule_operateur,
+ constantes=self.new_constantes,
+ fonctions=self.new_fonctions_unaires,
+ parent=self,
+ )
+ operateur.interpreteFormule()
+ texte = reste
+ return operateur, reste
+ elif texte[0] == "-":
+ # Il faut pouvoir trapper les expressions du type exp(-(x+1)) ...
+ try:
+ args, reste = self.chercheArgs(texte[1:])
+ except InterpreteurException as e:
+ raise InterpreteurException(e.__str__())
+ if not args:
+ # Il ne s'agit pas de '-' comme operateur unaire --> on retourne None
+ return None, texte
+ else:
+ identificateur = "-"
+ args = self.splitArgs(
+ identificateur, args, self.d_fonctions_unaires[identificateur]
+ )
+ formule_operateur = (identificateur, "", self.t_formule[2], args)
+ operateur = Interpreteur_Formule(
+ formule=formule_operateur,
+ constantes=self.new_constantes,
+ fonctions=self.new_fonctions_unaires,
+ parent=self,
+ )
+ operateur.interpreteFormule()
+ texte = reste
+ return operateur, reste
+ else:
+ return None, texte
+
+ def chercheOperateurBinaire(self, texte):
+ """
+ Cherche dans texte un operateur unaire
+ """
+ txt = None
+ texte = texte.strip()
+ for oper in self.l_fonctions_binaires:
+ index = texte.find(oper)
+ # if index != -1 : print 'on a trouve %s dans %s en %d' %(oper,texte,index)
+ if index == 0:
+ txt = oper
+ zz, reste = texte.split(oper, 1)
+ break
+ if txt:
+ return txt, reste
+ else:
+ # aucun operateur unaire trouve
+ return None, texte
+
+ def chercheExpressionEntreParentheses(self, texte):
+ """
+ Cherche en debut de texte une expression entre parentheses
+ """
+ args, reste = self.chercheArgs(texte.strip())
+ if not args:
+ return None, texte
+ else:
+ # on a trouve une expression entre parentheses en debut de texte
+ # --> on retourne un objet Interpreteur_Formule
+ formule_operateur = ("", "", self.t_formule[2], args[1:-1])
+ operateur = Interpreteur_Formule(
+ formule=formule_operateur,
+ constantes=self.new_constantes,
+ fonctions=self.new_fonctions_unaires,
+ parent=self,
+ )
+ operateur.interpreteFormule()
+ texte = reste
+ return operateur, reste
+
+ def splitArgs(self, nom_fonction, args, nb_args):
+ """
+ Tente de partager args en nb_args elements
+ Retourne une liste de chaines de caracteres (liste de longueur nb_args)
+ """
+ args = args[1:-1] # on enleve les parentheses ouvrante et fermante
+ if nb_args == 1:
+ return args
+ l_args = args.split(",")
+ if len(l_args) != nb_args:
+ raise InterpreteurException(
+ "La fonction %s requiert %d arguments : %d fourni(s)"
+ % (nom_fonction, nb_args, len(l_args))
+ )
+ else:
+ return l_args
+
+ def getType(self, texte):
+ """
+ Retourne le type de l'objet defini dans texte, a savoir:
+ - constante
+ - fonction
+ - unknown
+ et son nom
+ """
+ texte = texte.strip()
+ if "(" not in texte:
+ return "constante", texte
+ if texte[-1] != ")":
+ return "unknown", ""
+ nom_oper, args = texte.split("(", 1)
+ return "fonction", nom_oper
+
+ def getNbArgs(self, formule):
+ """
+ Retourne le nombre d'arguments dans la definition de formule (sous forme de tuple)
+ """
+ args = formule[2][1:-1] # on enleve les parentheses ouvrante et fermante
+ l_args = args.split(",")
+ return len(l_args)
+
+
+if __name__ == "__main__":
+ constantes = ["FREQ3", "AMOR1"]
+ fonctions_unaires = [
+ ("ACC", "REEL", "(REEL:x)", """bidon"""),
+ ]
+ f1 = ("f1", "REEL", "(REEL:x)", """SIN(x)+3*x""")
+ f2 = ("f2", "REEL", "(REEL:x)", """ATAN(x+3)+3*x""")
+ f3 = ("f3", "REEL", "(REEL:INST)", """ACC(INST,FREQ3,AMOR1)""")
+ f4 = ("f4", "REEL", "(REEL:INST)", """ACC(INST,FREQ2,AMOR1)""")
+ f5 = ("f5", "REEL", "(REEL:INST,REEL:Y)", """ACC(INST,FREQ3,AMOR1)+Y*INST""")
+ f6 = ("f6", "REEL", "(REEL:x)", """(x+ 3)/ 35.698""")
+ f7 = ("f7", "REEL", "(REEL:x)", """(x+ 3)/ 35.698E-10""")
+ f8 = ("f8", "REEL", "(REEL:x)", """(x+ 3)/ 35.698E""")
+ f9 = (
+ "f9",
+ "REEL",
+ "(REEL:INSTA,REEl:INSTB)",
+ """2.*SIN((PI/4)+((INSTA-INSTB)/2.))* COS((PI/4)-((INSTA+INSTB)/2.))""",
+ )
+ f10 = ("f10", "REEL", "(REEL:X)", """EXP(-(X+1))""")
+ for formule in (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10):
+ i = Interpreteur_Formule(
+ formule=formule, constantes=constantes, fonctions=fonctions_unaires
+ )
+ txt = i.str()
+ print(("\nformule %s = %s" % (str(formule), txt)))
+ # if i.isValid() :
+ # print "\n\tPas d'erreur !"
+ # else:
+ # print i.report()
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient la classe mixin qui porte les methodes
+ pour traiter les niveaux au sein d'un JDC
+"""
+
+from builtins import object
+from . import etape_niveau
+
+
+class JDC(object):
+ def __init__(self):
+ self.dict_niveaux = {}
+ self.buildNiveaux()
+
+ def buildNiveaux(self):
+ for niveau in self.definition.lNiveaux:
+ etape_niv = etape_niveau.ETAPE_NIVEAU(niveau, self)
+ self.etapes_niveaux.append(etape_niv)
+ self.dict_niveaux[niveau.nom] = etape_niv
+ self.dict_niveaux.update(etape_niv.dict_niveaux)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+"""
+ Ce module contient la classe JDC_INCLUDE qui sert a inclure
+ dans un jeu de commandes une partie de jeu de commandes
+ au moyen de la fonctionnalite INCLUDE ou INCLUDE_MATERIAU
+ Quand l'utilisateur veut inclure un fichier il faut versifier
+ que le jeu de commandes inclus est valide et compatible
+ avec le contexte avant et apres l'insertion
+"""
+import string
+from Accas import JDC, ASSD, AsException, JDC_CATA
+from Accas.accessor import CONNECTOR
+
+
+class JDC_POURSUITE(JDC):
+ def __init__(
+ self,
+ definition=None,
+ procedure=None,
+ cata=None,
+ cata_ord_dico=None,
+ parent=None,
+ nom="SansNom",
+ appli=None,
+ context_ini=None,
+ jdc_pere=None,
+ etape_include=None,
+ prefix_include=None,
+ recorded_units=None,
+ old_recorded_units=None,
+ **args
+ ):
+ JDC.__init__(
+ self,
+ definition=definition,
+ procedure=procedure,
+ cata=cata,
+ cata_ord_dico=cata_ord_dico,
+ parent=parent,
+ nom=nom,
+ appli=appli,
+ context_ini=context_ini,
+ **args
+ )
+ self.jdc_pere = jdc_pere
+ self.etape_include = etape_include
+ self.prefix_include = prefix_include
+ if recorded_units is not None:
+ self.recorded_units = recorded_units
+ if old_recorded_units is not None:
+ self.old_recorded_units = old_recorded_units
+
+ def o_register(self, sd):
+ return self.jdc_pere.o_register(sd)
+
+ def nommerSDProd(self, sd, sdnom, restrict="non"):
+ """
+ Nomme la SD apres avoir verifie que le nommage est possible : nom
+ non utilise
+ Ajoute un prefixe s'il est specifie (INCLUDE_MATERIAU)
+ Si le nom est deja utilise, leve une exception
+ Met le concept cree dans le contexe global g_context
+ """
+ # print "nommerSDProd",sd,sdnom,restrict
+ if self.prefix_include:
+ if sdnom != self.prefix_include:
+ sdnom = self.prefix_include + sdnom
+
+ if sdnom != "" and sdnom[0] == "_":
+ # Si le nom du concept commence par le caractere _ on lui attribue
+ # un identificateur automatique comme dans JEVEUX (voir gcncon)
+ #
+ # nom commencant par __ : il s'agit de concepts qui seront detruits
+ # nom commencant par _ : il s'agit de concepts intermediaires qui seront gardes
+ # ATTENTION : il faut traiter differemment les concepts dont le nom
+ # commence par _ mais qui sont des concepts nommes automatiquement par
+ # une eventuelle sous macro.
+ if sdnom[1] in string.digits:
+ # Ce concept provient probablement d'une sous macro (cas improbable)
+ # pas de renommage
+ pass
+ elif sdnom[1] == "_":
+ # cas d'un concept a ne pas conserver apres execution de la commande
+ sdnom = sd.id[2:]
+ pass
+ else:
+ sdnom = sd.id[2:]
+ pass
+
+ o = self.sdsDict.get(sdnom, None)
+ if isinstance(o, ASSD):
+ raise AsException(tr("Nom de concept deja defini : %s", sdnom))
+
+ # On pourrait verifier que le jdc_pere apres l'etape etape_include
+ # ne contient pas deja un concept de ce nom
+ # if self.jdc_pere.getSdApresEtapeAvecDetruire(sdnom,etape=self.etape_include):
+ # Il existe un concept apres self => impossible d'inserer
+ # raise AsException("Nom de concept deja defini : %s" % sdnom)
+ # On a choisi de ne pas faire ce test ici mais de le faire en bloc
+ # si necessaire apres en appelant la methode verifContexte
+
+ # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
+ # Ajoute a la creation (appel de regSD).
+ self.sdsDict[sdnom] = sd
+ sd.nom = sdnom
+
+ # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
+ if restrict == "non":
+ self.g_context[sdnom] = sd
+
+ def getVerifContexte(self):
+ # print "getVerifContexte"
+ j_context = self.getContexteAvant(None)
+ self.verifContexte(j_context)
+ return j_context
+
+ def forceContexte(self, contexte):
+ for nom_sd, sd in list(contexte.items()):
+ if not isinstance(sd, ASSD):
+ continue
+ autre_sd = self.jdc_pere.getSdApresEtapeAvecDetruire(
+ nom_sd, sd, etape=self.etape_include
+ )
+ if autre_sd is None:
+ continue
+ if sd is not autre_sd:
+ # Il existe un autre concept de meme nom produit par une etape apres self
+ # on detruit ce concept pour pouvoir inserer les etapes du jdc_include
+ if sd.etape:
+ sd.etape.supprimeSdprod(sd)
+
+ return contexte
+
+ def verifContexte(self, context):
+ """
+ Cette methode verifie si le contexte passe en argument (context)
+ peut etre insere dans le jdc pere de l'include.
+ Elle verifie que les concepts contenus dans ce contexte n'entrent
+ pas en conflit avec les concepts produits dans le jdc pere
+ apres l'include.
+ Si le contexte ne peut pas etre insere, la methode leve une
+ exception sinon elle retourne le contexte inchange
+ """
+ # print "verifContexte"
+ for nom_sd, sd in list(context.items()):
+ if not isinstance(sd, ASSD):
+ continue
+ autre_sd = self.jdc_pere.getSdApresEtapeAvecDetruire(
+ nom_sd, sd, etape=self.etape_include
+ )
+ if autre_sd is None:
+ continue
+ if sd is not autre_sd:
+ # Il existe un concept produit par une etape apres self
+ # => impossible d'inserer
+ raise Exception(
+ "Impossible d'inclure le fichier. Un concept de nom "
+ + "%s existe deja dans le jeu de commandes." % nom_sd
+ )
+
+ return context
+
+ def getListeCmd(self):
+ """
+ Retourne la liste des commandes du catalogue
+ """
+ if self.jdc_pere is None:
+ return JDC.getListeCmd(self)
+ return self.jdc_pere.getListeCmd()
+
+ def getGroups(self):
+ """
+ Retourne la liste des commandes du catalogue par groupes
+ """
+ if self.jdc_pere is None:
+ return JDC.getGroups(self)
+ return self.jdc_pere.getGroups()
+
+ def initModif(self):
+ """
+ Met l'etat de l'etape a : modifie
+ Propage la modification au parent
+
+ Attention : initModif doit etre appele avant de realiser une modification
+ La validite devra etre recalculee apres cette modification
+ mais par un appel a finModif pour preserver l'etat modified
+ de tous les objets entre temps
+ """
+ # print "jdc_include.initModif",self,self.etape_include
+ self.state = "modified"
+ if self.etape_include:
+ self.etape_include.initModif()
+
+ def finModif(self):
+ """
+ Methode appelee une fois qu'une modification a ete faite afin de
+ declencher d'eventuels traitements post-modification
+ ex : INCLUDE et POURSUITE
+ """
+ # print "jdc_include.finModif",self,self.etape_include
+ CONNECTOR.Emit(self, "valid")
+ if self.etape_include:
+ self.etape_include.finModif()
+
+ def supprime(self):
+ """
+ On ne supprime rien directement pour un jdc auxiliaire d'include ou de poursuite
+ Utiliser supprime_aux
+ """
+ pass
+
+ def supprime_aux(self):
+ # print "supprime_aux",self
+ JDC.supprime(self)
+ self.jdc_pere = None
+ self.etape_include = None
+ # self.cata_ordonne_dico={}
+ self.appli = None
+
+ # self.context_ini={}
+ # self.procedure=None
+
+ def getContexteAvant(self, etape):
+ """
+ Retourne le dictionnaire des concepts connus avant etape
+ On tient compte des concepts produits par le jdc pere
+ en reactualisant le contexte initial context_ini
+ On tient compte des commandes qui modifient le contexte
+ comme DETRUIRE ou les macros
+ Si etape == None, on retourne le contexte en fin de JDC
+ """
+ # print "jdc_include.getContexteAvant",etape,etape and etape.nom
+ if self.etape_include:
+ new_context = self.etape_include.parent.getContexteAvant(
+ self.etape_include
+ ).copy()
+ self.context_ini = new_context
+ d = JDC.getContexteAvant(self, etape)
+ return d
+
+ def resetContext(self):
+ # print "jdc_include.resetContext",self,self.nom
+ if self.etape_include:
+ self.etape_include.parent.resetContext()
+ new_context = self.etape_include.parent.getContexteAvant(
+ self.etape_include
+ ).copy()
+ self.context_ini = new_context
+ JDC.resetContext(self)
+
+ def getSdApresEtape(self, nom_sd, etape, avec="non"):
+ """
+ Cette methode retourne la SD de nom nom_sd qui est eventuellement
+ definie apres etape
+ Si avec vaut 'non' exclut etape de la recherche
+ """
+ if self.etape_include:
+ sd = self.etape_include.parent.getSdApresEtape(
+ nom_sd, self.etape_include, "non"
+ )
+ if sd:
+ return sd
+ return JDC.getSdApresEtape(self, nom_sd, etape, avec)
+
+ def getSdApresEtapeAvecDetruire(self, nom_sd, sd, etape, avec="non"):
+ """
+ On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
+ Il peut etre detruit, remplace ou conserve
+ Cette methode retourne la SD sd de nom nom_sd qui est eventuellement
+ definie apres etape en tenant compte des concepts detruits
+ Si avec vaut 'non' exclut etape de la recherche
+ """
+ # print "jdc_include.getSdApresEtapeAvecDetruire",nom_sd,sd,id(sd)
+ autre_sd = JDC.getSdApresEtapeAvecDetruire(self, nom_sd, sd, etape, avec)
+ # si autre_sd vaut None le concept sd a ete detruit. On peut terminer
+ # la recherche en retournant None
+ # Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer
+ # la recherche en retournant le concept nouvellement defini
+ # Sinon, on poursuit la recherche dans les etapes du niveau superieur.
+ if autre_sd is None or autre_sd is not sd:
+ return autre_sd
+ return self.etape_include.parent.getSdApresEtapeAvecDetruire(
+ nom_sd, sd, self.etape_include, "non"
+ )
+
+ def deleteConcept(self, sd):
+ """
+ Fonction : Mettre a jour les etapes du JDC suite a la disparition du
+ concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
+ """
+ # Nettoyage des etapes de l'include
+ JDC.deleteConcept(self, sd)
+ # Nettoyage des etapes du parent
+ if self.etape_include:
+ self.etape_include.parent.deleteConceptAfterEtape(self.etape_include, sd)
+
+ def deleteConceptAfterEtape(self, etape, sd):
+ """
+ Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite a
+ la disparition du concept sd
+ """
+ # Nettoyage des etapes de l'include
+ JDC.deleteConceptAfterEtape(self, etape, sd)
+ # Nettoyage des etapes du parent
+ if self.etape_include:
+ self.etape_include.parent.deleteConceptAfterEtape(self.etape_include, sd)
+
+ def updateConceptAfterEtape(self, etape, sd):
+ """
+ Fonction : mettre a jour les etapes du JDC suite a une modification
+ du concept sd (principalement renommage)
+ """
+ JDC.updateConceptAfterEtape(self, etape, sd)
+ if self.etape_include:
+ self.etape_include.parent.updateConceptAfterEtape(self.etape_include, sd)
+
+ def replaceConceptAfterEtape(self, etape, old_sd, sd):
+ """
+ Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite au
+ remplacement du concept old_sd par sd
+ """
+ # Nettoyage des etapes de l'include
+ JDC.replaceConceptAfterEtape(self, etape, old_sd, sd)
+ # Nettoyage des etapes du parent
+ if self.etape_include:
+ self.etape_include.parent.replaceConceptAfterEtape(
+ self.etape_include, old_sd, sd
+ )
+
+ def changeFichier(self, fichier):
+ if self.etape_include:
+ self.etape_include.fichier_ini = fichier
+ self.finModif()
+
+ def controlContextApres(self, etape):
+ """
+ Cette methode verifie que les etapes apres l'etape etape
+ ont bien des concepts produits acceptables (pas de conflit de
+ nom principalement)
+ Si des concepts produits ne sont pas acceptables ils sont supprimes.
+ Effectue les verifications sur les etapes du jdc mais aussi sur les
+ jdc parents s'ils existent.
+ """
+ # print "jdc_include.controlContextApres",self,etape
+ # Regularise les etapes du jdc apres l'etape etape
+ self.controlJdcContextApres(etape)
+ if self.etape_include:
+ # print "CONTROL_INCLUDE:",self.etape_include,self.etape_include.nom
+ # il existe un jdc pere. On propage la regularisation
+ self.etape_include.parent.controlContextApres(self.etape_include)
+
+
+class JDC_INCLUDE(JDC_POURSUITE):
+ def getListeCmd(self):
+ """
+ Retourne la liste des commandes du catalogue
+ """
+ if self.jdc_pere is None:
+ return JDC.getListeCmd(self)
+ return [
+ e
+ for e in self.jdc_pere.getListeCmd()
+ if e not in ("DEBUT", "POURSUITE", "FIN")
+ ]
+
+ def activeEtapes(self):
+ for e in self.etapes:
+ e.active()
+
+
+class JDC_CATA_INCLUDE(JDC_CATA):
+ class_instance = JDC_INCLUDE
+
+
+class JDC_CATA_POURSUITE(JDC_CATA):
+ class_instance = JDC_POURSUITE
+
+
+from Accas import AU_MOINS_UN, A_CLASSER
+
+import prefs
+
+c = prefs.code
+JdC_include = JDC_CATA_INCLUDE(code=c, execmodul=None)
+
+JdC_poursuite = JDC_CATA_POURSUITE(
+ code="ASTER",
+ execmodul=None,
+ regles=(
+ AU_MOINS_UN("DEBUT", "POURSUITE"),
+ AU_MOINS_UN("FIN"),
+ A_CLASSER(("DEBUT", "POURSUITE"), "FIN"),
+ ),
+)
--- /dev/null
+# -*- coding: utf-8 -*-
+# copyright 2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr -- mailto:contact@logilab.fr
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+
+"""
+
+import os
+
+try:
+ from PyQt5.QtCore import QTranslator
+ code_translator = QTranslator()
+ eficas_translator = QTranslator()
+except:
+ code_translator = None
+ eficas_translator = None
+ print("pas d import de qt, pas de traduction")
+
+
+def localise(application, locale=None, file=None, translatorFile=None, debug=False):
+ """
+ file contient les traductions eficas
+ translatorFile contient les traductions specifiques au code
+ pour l instant ne fonctionne qu avec qt
+ """
+ if code_translator == None:
+ print("qt not avalaible, no translation")
+ return
+
+ from PyQt5.QtCore import QLibraryInfo
+ from PyQt5.QtCore import QLocale
+ from PyQt5.QtWidgets import QApplication
+ monPath = os.path.join(os.path.dirname(__file__), "..","..", "UiQT5")
+ sys_locale = QLocale.system().name()
+
+ if locale is None : locale = "fr"
+ if locale == "ang": locale = "en"
+
+ if file == None and translatorFile == None :
+ if debug: print("pas de fichier de traduction a charger")
+ return
+
+ if file :
+ print("chargement du fichier de traduction : ", file, monPath)
+ if eficas_translator.load(file, monPath) :
+ if debug : print( file, " loaded")
+ else :
+ print( 'pb au chargement du fichier de traduction :', file)
+ QApplication.installTranslator(eficas_translator)
+
+ if translatorFile :
+ print("chargement du fichier de traduction specifique : ", translatorFile)
+ if (code_translator.load(translatorFile)) and debug : print(translatorFile, " loaded")
+ elif code_translator.load(translatorFile + "_" + locale) and debug:
+ print(translatorFile + "_" + locale + " loaded")
+ elif debug: print( "Unable to load Code translator! No file or No translation" + translatorFile)
+ if debug: print(QApplication.installTranslator(code_translator))
+ else: QApplication.installTranslator(code_translator)
+
+
+if __name__ == "__main__":
+ import sys
+ localise(sys.argv[1])
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+# Modules Python
+
+from builtins import str
+
+# Modules Eficas
+from Accas.processing import P_MCCOMPO
+from Accas.validation import V_MCCOMPO
+from Accas.extensions.eficas_translation import tr
+
+
+class MCNUPLET(V_MCCOMPO.MCCOMPO, P_MCCOMPO.MCCOMPO):
+ """ """
+
+ nature = "MCNUPLET"
+ txt_nat = "Nuplet : "
+
+ def __init__(self, val, definition, nom, parent):
+ # val contient la valeur initial du nuplet
+ self.val = val
+ if val == None:
+ self.val = ()
+ self.definition = definition
+ self.nom = nom
+ self.parent = parent
+ # getValeurEffective affecte la valeur par defaut si necessaire
+ self.valeur = self.getValeurEffective(self.val)
+ if parent:
+ self.jdc = self.parent.jdc
+ self.niveau = self.parent.niveau
+ self.etape = self.parent.etape
+ else:
+ # Le mot cle a ete cree sans parent
+ self.jdc = None
+ self.niveau = None
+ self.etape = None
+ self.state = "undetermined"
+ self.actif = 1
+ self.mcListe = self.buildMc()
+
+ def buildMc(self):
+ """
+ Construit la liste des sous-entites de MCNUPLET
+ a partir de la liste des arguments (valeur)
+ """
+ args = self.valeur
+ if args == None:
+ args = ()
+ mcListe = []
+
+ # on cree les sous entites du NUPLET a partir des valeurs initiales
+ k = 0
+ for v in self.definition.entites:
+ if k < len(args):
+ val = args[k]
+ else:
+ val = None
+ objet = v(val=val, nom=repr(k), parent=self)
+ if hasattr(objet.definition, "position"):
+ if objet.definition.position == "global":
+ self.append_mc_global(objet)
+ # XXX et global_jdc ??
+ mcListe.append(objet)
+ k = k + 1
+ # Un nuplet n'a pas de mots inconnus
+ self.reste_val = {}
+ return mcListe
+
+ def isValid(self, cr="non"):
+ """
+ Indique si self (MCNUPLET) est un objet valide ou non : retourne 1 si oui, 0 sinon
+ """
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ valid = 1
+ if hasattr(self, "valid"):
+ old_valid = self.valid
+ else:
+ old_valid = None
+ for child in self.mcListe:
+ if not child.isValid():
+ valid = 0
+ break
+ if len(self.mcListe) != len(self.definition.entites):
+ valid = 0
+ if cr == "oui":
+ self.cr.fatal(
+ "".join(("Nuplet : ", self.nom, tr("Longueur incorrecte")))
+ )
+ self.valid = valid
+ self.state = "unchanged"
+ if old_valid:
+ if old_valid != self.valid:
+ self.initModifUp()
+ return self.valid
+
+ def __getitem__(self, key):
+ """
+ Retourne le key eme element du nuplet
+ """
+ # Un nuplet est toujours une liste de mots cles simples
+ # On retourne donc la valeur
+ return self.mcListe[key].valeur
+
+ def __str__(self):
+ """
+ Retourne une representation du nuplet sous forme de chaine
+ de caracteres
+ """
+ s = "("
+ for e in self.mcListe:
+ s = s + str(e.valeur) + ","
+ return s + ")"
+
+ def __repr__(self):
+ """
+ Retourne une representation du nuplet sous forme de chaine
+ de caracteres
+ """
+ s = "("
+ for e in self.mcListe:
+ s = s + str(e.valeur) + ","
+ return s + ")"
+
+ def getRegles(self):
+ """
+ Retourne la liste des regles attachees au nuplet
+ """
+ return []
+
+ def verifConditionBloc(self):
+ """
+ Verifie s'il y a des blocs sous le nuplet et retourne
+ les blocs en question
+ """
+ # Il n y a pas de BLOCs sous un NUPLET
+ return [], []
+
+ def isRepetable(self):
+ """
+ Indique si le NUPLET peut etre repete.
+ Retourne 1 si c'est le cas.
+ Retourne 0 dans le cas contraire.
+ L'information est donnee par le catalogue, cad la definition de self
+ """
+ if self.definition.min != self.definition.max:
+ return 1
+ else:
+ return 0
+
+ def makeobjet(self):
+ return self.definition(val=None, nom=self.nom, parent=self.parent)
+
+ def getValeur(self):
+ """
+ Cette methode doit retourner la valeur de l'objet. Elle est utilisee par
+ creeDictValeurs pour construire un dictionnaire contenant les mots cles
+ d'une etape.
+ Dans le cas d'un nuplet, on retournera comme valeur une liste des valeurs
+ des mots cle simples contenus.
+ """
+ l = []
+ for v in self.mcListe:
+ l.append(v.valeur)
+ return l
+
+ def getVal(self):
+ """
+ Une autre methode qui retourne une "autre" valeur du mot cle facteur.
+ Elle est utilisee par la methode getMocle
+ """
+ l = []
+ for v in self.mcListe:
+ l.append(v.valeur)
+ return l
+
+ def isOblig(self):
+ return self.definition.statut == "o"
+
+ def getFr(self):
+ """
+ Retourne le texte d'aide dans la langue choisie
+ """
+ try:
+ return getattr(self.definition, self.jdc.lang)
+ except:
+ return ""
+
+ def creeDictValeurs(self, liste=[], condition=0):
+ dico = {}
+ return dico
+
+ def updateConditionBloc(self):
+ """
+ Realise l'update des blocs conditionnels fils de self
+ et propage au parent (rien a faire pour nuplet)
+ """
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient la classe NIVEAU qui sert a definir
+ des groupes de commandes dans le catalogue
+"""
+from builtins import object
+
+
+class NIVEAU(object):
+ def __init__(self, nom="", label="", niveaux=(), valide_vide=1, actif=1):
+ self.nom = nom
+ self.label = label
+ self.statut = "o"
+ self.min = 1
+ self.max = 1
+ self.entites = []
+ self.l_noms_entites = []
+ self.valide_vide = valide_vide
+ self.actif = actif
+ self.d_niveaux = {}
+ self.lNiveaux = niveaux
+ for niveau in niveaux:
+ self.d_niveaux[niveau.nom] = niveau
+ self.d_niveaux.update(niveau.d_niveaux)
+
+ def enregistre(self, commande):
+ self.entites.append(commande)
+ self.l_noms_entites.append(commande.nom)
+
+ def getListeCmd(self):
+ self.l_noms_entites.sort()
+ return self.l_noms_entites
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient la classe de definition pour les nuplets NUPL
+"""
+# Modules Python
+from builtins import str
+import types
+
+# Modules Eficas
+from Accas.processing import P_ENTITE, P_MCLIST, P_CR
+from Accas.accessor import A_ENTITE
+from Accas.extensions.eficas_translation import tr
+from . import mcnuplet
+
+
+class NUPL(P_ENTITE.ENTITE, A_ENTITE.ENTITE):
+ """ """
+
+ class_instance = mcnuplet.MCNUPLET
+ list_instance = P_MCLIST.MCList
+ label = "NUPLET"
+ CR = P_CR.CR
+
+ def __init__( self, fr="", ang="", docu="", statut="f", defaut=None, min=0, max=1, elements=None,):
+ P_ENTITE.ENTITE.__init__(self)
+ A_ENTITE.ENTITE.__init__(self)
+ self.fr = fr
+ self.ang = ang
+ self.docu = docu
+ self.statut = statut
+ self.defaut = defaut
+ self.min = min
+ self.max = max
+ if self.max == "**":
+ self.max = float("inf")
+ if self.min == "**":
+ self.min = float("-inf")
+ self.entites = elements
+ self.regles = ()
+ # on force le statut des sous entites a obligatoire
+ for e in elements:
+ e.statut = "o"
+ self.idracine = "NUPLET"
+ self.affecter_parente()
+
+ def verifCata(self):
+ """
+ Cette methode sert a valider les attributs de l'objet de definition
+ de la classe NUPL
+ """
+ if type(self.min) != int:
+ if self.min != "**" and self.min != float("-inf"):
+ self.cr.fatal(
+ tr("L'attribut 'min' doit etre un entier : ") + str(self.min)
+ )
+ if type(self.max) != int:
+ if self.max != "**" and self.max != float("inf"):
+ self.cr.fatal(
+ tr("L'attribut 'max' doit etre un entier : ") + str(self.max)
+ )
+ if self.min > self.max:
+ self.cr.fatal(
+ tr("Nombres d'occurrence min et max invalides :")
+ + str(self.min)
+ + ","
+ + str(self.max)
+ )
+ if type(self.fr) != bytes and type(self.fr) != str:
+ self.cr.fatal(tr("L'attribut 'fr' doit etre une chaine de caracteres"))
+ if self.statut not in ["o", "f", "c", "d"]:
+ self.cr.fatal(tr("L'attribut 'statut' doit valoir 'o','f','c' ou 'd'"))
+ if type(self.docu) != bytes and type(self.docu) != str:
+ self.cr.fatal(tr("L'attribut 'docu' doit etre une chaine de caracteres"))
+ self.verifCataRegles()
+
+ def __call__(self, val, nom, parent):
+ """
+ Construit la structure de donnees pour un NUPLET a partir de sa definition (self)
+ de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
+ """
+ if (type(val) == tuple or type(val) == list) and type(val[0]) == tuple:
+ # On est en presence d une liste de nuplets
+ l = self.list_instance()
+ l.init(nom=nom, parent=parent)
+ for v in val:
+ objet = self.class_instance(
+ nom=nom, definition=self, val=v, parent=parent
+ )
+ l.append(objet)
+ return l
+ else:
+ # on est en presence d un seul nuplet
+ return self.class_instance(nom=nom, definition=self, val=val, parent=parent)
+
+ def report(self):
+ """
+ Methode qui cree le rapport de verification du catalogue du nuplet
+ """
+ self.cr = self.CR()
+ self.verifCata()
+ for v in self.entites:
+ cr = v.report()
+ cr.debut = tr("Debut ") + v.__class__.__name__ + " : "
+ cr.fin = tr("Fin ") + v.__class__.__name__ + " : "
+ self.cr.add(cr)
+ return self.cr
+
+ def affecter_parente(self):
+ """
+ Cette methode a pour fonction de donner un nom et un pere aux
+ sous entites qui n'ont aucun moyen pour atteindre leur parent
+ directement
+ Il s'agit principalement des mots cles
+ """
+ k = 0
+ for v in self.entites:
+ v.pere = self
+ v.nom = str(k)
+ k = k + 1
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# Classe qui permet d entrer des formules comme
+# comme a=3cos(30) sans qu elles soient caculees a l exec
+# attention toutes les fonctions mathematiques ne sont pas surchargées
+
+def mkf(value):
+ if type(value) in (type(1), type(1), type(1.5), type(1j), type("hh")):
+ return Constant(value)
+ elif isinstance(value, Formula):
+ return value
+ elif type(value) == type([]):
+ return Constant(value)
+ else:
+ # return Constant(value)
+ raise TypeError("Can't make formula from", value)
+
+
+class Formula(object):
+ def __len__(self):
+ val = self.eval()
+ if val is None:
+ return 0
+ try:
+ return len(val)
+ except:
+ return 1
+
+ def __complex__(self):
+ return complex(self.eval())
+
+ def __int__(self):
+ return int(self.eval())
+
+ def __long__(self):
+ return int(self.eval())
+
+ def __float__(self):
+ return float(self.eval())
+
+ def __pos__(self):
+ return self # positive
+
+ def __neg__(self):
+ return Unop("-", self)
+
+ def __abs__(self):
+ return Unop("abs", self)
+
+ def __add__(self, other):
+ return Binop("+", self, other)
+
+ def __radd__(self, other):
+ return Binop("+", other, self)
+
+ def __sub__(self, other):
+ return Binop("-", self, other)
+
+ def __rsub__(self, other):
+ return Binop("-", other, self)
+
+ def __mul__(self, other):
+ return Binop("*", self, other)
+
+ def __rmul__(self, other):
+ return Binop("*", other, self)
+
+ def __div__(self, other):
+ return Binop("/", self, other)
+
+ def __rdiv__(self, other):
+ return Binop("/", other, self)
+
+ def __truediv__(self, other):
+ return Binop("/", self, other)
+
+ def __rtruediv__(self, other):
+ return Binop("/", other, self)
+
+ def __floordiv__(self, other):
+ return Binop("//", self, other)
+
+ def __rfloordiv__(self, other):
+ return Binop("//", other, self)
+
+ def __pow__(self, other):
+ return Binop("**", self, other)
+
+ def __rpow__(self, other):
+ return Binop("**", other, self)
+
+ def __getitem__(self, i):
+ if i > len(self):
+ raise StopIteration
+ return Binop("[]", self, i)
+
+ def __cmp__(self, other):
+ return self.eval().__cmp__(other)
+
+ def __eq__(self, other):
+ return self.eval() == other
+
+ def __ne__(self, other):
+ return self.eval() != other
+
+ def __lt__(self, other):
+ return self.eval() < other
+
+ def __le__(self, other):
+ return self.eval() <= other
+
+ def __gt__(self, other):
+ return self.eval() > other
+
+ def __ge__(self, other):
+ return self.eval() >= other
+
+ def __hash__(self):
+ return id(self)
+
+
+def _div(a, b):
+ import six
+ import types
+ if isinstance(a, six.integer_types) and isinstance(b, six.integer_types):
+ if a % b:
+ return a / b
+ else:
+ return a // b
+ else:
+ return a / b
+
+
+class Binop(Formula):
+ opmap = {
+ "+": lambda a, b: a + b,
+ "*": lambda a, b: a * b,
+ "-": lambda a, b: a - b,
+ "/": _div,
+ "//": lambda a, b: a // b,
+ "**": lambda a, b: a**b,
+ "[]": lambda a, b: a[b],
+ }
+
+ def __init__(self, op, value1, value2):
+ self.op = op
+ self.values = mkf(value1), mkf(value2)
+
+ def __str__(self):
+ if self.op == "[]":
+ return "%s[%s]" % (self.values[0], self.values[1])
+ else:
+ return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
+
+ def __repr__(self):
+ if self.op == "[]":
+ return "%s[%s]" % (self.values[0], self.values[1])
+ else:
+ return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
+
+ def eval(self):
+ result = self.opmap[self.op](self.values[0].eval(), self.values[1].eval())
+ while isinstance(result, Formula):
+ result = result.eval()
+ return result
+
+ def __adapt__(self, validator):
+ return validator.adapt(self.eval())
+
+
+class Unop(Formula):
+ opmap = {
+ "-": lambda x: -x,
+ "abs": lambda x: abs(x),
+ }
+
+ def __init__(self, op, arg):
+ self._op = op
+ self._arg = mkf(arg)
+
+ def __str__(self):
+ return "%s(%s)" % (self._op, self._arg)
+
+ def __repr__(self):
+ return "%s(%s)" % (self._op, self._arg)
+
+ def eval(self):
+ return self.opmap[self._op](self._arg.eval())
+
+ def __adapt__(self, validator):
+ return validator.adapt(self.eval())
+
+
+class Unop2(Unop):
+ def __init__(self, nom, op, arg):
+ self._nom = nom
+ self._op = op
+ self._arg = []
+ for a in arg:
+ self._arg.append(mkf(a))
+
+ def __str__(self):
+ s = "%s(" % self._nom
+ for a in self._arg:
+ s = s + str(a) + ","
+ s = s + ")"
+ return s
+
+ def __repr__(self):
+ s = "%s(" % self._nom
+ for a in self._arg:
+ s = s + str(a) + ","
+ s = s + ")"
+ return s
+
+ def eval(self):
+ l = []
+ for a in self._arg:
+ l.append(a.eval())
+ return self._op(*l)
+
+
+class Constant(Formula):
+ def __init__(self, value):
+ self._value = value
+
+ def eval(self):
+ return self._value
+
+ def __str__(self):
+ return str(self._value)
+
+ def __adapt__(self, validator):
+ return validator.adapt(self._value)
+
+
+class Variable(Formula):
+ def __init__(self, name, value):
+ self._name = name
+ self._value = value
+
+ def eval(self):
+ return self._value
+
+ def __repr__(self):
+ return "Variable('%s',%s)" % (self._name, self._value)
+
+ def __str__(self):
+ return self._name
+
+ def __adapt__(self, validator):
+ return validator.adapt(self._value)
+
+
+def Eval(f):
+ if isinstance(f, Formula):
+ f = f.eval()
+ elif type(f) in (list,):
+ f = [Eval(i) for i in f]
+ elif type(f) in (tuple,):
+ f = tuple([Eval(i) for i in f])
+ return f
+
+
+def cos(f):
+ return Unop("ncos", f)
+
+
+def sin(f):
+ return Unop("nsin", f)
+
+
+def array(f, *tup, **args):
+ """array de numpy met en defaut la mecanique des parametres
+ on la supprime dans ce cas. Il faut que la valeur du parametre soit bien definie
+ """
+ originalMath = OriginalMath()
+ original_narray = originalMath.original_narray
+ return original_narray(Eval(f), *tup, **args)
+
+
+def sin(f):
+ return Unop("sin", f)
+
+
+def cos(f):
+ return Unop("cos", f)
+
+
+def ceil(f):
+ return Unop("ceil", f)
+
+
+def sqrt(f):
+ return Unop("sqrt", f)
+
+
+def pi2():
+ return Unop("pi")
+
+
+class OriginalMath(object):
+ _instance = None
+
+ def __new__(cls, *args, **kwargs):
+ if not cls._instance:
+ cls._instance = super(OriginalMath, cls).__new__(cls, *args, **kwargs)
+
+ return cls._instance
+
+ def __init__(self):
+ if hasattr(self, "pi"):
+ return
+ import math
+ import numpy
+
+ try:
+ self.toSurcharge()
+ except:
+ pass
+
+ def toSurcharge(self):
+ self.numeric_ncos = numpy.cos
+ self.numeric_nsin = numpy.sin
+ self.numeric_narray = numpy.array
+ self.sin = math.sin
+ self.cos = math.cos
+ self.sqrt = math.sqrt
+ self.ceil = math.ceil
+ self.pi = math.pi
+
+ # surcharge de la fonction cos de numpy pour les parametres
+ original_ncos = numpy.cos
+ Unop.opmap["ncos"] = lambda x: original_ncos(x)
+ numpy.cos = cos
+
+ # surcharge de la fonction sin de numpy pour les parametres
+ original_nsin = numpy.sin
+ Unop.opmap["nsin"] = lambda x: original_nsin(x)
+ numpy.sin = sin
+
+ # surcharge de la fonction array de numpy pour les parametres
+ original_narray = numpy.array
+ self.original_narray = numpy.array
+ numpy.array = array
+
+ # surcharge de la fonction sin de math pour les parametres
+ original_sin = math.sin
+ Unop.opmap["sin"] = lambda x: original_sin(x)
+ math.sin = sin
+
+ # surcharge de la fonction cos de math pour les parametres
+ original_cos = math.cos
+ Unop.opmap["cos"] = lambda x: original_cos(x)
+ math.cos = cos
+
+ # surcharge de la fonction sqrt de math pour les parametres
+ original_sqrt = math.sqrt
+ Unop.opmap["sqrt"] = lambda x: original_sqrt(x)
+ math.sqrt = sqrt
+
+ # surcharge de la fonction ceil de math pour les parametres
+ original_ceil = math.ceil
+ Unop.opmap["ceil"] = lambda x: original_ceil(x)
+ math.ceil = ceil
+
+ original_pi = math.pi
+ Unop.opmap["pi"] = lambda x: original_pi
+ pi = Variable("pi", pi2)
+ math.pi = pi
+
+ def toOriginal(self):
+ import math
+ import numpy
+ try:
+ numpy.cos = originalMath.numeric_ncos
+ numpy.sin = originalMath.numeric_nsin
+ numpy.array = originalMath.numeric_narray
+ except:
+ pass
+ math.sin = originalMath.sin
+ math.cos = originalMath.cos
+ math.sqrt = originalMath.sqrt
+ math.ceil = originalMath.ceil
+ math.pi = originalMath.pi
+
+
+originalMath = OriginalMath()
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient la classe PARAMETRE qui sert a definir
+ des objets parametres qui sont comprehensibles et donc affichables
+ par EFICAS.
+ Ces objets sont crees a partir de la modification du fichier de commandes
+ de l'utilisateur par le parseur de fichiers Python
+"""
+
+# import de modules Python
+from builtins import str
+from builtins import object
+
+import types
+from math import *
+import traceback
+
+# import de modules Eficas
+from Accas.processing.P_CR import CR
+from Accas.processing.P_UserASSD import UserASSD
+from Accas.processing.P_UserASSDMultiple import UserASSDMultiple
+from Accas.processing import P_OBJECT
+from Accas.accessor import A_OBJECT
+from .param2 import *
+from Accas.accessor import CONNECTOR
+from Accas.extensions.eficas_translation import tr
+
+
+class PARAMETRE(P_OBJECT.OBJECT, A_OBJECT.OBJECT, Formula):
+ """
+ Cette classe permet de creer des objets de type PARAMETRE
+ cad des affectations directes dans le jeu de commandes (ex: a=10.)
+ qui sont interpretees par le parseur de fichiers Python.
+ Les objets ainsi crees constituent des parametres pour le jdc
+ """
+
+ nature = "PARAMETRE"
+ idracine = "param"
+
+ def __new__(cls, nom, valeur=None):
+ # on est en relecture du .comm: l objet a ete detecte comme parametre par le parsing
+ # mais il s agit d une reference, une UserASDD
+ if issubclass(valeur.__class__, UserASSDMultiple):
+ valeur.initialiseNom(nom)
+ return valeur
+ if issubclass(valeur.__class__, UserASSD):
+ valeur.initialiseNom(nom)
+ return valeur
+ try:
+ return super(PARAMETRE, cls).__new__(cls, *args, **kwargs)
+ except:
+ return super(PARAMETRE, cls).__new__(cls)
+
+ def __init__(self, nom, valeur=None):
+ # print ('__init__ de parametre pour', nom,valeur)
+ self.nom = nom
+ # La classe PARAMETRE n'a pas de definition : on utilise self pour
+ # completude
+ self.definition = self
+ # parent ne peut etre qu'un objet de type JDC
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
+ self.niveau = self.parent.niveau
+ self.actif = 1
+ self.state = "undetermined"
+ self.register()
+ self.dict_valeur = []
+ # self.valeur = self.interpreteValeur(valeur)
+ # self.val=valeur
+ self.valeur = valeur
+ self.val = repr(valeur)
+ self.fenetreIhm = None
+
+ def interpreteValeur(self, val):
+ """
+ Essaie d'interpreter val (chaine de caracteres)comme :
+ - un entier
+ - un reel
+ - une chaine de caracteres
+ - une liste d'items d'un type qui precede
+ Retourne la valeur interpretee
+ """
+ # if not val : return None
+ valeur = None
+
+ if type(val) == list:
+ # Un premier traitement a ete fait lors de la saisie
+ # permet de tester les parametres qui sont des listes
+ l_new_val = []
+ for v in val:
+ try:
+ valeur = eval(str(v))
+ l_new_val.append(v)
+ except:
+ return None
+ return l_new_val
+
+ if type(val) == bytes or type(val) == str:
+ # on tente l'evaluation dans un contexte fourni par le parent s'il existe
+ if self.parent:
+ valeur = self.parent.evalInContext(val, self)
+ else:
+ try:
+ valeur = eval(val)
+ except:
+ # traceback.print_exc()
+ pass
+ # PN je n ose pas modifier je rajoute
+ # refus des listes heterogenes : ne dvrait pas etre la
+ if valeur != None:
+ if type(valeur) == tuple:
+ l_new_val = []
+ typ = None
+ for v in valeur:
+ if not typ:
+ typ = type(v)
+ else:
+ if type(v) != typ:
+ # la liste est heterogene --> on refuse d'interpreter
+ # self comme une liste
+ # on retourne la string initiale
+ print(("liste heterogene ", val))
+ return val
+ l_new_val.append(v)
+ return tuple(l_new_val)
+
+ if valeur != None:
+ if type(valeur).__name__ == "list":
+ self.dict_valeur = []
+ for i in range(len(valeur)):
+ self.dict_valeur.append(valeur[i])
+ return valeur
+ # on retourne val comme une string car on n'a pas su l'interpreter
+ return val
+
+ def getValeurs(self):
+ valeurretour = []
+ if self.dict_valeur != []:
+ for val in self.dict_valeur:
+ valeurretour.append(val)
+ else:
+ valeurretour.append(self.valeur)
+ return valeurretour
+
+ def setValeur(self, new_valeur):
+ """
+ Remplace la valeur de self par new_valeur interpretee
+ """
+ self.valeur = self.interpreteValeur(new_valeur)
+ self.val = repr(self.valeur)
+ self.parent.updateConceptAfterEtape(self, self)
+ self.initModif()
+
+ def setNom(self, new_nom):
+ """
+ Change le nom du parametre
+ """
+ self.initModif()
+ self.nom = new_nom
+ self.finModif()
+
+ def initModif(self):
+ """
+ Methode qui declare l'objet courant comme modifie et propage
+ cet etat modifie a ses ascendants
+ """
+ self.state = "modified"
+ if self.parent:
+ self.parent.initModif()
+
+ def getJdcRoot(self):
+ if self.parent:
+ return self.parent.getJdcRoot()
+ else:
+ return self
+
+ def register(self):
+ """
+ Enregistre le parametre dans la liste des etapes de son parent (JDC)
+ """
+ self.parent.registerParametre(self)
+ self.parent.register(self)
+
+ def isValid(self, cr="non"):
+ """
+ Retourne 1 si self est valide, 0 sinon
+ Un parametre est considere comme valide si :
+ - il a un nom
+ - il a une valeur
+ """
+ if self.nom == "":
+ if cr == "oui":
+ self.cr.fatal(tr("Pas de nom donne au parametre "))
+ return 0
+ else:
+ if self.valeur == None:
+ if cr == "oui":
+ self.cr.fatal(tr("Le parametre %s ne peut valoir None", self.nom))
+ return 0
+ return 1
+
+ def isOblig(self):
+ """
+ Indique si self est obligatoire ou non : retourne toujours 0
+ """
+ return 0
+
+ def isRepetable(self):
+ """
+ Indique si self est repetable ou non : retourne toujours 1
+ """
+ return 1
+
+ def listeMcPresents(self):
+ return []
+
+ def supprime(self):
+ """
+ Methode qui supprime toutes les boucles de references afin que
+ l'objet puisse etre correctement detruit par le garbage collector
+ """
+ self.parent = None
+ self.jdc = None
+ self.definition = None
+ self.niveau = None
+
+ def active(self):
+ """
+ Rend l'etape courante active.
+ Il faut ajouter le parametre au contexte global du JDC
+ """
+ self.actif = 1
+ try:
+ self.jdc.appendParam(self)
+ except:
+ pass
+ CONNECTOR.Emit(self, "add", None)
+ CONNECTOR.Emit(self, "valid")
+
+ def inactive(self):
+ """
+ Rend l'etape courante inactive
+ Il faut supprimer le parametre du contexte global du JDC
+ """
+ self.actif = 0
+ self.jdc.delParam(self)
+ self.jdc.deleteConceptAfterEtape(self, self)
+ CONNECTOR.Emit(self, "supp", None)
+ CONNECTOR.Emit(self, "valid")
+
+ def isActif(self):
+ """
+ Booleenne qui retourne 1 si self est actif, 0 sinon
+ """
+ return self.actif
+
+ def setAttribut(self, nom_attr, new_valeur):
+ """
+ Remplace la valeur de self.nom_attr par new_valeur)
+ """
+ if hasattr(self, nom_attr):
+ setattr(self, nom_attr, new_valeur)
+ self.initModif()
+
+ def supprimeSdProds(self):
+ """
+ Il faut supprimer le parametre qui a ete entre dans la liste des
+ parametres du JDC
+ """
+ self.jdc.deleteParam(self)
+ self.parent.deleteConcept(self)
+
+ def updateContext(self, d):
+ """
+ Update le dictionnaire d avec le parametre que produit self
+ """
+ d[self.nom] = self
+
+ def __repr__(self):
+ """
+ Donne un echo de self sous la forme nom = valeur
+ """
+ if type(self.valeur) == bytes or type(self.valeur) == str:
+ if self.valeur.find("\n") == -1:
+ # pas de retour chariot, on utilise repr
+ return self.nom + " = " + repr(self.valeur)
+ elif self.valeur.find('"""') == -1:
+ # retour chariot mais pas de triple ", on formatte
+ return self.nom + ' = """' + self.valeur + '"""'
+ else:
+ return self.nom + " = " + repr(self.valeur)
+ else:
+ if type(self.valeur) == list:
+ aRetourner = self.nom + " = ["
+ for l in self.valeur:
+ aRetourner = aRetourner + str(l) + ","
+ aRetourner = aRetourner[0:-1] + "]"
+ return aRetourner
+ return self.nom + " = " + str(self.valeur)
+
+ def __str__(self):
+ """
+ Retourne le nom du parametre comme representation de self
+ """
+ return self.nom
+
+ def getSdprods(self, nom_sd):
+ """
+ Retourne les concepts produits par la commande
+ """
+ return None
+
+ def report(self):
+ """Genere l'objet rapport (classe CR)"""
+ self.cr = CR()
+ self.isValid(cr="oui")
+ return self.cr
+
+ def ident(self):
+ """
+ Retourne le nom interne associe a self
+ Ce nom n'est jamais vu par l'utilisateur dans EFICAS
+ """
+ return self.nom
+
+ def deleteConcept(self, sd):
+ pass
+
+ def replaceConcept(self, old_sd, sd):
+ pass
+
+ def verifConditionBloc(self):
+ """
+ Evalue les conditions de tous les blocs fils possibles
+ (en fonction du catalogue donc de la definition) de self et
+ retourne deux listes :
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
+ """
+ return [], []
+
+ def verifConditionRegles(self, liste_presents):
+ """
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
+ """
+ return []
+
+ def verifExistenceSd(self):
+ pass
+
+ def controlSdprods(self, d):
+ """sans objet"""
+ pass
+
+ def close(self):
+ pass
+
+ def resetContext(self):
+ pass
+
+ def eval(self):
+ if isinstance(self.valeur, Formula):
+ return self.valeur.eval()
+ else:
+ return self.valeur
+
+ def __adapt__(self, validator):
+ return validator.adapt(self.eval())
+
+
+class COMBI_PARAMETRE(object):
+ def __init__(self, chainevaleur, valeur):
+ self.chainevaleur = chainevaleur
+ self.valeur = valeur
+
+ def __repr__(self):
+ return self.chainevaleur
+
+ def isValid(self):
+ if self.valeur and self.chainevaleur:
+ return 1
+
+
+class ITEM_PARAMETRE(object):
+ def __init__(self, param_pere, item=None):
+ self.param_pere = param_pere
+ self.item = item
+
+ def __repr__(self):
+ return self.param_pere.nom + "[" + str(self.item) + "]"
+
+ def isValid(self):
+ isValid = 1
+ if self.item < 0:
+ isValid = 0
+ try:
+ longueur = len(self.param_pere.dict_valeur) - 1
+ except:
+ longueur = 0
+ if self.item > longueur:
+ isValid = 0
+ return isValid
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+Ce module contient la classe PARAMETRE_EVAL qui sert a definir
+des objets parametres qui sont comprehensibles et donc affichables
+par EFICAS.
+Ces objets sont crees a partir de la modification du fichier de commandes
+de l'utilisateur par le parseur de fichiers Python
+"""
+# import de modules Python
+import types, re
+import traceback
+
+# import modules Eficas
+from . import interpreteur_formule
+from Accas.processing.P_CR import CR
+from Accas.extensions.eficas_translation import tr
+from . import parametre
+
+pattern_eval = re.compile(r"^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)")
+
+
+class PARAMETRE_EVAL(parametre.PARAMETRE):
+ """
+ Cette classe permet de creer des objets de type PARAMETRE_EVAL
+ cad des affectations directes evaluees dans le jeu de commandes (ex: a=EVAL('''10.*SQRT(25)'''))
+ qui sont interpretees par le parseur de fichiers Python.
+ Les objets ainsi crees constituent des parametres evalues pour le jdc
+ """
+
+ nature = "PARAMETRE_EVAL"
+ idracine = "param_eval"
+
+ def __init__(self, nom, valeur=None):
+ # parent ne peut etre qu'un objet de type JDC
+ import Accas
+
+ self.Accas_EVAL = Accas.EVAL
+ self.valeur = self.interpreteValeur(valeur)
+ self.val = valeur
+ self.nom = nom
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
+ self.definition = self
+ self.niveau = self.parent.niveau
+ self.actif = 1
+ self.state = "undetermined"
+ # Ceci est-il indispensable ???
+ # self.appel = P_utils.calleeWhere(niveau=2)
+ self.register()
+
+ def __repr__(self):
+ """
+ Donne un echo de self sous la forme nom = valeur
+ """
+ return self.nom + " = " + repr(self.valeur)
+
+ def __str__(self):
+ """
+ Retourne le nom du parametre evalue comme representation de self
+ """
+ return self.nom
+
+ def interpreteValeur(self, val):
+ """
+ Essaie d'interpreter val (chaine de caracteres ou None) comme :
+ une instance de Accas.EVAL
+ Retourne la valeur interpretee
+ """
+ if not val:
+ return None
+ d = {}
+ val = val.strip()
+ if val[-1] == ";":
+ val = val[0:-1]
+ d["EVAL"] = self.Accas_EVAL
+ try:
+ valeur = eval(val, {}, d)
+ return valeur
+ except:
+ traceback.print_exc()
+ print(("Le texte %s n'est pas celui d'un parametre evalue" % val))
+ return None
+
+ def setValeur(self, new_valeur):
+ """
+ Remplace la valeur de self par new_valeur interpretee.
+ """
+ self.valeur = self.interpreteValeur(new_valeur)
+ self.val = new_valeur
+ self.initModif()
+
+ def getNom(self):
+ """
+ Retourne le nom du parametre
+ """
+ return self.nom
+
+ def getValeur(self):
+ """
+ Retourne la valeur de self, cad le texte de l'objet class_eval.EVAL
+ """
+ if self.valeur:
+ return self.valeur.valeur
+ else:
+ return ""
+
+ def verifEval(self, exp_eval=None, cr="non"):
+ """
+ Cette methode a pour but de verifier si l'expression EVAL
+ est syntaxiquement correcte.
+ Retourne :
+ - un booleen, qui vaut 1 si licite, 0 sinon
+ - un message d'erreurs ('' si illicite)
+ """
+ if not exp_eval:
+ if self.valeur:
+ exp_eval = self.valeur.valeur[3:-3] # on enleve les triples guillemets
+ else:
+ exp_eval = None
+ if exp_eval:
+ # on construit un interpreteur de formule
+ formule = (self.nom, "", None, exp_eval)
+ # on recupere la liste des constantes et des autres fonctions predefinies
+ # et qui peuvent etre utilisees dans le corps de la formule courante
+ l_ctes, l_form = self.jdc.getParametresFonctionsAvantEtape(self)
+ # on cree un objet verificateur
+ verificateur = interpreteur_formule.Interpreteur_Formule(
+ formule=formule, constantes=l_ctes, fonctions=l_form
+ )
+ if cr == "oui":
+ if not verificateur.cr.estvide():
+ self.cr.fatal(verificateur.cr.getMessFatal())
+ return verificateur.isValid(), "".join(verificateur.cr.crfatal)
+ else:
+ # pas d'expression EVAL --> self non valide
+ if cr == "oui":
+ self.cr.fatal(tr("Le parametre EVAL %s ne peut valoir None"), self.nom)
+ return 0, tr("Le parametre EVAL ne peut valoir None")
+
+ def verifNom(self, nom=None, cr="non"):
+ """
+ Verifie si le nom passe en argument (si aucun prend le nom courant)
+ est un nom valide pour un parametre EVAL
+ Retourne :
+ - un booleen, qui vaut 1 si nom licite, 0 sinon
+ - un message d'erreurs ('' si illicite)
+ """
+ if not nom:
+ nom = self.nom
+ if nom == "":
+ if cr == "oui":
+ self.cr.fatal(tr("Pas de nom donne au parametre EVAL"))
+ return 0, "Pas de nom donne au parametre EVAL"
+ if len(nom) > 8:
+ if cr == "oui":
+ self.cr.fatal(tr("Un nom de parametre ne peut depasser 8 caracteres"))
+ return 0, "Un nom de parametre ne peut depasser 8 caracteres"
+ sd = self.parent.getSdAutourEtape(nom, self)
+ if sd:
+ if cr == "oui":
+ self.cr.fatal(tr("Un concept de nom %s existe deja !"), nom)
+ return 0, "Un concept de nom %s existe deja !" % nom
+ return 1, ""
+
+ def verifParametreEval(self, param=None, cr="non"):
+ """
+ Verifie la validite du parametre EVAL passe en argument.
+ Ce nouveau parametre est passe sous la forme d'un tuple : (nom,valeur)
+ Si aucun tuple passe, prend les valeurs courantes de l'objet
+ Retourne :
+ - un booleen, qui vaut 1 si EVAL licite, 0 sinon
+ - un message d'erreurs ('' si illicite)
+ """
+ if not param:
+ if self.valeur:
+ param = (self.nom, self.valeur.valeur)
+ else:
+ param = (self.nom, None)
+ test_nom, erreur_nom = self.verifNom(param[0], cr=cr)
+ test_eval, erreur_eval = self.verifEval(param[1], cr=cr)
+ # test global = produit des tests partiels
+ test = test_nom * test_eval
+ # message d'erreurs global = concatenation des messages partiels
+ erreur = ""
+ if not test:
+ for mess in (erreur_nom, erreur_eval):
+ erreur = erreur + (len(mess) > 0) * "\n" + mess
+ return test, erreur
+
+ def update(self, param):
+ """
+ Methode externe.
+ Met a jour les champs nom, valeur de self
+ par les nouvelles valeurs passees dans le tuple formule.
+ On stocke les valeurs SANS verifications.
+ """
+ self.initModif()
+ self.setNom(param[0])
+ self.setValeur('EVAL("""' + param[1] + '""")')
+
+ def isValid(self, cr="non"):
+ """
+ Retourne 1 si self est valide, 0 sinon
+ Un parametre evalue est considere comme valide si :
+ - il a un nom
+ - il a une valeur qui est interpretable par l'interpreteur de FORMULEs
+ """
+ resu, erreur = self.verifParametreEval(cr=cr)
+ return resu
+
+ def report(self):
+ """
+ Genere l'objet rapport (classe CR)
+ """
+ self.cr = CR()
+ self.isValid(cr="oui")
+ return self.cr
+
+ def setNom(self, new_nom):
+ """
+ Remplace le nom de self par new_nom
+ """
+ self.nom = new_nom
--- /dev/null
+from .translationQT5 import tr
+from .translationQT5 import tr_qt
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+# Installation de tous les fichiers Python du repertoire et des sous-repertoires (sauf CVS)
+install ( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ DESTINATION ${CMAKE_INSTALL_PREFIX}
+ FILES_MATCHING PATTERN *.py
+ PATTERN CVS EXCLUDE
+ )
+
+
+### Local Variables:
+### mode: cmake
+### End:
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+"""
+
+"""
+
+class ASSD(object):
+
+ """
+ Classe de base pour definir des types de structures de donnees
+ Doit_on garder tout ce qui concerne jeveux ? les concepts ?
+ """
+
+ idracine = "SD"
+
+ def __init__(self, etape=None, sd=None, reg="oui"):
+ """
+ reg est un parametre qui vaut oui ou non :
+ - si oui (défaut) : on enregistre la SD aupres du JDC
+ - si non : on ne l'enregistre pas
+ """
+ self.etape = etape
+ self.sd = sd
+ self.nom = None
+ if etape:
+ self.parent = etape.parent
+ else:
+ self.parent = CONTEXT.getCurrentStep()
+ if self.parent:
+ self.jdc = self.parent.getJdcRoot()
+ else:
+ self.jdc = None
+
+ if not self.parent:
+ self.id = None
+ elif reg == "oui":
+ self.id = self.parent.regSD(self)
+ else:
+ self.id = self.parent.o_register(self)
+ # permet de savoir si le concept a été calculé (1) ou non (0)
+ self.executed = 0
+ if self.parent:
+ self.order = self.parent.icmd
+ else:
+ self.order = 0
+ # attributs pour le Catalogue de Structure de Données
+ # "self.cata_sdj" est un attribut de classe
+ self.ptr_class_sdj = None
+ self.ptr_sdj = None
+ # construit en tant que CO('...')
+ # 0 : assd normal, 1 : type CO, 2 : type CO typé
+ self._as_co = 0
+
+ def _getSdj(self):
+ """Retourne le catalogue de SD associé au concept."""
+ if self.ptr_sdj is None:
+ cata_sdj = getattr(self, "cata_sdj", None)
+ assert cata_sdj, (
+ "The attribute 'cata_sdj' must be defined in the class %s"
+ % self.__class__.__name__
+ )
+ assert self.nom, "The attribute 'nom' has not been filled!"
+ if self.ptr_class_sdj is None:
+ self.ptr_class_sdj = importObject(cata_sdj)
+ self.ptr_sdj = self.ptr_class_sdj(nomj=self.nom)
+ return self.ptr_sdj
+
+ def _del_sdj(self):
+ """Suppression du catalogue de SD."""
+ if self.ptr_sdj is not None:
+ self.ptr_sdj.supprime(True)
+ self.ptr_sdj = None
+ self.ptr_class_sdj = None
+
+ sdj = property(_getSdj, None, _del_sdj)
+
+ def __getitem__(self, key):
+ text_error = "ASSD.__getitem__ est déprécié car la référence a l'objet ETAPE parent sera supprimée."
+ from warnings import warn
+
+ warn(text_error, DeprecationWarning, stacklevel=2)
+ return self.etape[key]
+
+ def setName(self, nom):
+ """Positionne le nom de self"""
+ self.nom = nom
+
+ def isTypCO(self):
+ """Permet de savoir si l'ASSD est issu d'un type CO.
+ Retourne:
+ 0 : ce n'est pas un type CO
+ 1 : c'est un type CO, non encore typé
+ 2 : c'est un type CO retypé
+ """
+ return self._as_co
+
+ def changeType(self, new_type):
+ """Type connu a posteriori (type CO)."""
+ self.__class__ = new_type
+ assert self._as_co != 0, "it should only be called on CO object."
+ self._as_co = 2
+
+ def getName(self):
+ """
+ Retourne le nom de self, éventuellement en le demandant au JDC
+ """
+ if not self.nom:
+ try:
+ self.nom = self.parent.getName(self) or self.id
+ except:
+ self.nom = ""
+
+ if self.nom == "sansnom" or self.nom == "":
+ self.nom = self.id
+ return self.nom
+
+ def supprime(self, force=False):
+ """
+ Cassage des boucles de références pour destruction du JDC.
+ 'force' est utilisée pour faire des suppressions complémentaires
+ (voir les formules dans P_FONCTION).
+ """
+ self.supprimeSd()
+ self.etape = None
+ self.sd = None
+ self.jdc = None
+ self.parent = None
+
+ def supprimeSd(self):
+ """Supprime la partie du catalogue de SD."""
+ # 'del self.sdj' appellerait la méthode '_getSdj()'...
+ self._del_sdj()
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitASSD(self)
+
+ def __getstate__(self):
+ """
+ Cette methode permet de pickler les objets ASSD
+ Ceci est possible car on coupe les liens avec les objets
+ parent, etape et jdc qui conduiraient a pickler de nombreux
+ objets inutiles ou non picklables.
+ En sortie, l'objet n'est plus tout a fait le même !
+ """
+ d = self.__dict__.copy()
+ for key in ("parent", "etape", "jdc"):
+ if key in d:
+ del d[key]
+ for key in list(d.keys()):
+ if key in ("_as_co",):
+ continue
+ if key[0] == "_":
+ del d[key]
+ return d
+
+ def accessible(self):
+ """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD."""
+ if CONTEXT.debug:
+ print(("| accessible ?", self.nom))
+ is_accessible = CONTEXT.getCurrentStep().sdAccessible()
+ if CONTEXT.debug:
+ print((" `- is_accessible =", repr(is_accessible)))
+ return is_accessible
+
+ def filter_context(self, context):
+ """Filtre le contexte fourni pour retirer (en gros) ce qui vient du catalogue."""
+ from .P_ENTITE import ENTITE
+ import types
+
+ ctxt = {}
+ for key, value in list(context.items()):
+ if type(value) is type:
+ continue
+ if type(value) is types.ModuleType and value.__name__.startswith("Accas"):
+ continue
+ if issubclass(type(value), type):
+ continue
+ if isinstance(value, ENTITE):
+ continue
+ ctxt[key] = value
+ return ctxt
+
+ def parLot(self):
+ """Conserver uniquement pour la compatibilite avec le catalogue v9 dans eficas."""
+ # XXX eficas
+ if not hasattr(self, "jdc") or self.jdc == None:
+ val = None
+ else:
+ val = self.jdc.parLot
+ return val == "OUI"
+
+ def getEficasAttribut(self, attribut):
+ # print ('getEficasAttribut : ', self, attribut)
+ valeur = self.etape.getMocle(attribut)
+ try:
+ valeur = self.etape.getMocle(attribut)
+ except:
+ valeur = None
+ # print (valeur)
+ return valeur
+
+ def getEficasListOfAttributs(self, listeAttributs):
+ from .P_MCLIST import MCList
+
+ # print ('getEficasListOfAttributs pour', self,listeAttributs)
+ aTraiter = (self.etape,)
+ while len(listeAttributs) > 0:
+ attribut = listeAttributs.pop(0)
+ nvListe = []
+ for mc in aTraiter:
+ try:
+ resultat = mc.getMocle(attribut)
+ if isinstance(resultat, MCList):
+ for rmc in resultat:
+ nvListe.append(rmc)
+ else:
+ nvListe.append(resultat)
+ except:
+ pass
+ aTraiter = nvListe
+ # print ('fin getEficasListOfAttributs ', nvListe)
+ return nvListe
+
+ def ajouteUnPere(self, pere):
+ # ne fait rien mais est appeler pour tous les types de ASSD
+ pass
+
+
+class assd(ASSD):
+ def __convert__(cls, valeur):
+ # On accepte les vraies ASSD et les objets 'entier' et 'reel'
+ # qui font tout pour se faire passer pour de vrais entiers/réels.
+ if isinstance(valeur, ASSD) or type(valeur) in (int, float):
+ return valeur
+ raise ValueError(_("On attend un objet concept."))
+
+ __convert__ = classmethod(__convert__)
+
+
+class not_checked(ASSD):
+ def __convert__(cls, valeur):
+ return valeur
+
+ __convert__ = classmethod(__convert__)
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+"""
+ Ce module contient la classe de definition BLOC
+ qui permet de spécifier les caractéristiques des blocs de mots clés
+"""
+
+
+import types
+import sys
+import traceback
+
+from Accas.processing import P_ENTITE
+from Accas.processing import P_MCBLOC
+from Accas.processing.P_Exception import AsException
+from Accas.processing.P_types import forceList
+
+
+class BLOC(P_ENTITE.ENTITE):
+
+ """
+ Classe pour definir un bloc de mots-cles
+
+ Cette classe a deux attributs de classe :
+
+ - class_instance qui indique la classe qui devra etre utilisée
+ pour créer l'objet qui servira à controler la conformité d'un
+ bloc de mots-clés avec sa définition
+ - label qui indique la nature de l'objet de définition (ici, BLOC)
+
+ """
+
+ class_instance = P_MCBLOC.MCBLOC
+ label = "BLOC"
+
+ def __init__(
+ self,
+ fr="",
+ docu="",
+ regles=(),
+ statut="f",
+ condition=None,
+ ang="",
+ nomXML=None,
+ exclusif=False,
+ **args
+ ):
+ """
+ Un bloc est caractérisé par les attributs suivants :
+
+ - fr : chaine de caractere commentaire pour aide en ligne (en francais)
+ - regles : liste d'objets de type REGLE pour vérifier la cohérence des sous-objets
+ - statut : obligatoire ('o') ou facultatif ('f')
+ - condition : chaine de caractère evaluable par l'interpreteur Python
+ - exclusif : ne s active pas en meme temps que ses blocs freres
+ - entites : dictionnaire contenant les sous-objets de self (mots-clés).
+ La clé du dictionnaire est le nom du mot-clé et la valeur l'objet de
+ définition correspondant. Cet attribut est initialisé avec l'argument
+ args de la méthode __init__
+
+ """
+ # Initialisation des attributs
+ self.fr = fr
+ self.ang = ang
+ self.docu = docu
+ self.fenetreIhm = None
+ self.exclusif = exclusif
+ if type(regles) == tuple:
+ self.regles = regles
+ else:
+ self.regles = (regles,)
+ self.statut = statut
+ self.condition = condition
+ self.nomXML = nomXML
+ self.entites = args
+ self.affecter_parente()
+ self.txtNomComplet = ""
+ self.possedeDejaUnMCFactorise = False
+
+ def __call__(self, val, nom, parent=None, dicoPyxbDeConstruction=None):
+ """
+ Construit un objet MCBLOC a partir de sa definition (self)
+ de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
+ """
+ return self.class_instance(
+ nom=nom,
+ definition=self,
+ val=val,
+ parent=parent,
+ dicoPyxbDeConstruction=dicoPyxbDeConstruction,
+ )
+
+ def verifCata(self):
+ """
+ Cette méthode vérifie si les attributs de définition sont valides.
+ Les éventuels messages d'erreur sont écrits dans l'objet compte-rendu (self.cr).
+ """
+ self.checkFr()
+ self.checkDocu()
+ self.checkRegles()
+ self.checkStatut(into=("f", "o"))
+ self.checkCondition()
+ self.verifCataRegles()
+
+ def verifPresence(self, dict, globs):
+ """
+ Cette méthode vérifie si le dictionnaire passé en argument (dict)
+ est susceptible de contenir un bloc de mots-clés conforme à la
+ définition qu'il porte.
+ Si la réponse est oui, la méthode retourne 1
+ Si la réponse est non, la méthode retourne 0
+
+ Le dictionnaire dict a pour clés les noms des mots-clés et pour valeurs
+ les valeurs des mots-clés
+ """
+ # On recopie le dictionnaire pour protéger l'original
+ dico = blocUtils()
+ dico.update(dict)
+ if self.condition != None:
+ try:
+ # if 1 :
+ test = eval(self.condition, globs, dico)
+ return test
+ # try:
+ # 1
+ except NameError:
+ # erreur 'normale' : un mot-clé n'est pas présent et on veut
+ # l'évaluer dans la condition
+ if CONTEXT.debug:
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ print(
+ (
+ "WARNING : Erreur a l'evaluation de la condition "
+ + "".join(l)
+ )
+ )
+ return 0
+ except SyntaxError:
+ # le texte de la condition n'est pas du Python correct -->
+ # faute de catalogue
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ raise AsException(
+ "Catalogue entite : ",
+ self.nom,
+ ", de pere : ",
+ self.pere.nom,
+ "\n",
+ "Erreur dans la condition : ",
+ self.condition,
+ "".join(l),
+ )
+ except:
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ raise AsException(
+ "Catalogue entite : ",
+ self.nom,
+ ", de pere : ",
+ self.pere.nom,
+ "\n",
+ "Erreur dans la condition : ",
+ self.condition,
+ "".join(l),
+ )
+ else:
+ return 0
+
+ def longueurDsArbre(self):
+ longueur = 0
+ for mc in self.mcListe:
+ longueur = longueur + mc.longueurDsArbre()
+ return longueur
+
+
+def blocUtils():
+ """Définit un ensemble de fonctions utilisables pour écrire les
+ conditions de BLOC."""
+
+ def au_moins_un(mcsimp, valeurs):
+ """Valide si la (ou une) valeur de 'mcsimp' est au moins une fois dans
+ la ou les 'valeurs'. Similaire à la règle AU_MOINS_UN, 'mcsimp' peut
+ contenir plusieurs valeurs."""
+ test = set(forceList(mcsimp))
+ valeurs = set(forceList(valeurs))
+ return not test.isdisjoint(valeurs)
+
+ def aucun(mcsimp, valeurs):
+ """Valide si aucune des valeurs de 'mcsimp' n'est dans 'valeurs'."""
+ return not au_moins_un(mcsimp, valeurs)
+
+ def getEficasAttribut(nomUserASSD, nomAttr):
+ if nomUserASSD == None:
+ return None
+ return nomUserASSD.getEficasAttribut(nomAttr)
+
+ def getEficasListOfAttributs(nomASSD, listeAttributs):
+ if nomASSD == None:
+ return ()
+ return nomASSD.getEficasListOfAttributs(listeAttributs)
+
+ return locals()
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+from Accas.processing.P_ASSD import ASSD
+from Accas.processing.P_Exception import AsException
+from Accas.processing import P_utils
+
+
+class CO(ASSD):
+ def __init__(self, nom):
+ ASSD.__init__(self, etape=None, sd=None, reg="oui")
+ self._as_co = 1
+ #
+ # On demande le nommage du concept
+ #
+ if self.parent:
+ try:
+ self.parent.nommerSDProd(self, nom)
+ except AsException as e:
+ appel = P_utils.calleeWhere(niveau=2)
+ raise AsException(
+ "Concept CO, fichier: ", appel[1], " ligne : ", appel[0], "\n", e
+ )
+ else:
+ self.nom = nom
+
+ def __convert__(cls, valeur):
+ if valeur.isTypCO():
+ return valeur
+ raise ValError("Pas un concept CO")
+
+ __convert__ = classmethod(__convert__)
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+"""
+ Module de conversion des valeurs saisies par l'utilisateur après vérification.
+"""
+from Accas.processing.P_types import isInt, isFloat, isSequence
+
+
+def hasIntValue(real):
+ """Est-ce que 'real' a une valeur entière ?"""
+ return abs(int(real) - real) < 1.0e-12
+
+
+class Conversion(object):
+
+ """Conversion de type."""
+
+ def __init__(self, name, typeACreer):
+ self.name = name
+ self.typeACreer = typeACreer
+
+ def convert(self, obj):
+ """Filtre liste"""
+ in_as_seq = isSequence(obj)
+ if not in_as_seq:
+ obj = (obj,)
+
+ result = []
+ for o in obj:
+ result.append(self.function(o))
+
+ if not in_as_seq:
+ return result[0]
+ else:
+ # ne marche pas avec MACR_RECAL qui attend une liste et non un
+ # tuple
+ return tuple(result)
+
+ def function(self, o):
+ raise NotImplementedError("cette classe doit être dérivée")
+
+
+class TypeConversion(Conversion):
+
+ """Conversion de typeACreer"""
+
+ def __init__(self, typeACreer):
+ Conversion.__init__(self, "type", typeACreer)
+
+
+class IntConversion(TypeConversion):
+
+ """Conversion en entier"""
+
+ def __init__(self):
+ TypeConversion.__init__(self, "I")
+
+ def function(self, o):
+ if isFloat(o) and hasIntValue(o):
+ o = int(o)
+ return o
+
+
+class FloatConversion(TypeConversion):
+
+ """Conversion de type"""
+
+ def __init__(self):
+ TypeConversion.__init__(self, "R")
+
+ def function(self, o):
+ if isFloat(o):
+ o = float(o)
+ return o
+
+
+class UserASSDConversion(TypeConversion):
+ def __init__(self, classUser):
+ TypeConversion.__init__(self, classUser)
+
+ def function(self, o):
+ # print ('je convertis : ', o, 'en ', self.typeACreer )
+ # import traceback
+ # traceback.print_stack()
+ if o == None:
+ return None
+ # print ('je cree UserASSDConversion', o, ' ', self.typeACreer)
+ nouvelObj = self.typeACreer(o)
+ return nouvelObj
+
+
+class UserASSDMultipleConversion(TypeConversion):
+ def __init__(self, classUser):
+ TypeConversion.__init__(self, classUser)
+
+ def function(self, o):
+ if o == None:
+ return None
+ # print ('je cree dans UserASSDMultipleConversion', o, ' ', self.typeACreer)
+ nouvelObj = self.typeACreer(o)
+ return nouvelObj
+
+
+_convertI = IntConversion()
+_convertR = FloatConversion()
+
+
+def ConversionFactory(name, typ):
+ if name == "type":
+ if "I" in typ:
+ return _convertI
+ elif "R" in typ:
+ return _convertR
+ if name == "UserASSD":
+ # print(typ)
+ return UserASSDConversion(typ)
+ if name == "UserASSDMultiple":
+ return UserASSDMultipleConversion(typ)
+ return None
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+""" Ce module contient la classe compte-rendu de Accas.validation
+"""
+
+
+class CR(object):
+
+ """
+ Classe servant a la construction et a l'affichage des objets Comptes-rendus
+ """
+
+ def __init__(self, verbeux="non", debut="", fin="", dec=" "):
+ """
+ Attributs
+ - verbeux
+ - debut
+ - fin
+ - dec
+ """
+ self.verbeux = verbeux
+ self.debut = debut
+ self.fin = fin
+ self.dec = dec
+ self.crok = []
+ self.crwarn = []
+ self.crfatal = []
+ self.crexception = []
+ self.subcr = []
+
+ def ok(self, comment):
+ """Ajoute un commentaire OK a la liste crok"""
+ self.crok.append(comment)
+
+ def warn(self, comment):
+ """Ajoute un commentaire Warning a la liste crwarn"""
+ self.crwarn.append(comment)
+
+ def fatal(self, comment, *args):
+ """Ajoute un commentaire Erreur Fatale a la liste crfatal a formater"""
+ self.crfatal.append(comment)
+ self.crfatal.append(str(*args))
+
+ def exception(self, comment):
+ """Ajoute un commentaire Exception a la liste crexception"""
+ self.crexception.append(comment)
+
+ def add(self, cr):
+ """Ajoute un objet CR a la liste subcr :il s'agit de l'objet CR d'un fils de self"""
+ self.subcr.append(cr)
+
+ def estvide(self):
+ """
+ Retourne 1 si self ne contient aucun message grave (fatal ou exception)
+ et aucun CR qui en contienne, 0 sinon
+ """
+ if self.crexception:
+ return 0
+ if self.crfatal:
+ return 0
+ for s in self.subcr:
+ if not s.estvide():
+ return 0
+ return 1
+
+ def purge(self):
+ """
+ Purge complètement le CR sauf les exceptions
+ """
+ self.debut = ""
+ self.fin = ""
+ self.dec = " "
+ self.crok = []
+ self.crwarn = []
+ self.crfatal = []
+ self.subcr = []
+
+ def beautifieMessages(self):
+ """
+ Beautifie les messages stockés dans crok,crfatal,crexception et crwarn
+ """
+ l = []
+ for mess in self.crok:
+ l.append(mess + "\n")
+ self.crok_belle = l
+ l = []
+ for mess in self.crwarn:
+ l.append(encadreMessage(mess, "*"))
+ self.crwarn_belle = l
+ l = []
+ for mess in self.crfatal:
+ l.append(encadreMessage(mess, "!"))
+ self.crfatal_belle = l
+ l = []
+ for mess in self.crexception:
+ l.append(encadreMessage(mess, "!"))
+ self.crexception_belle = l
+
+ def indent(self, s):
+ """
+ Insère en tete de chaque ligne du texte s la chaine self.dec
+ """
+ l = s.split("\n")
+ a = "\n" + self.dec
+ return self.dec + a.join(l)[:-3]
+
+ def __unicode__(self):
+ """
+ Retourne une chaine de caractères décorée et représentative de self
+ """
+ s = ""
+ self.beautifieMessages()
+ s = s + "".join(self.crok_belle)
+ s = s + "".join(self.crwarn_belle)
+ s = s + "".join(self.crfatal_belle)
+ s = s + "".join(self.crexception_belle)
+ for subcr in self.subcr:
+ if self.verbeux == "oui":
+ s = s + six.text_type(subcr) + "\n"
+ else:
+ if not subcr.estvide():
+ s = s + six.text_type(subcr)
+ if s != "":
+ s = self.debut + "\n" + self.indent(s) + self.fin + "\n"
+ else:
+ s = self.debut + "\n" + self.fin + "\n"
+ return s
+
+ def __str__(self):
+ """Return the report representation"""
+ txt = self.__unicode__()
+ return txt
+
+ def report(self, decalage=2):
+ """
+ Retourne une chaine de caractères non encadrée mais représentative de self
+ """
+ s = ""
+ # on stocke dans s les messages de premier niveau
+ for mess in self.crok:
+ s = s + decalage * self.dec + mess + self.dec + "\n"
+ for mess in self.crwarn:
+ s = s + decalage * self.dec + mess + self.dec + "\n"
+ for mess in self.crfatal:
+ s = s + decalage * self.dec + mess + self.dec + "\n"
+ for mess in self.crexception:
+ s = s + decalage * self.dec + mess + self.dec + "\n"
+ # on récupère les messages des sous comptes-rendus ...
+ for subcr in self.subcr:
+ if not subcr.estvide():
+ s = s + subcr.report(decalage=decalage + 1)
+ # on rajoute les flags de début et de fin ... (si self n'est pas vide)
+ if not self.estvide():
+ s = (
+ (decalage - 1) * self.dec
+ + self.debut
+ + "\n"
+ + s
+ + (decalage - 1) * self.dec
+ + self.fin
+ + "\n"
+ )
+ return s
+
+ def getMessFatal(self):
+ """
+ Retourne une chaine de caractères contenant les messages de
+ la liste crfatal (du dernier au premier)
+ """
+ self.crfatal.reverse()
+ s = ""
+ for elem in self.crfatal:
+ s = s + elem
+ self.crfatal.reverse()
+ return s
+
+ def getMessException(self):
+ """
+ Retourne une chaine de caractères contenant les messages
+ de la liste crexception (du dernier au premier)
+ """
+ self.crexception.reverse()
+ s = ""
+ for elem in self.crexception:
+ s = s + elem
+ self.crexception.reverse()
+ return s
+
+
+separateurs = (" ", ",", "/")
+
+
+def split(ligne, cesure):
+ ligne = ligne.rstrip()
+ if len(ligne) <= cesure:
+ return ligne
+ else:
+ coupure = cesure
+ while ligne[coupure] not in separateurs and coupure > 0:
+ coupure = coupure - 1
+ if coupure == 0:
+ # Il faut augmenter la cesure
+ coupure = cesure
+ while ligne[coupure] not in separateurs and coupure < len(ligne) - 1:
+ coupure = coupure + 1
+ if coupure == len(ligne) - 1:
+ return ligne
+ else:
+ return ligne[: coupure + 1] + "\n" + split(ligne[coupure + 1 :], cesure)
+
+
+def justifyText(texte="", cesure=50):
+ if not isinstance(texte, str):
+ texte = "".join(texte)
+ texte = texte.strip()
+ liste_lignes = texte.split("\n")
+ l = [split(l, cesure) for l in liste_lignes]
+ texte_justifie = "\n".join(l)
+ return texte_justifie
+
+
+def encadreMessage(texte, motif):
+ """
+ Retourne la chaine de caractères texte entourée d'un cadre formés
+ d'éléments 'motif'
+ """
+ texte = justifyText(texte, cesure=80)
+ if texte.strip() == "":
+ return ""
+ lignes = texte.split("\n")
+ longueur = 0
+ for ligne in lignes:
+ ligne = ligne.rstrip()
+ if len(ligne) > longueur:
+ longueur = len(ligne)
+ longueur = longueur + 4
+ txt = motif * longueur + "\n"
+ for ligne in lignes:
+ if ligne == "":
+ continue
+ txt = (
+ txt
+ + motif
+ + " "
+ + ligne
+ + " " * (longueur - len(motif + ligne) - 2)
+ + motif
+ + "\n"
+ )
+ txt = txt + motif * longueur + "\n"
+ return txt
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient la classe ENTITE qui est la classe de base
+ de toutes les classes de definition d'EFICAS.
+"""
+from Accas.processing import P_CR
+from Accas.processing import P_OPS
+
+import six
+
+stringTypes = (str, six.text_type)
+
+
+class ENTITE(object):
+
+ """
+ Classe de base pour tous les objets de definition : mots cles et commandes
+ Cette classe ne contient que des methodes utilitaires
+ Elle ne peut être instanciee et doit d abord être specialisee
+ """
+
+ CR = P_CR.CR
+ from Accas.processing.P_VALIDATOR import validatorFactory
+ factories = {"validator": validatorFactory}
+
+ def __init__(self, validators=None):
+ """
+ Initialise les deux attributs regles et entites d'une classe dérivée
+ à : pas de règles et pas de sous-entités.
+
+ L'attribut regles doit contenir la liste des regles qui s'appliquent
+ sur ses sous-entités
+
+ L'attribut entités doit contenir le dictionnaires des sous-entités
+ (clé = nom, valeur=objet)
+ Les attributs utiles pour la projection xsd sont aussi initialises
+ init non appele pour bloc
+ """
+ self.regles = ()
+ self.entites = {}
+ if validators:
+ self.validators = self.factories["validator"](validators)
+ else:
+ self.validators = validators
+ # self.doitSenregistrerComme = None
+ self.txtNomComplet = ""
+ self.redefinit = False
+ self.dejaPrepareDump = False
+ self.possedeDejaUnMCFactorise = False
+
+ def affecter_parente(self):
+ """
+ Cette methode a pour fonction de donner un nom et un pere aux
+ sous entités qui n'ont aucun moyen pour atteindre leur parent
+ directement
+ Il s'agit principalement des mots cles
+ """
+ for k, v in list(self.entites.items()):
+ # print( k,v)
+ v.pere = self
+ v.nom = k
+
+ def verifCata(self):
+ """
+ Cette methode sert à valider les attributs de l'objet de définition
+ """
+ raise NotImplementedError(
+ "La méthode verifCata de la classe %s doit être implémentée"
+ % self.__class__.__name__
+ )
+
+ def __call__(self):
+ """
+ Cette methode doit retourner un objet dérivé de la classe OBJECT
+ """
+
+ raise NotImplementedError(
+ "La méthode __call__ de la classe %s doit être implémentée"
+ % self.__class__.__name__
+ )
+
+ def report(self):
+ """
+ Cette méthode construit pour tous les objets dérivés de ENTITE un
+ rapport de Accas.validation de la définition portée par cet objet
+ """
+ self.cr = self.CR()
+ self.verifCata()
+ for k, v in list(self.entites.items()):
+ try:
+ cr = v.report()
+ cr.debut = "Début " + v.__class__.__name__ + " : " + k
+ cr.fin = "Fin " + v.__class__.__name__ + " : " + k
+ self.cr.add(cr)
+ except:
+ self.cr.fatal("Impossible d'obtenir le rapport de %s %s" % (k, repr(v)))
+ print(("Impossible d'obtenir le rapport de %s %s" % (k, repr(v))))
+ print(("père =", self))
+ return self.cr
+
+ def verifCataRegles(self):
+ """
+ Cette méthode vérifie pour tous les objets dérivés de ENTITE que
+ les objets REGLES associés ne portent que sur des sous-entités
+ existantes
+ """
+ for regle in self.regles:
+ l = []
+ for mc in regle.mcs:
+ if not mc in self.entites:
+ l.append(mc)
+ if l != []:
+ txt = str(regle)
+ self.cr.fatal(
+ _("Argument(s) non permis : %r pour la règle : %s"), l, txt
+ )
+
+ def checkDefinition(self, parent):
+ """Verifie la definition d'un objet composite (commande, fact, bloc)."""
+ args = self.entites.copy()
+ mcs = set()
+ for nom, val in list(args.items()):
+ if val.label == "SIMP":
+ mcs.add(nom)
+ # XXX
+ # if val.max != 1 and val.type == 'TXM':
+ # print "#CMD", parent, nom
+ elif val.label == "FACT":
+ val.checkDefinition(parent)
+ # CALC_SPEC !
+ # assert self.label != 'FACT', \
+ #'Commande %s : Mot-clef facteur present sous un mot-clef facteur : interdit !' \
+ # % parent
+ else:
+ continue
+ del args[nom]
+ # seuls les blocs peuvent entrer en conflit avec les mcs du plus haut
+ # niveau
+ for nom, val in list(args.items()):
+ if val.label == "BLOC":
+ mcbloc = val.checkDefinition(parent)
+ # XXX
+ assert mcs.isdisjoint(
+ mcbloc
+ ), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" % (
+ parent,
+ tuple(mcs.intersection(mcbloc)),
+ )
+ return mcs
+
+ def checkOp(self, valmin=-9999, valmax=9999):
+ """Vérifie l'attribut op."""
+ if self.op is not None and (
+ type(self.op) is not int or self.op < valmin or self.op > valmax
+ ):
+ self.cr.fatal(
+ _("L'attribut 'op' doit être un entier " "compris entre %d et %d : %r"),
+ valmin,
+ valmax,
+ self.op,
+ )
+
+ def checkProc(self):
+ """Vérifie l'attribut proc."""
+ if self.proc is not None and not isinstance(self.proc, P_OPS.OPS):
+ self.cr.fatal(
+ _("L'attribut op doit être une instance d'OPS : %r"), self.proc
+ )
+
+ def checkRegles(self):
+ """Vérifie l'attribut regles."""
+ if type(self.regles) is not tuple:
+ self.cr.fatal(_("L'attribut 'regles' doit être un tuple : %r"), self.regles)
+
+ def checkFr(self):
+ """Vérifie l'attribut fr."""
+ if type(self.fr) not in stringTypes:
+ self.cr.fatal(
+ _("L'attribut 'fr' doit être une chaine de caractères : %r"), self.fr
+ )
+
+ def checkDocu(self):
+ """Vérifie l'attribut docu."""
+ if type(self.docu) not in stringTypes:
+ self.cr.fatal(
+ _("L'attribut 'docu' doit être une chaine de caractères : %r"),
+ self.docu,
+ )
+
+ def checkNom(self):
+ """Vérifie l'attribut proc."""
+ if type(self.nom) is not str:
+ self.cr.fatal(
+ _("L'attribut 'nom' doit être une chaine de caractères : %r"), self.nom
+ )
+
+ def checkReentrant(self):
+ """Vérifie l'attribut reentrant."""
+ if self.reentrant not in ("o", "n", "f"):
+ self.cr.fatal(
+ _("L'attribut 'reentrant' doit valoir 'o','n' ou 'f' : %r"),
+ self.reentrant,
+ )
+
+ def checkStatut(self, into=("o", "f", "c", "d")):
+ """Vérifie l'attribut statut."""
+ if self.statut not in into:
+ self.cr.fatal(
+ _("L'attribut 'statut' doit être parmi %s : %r"), into, self.statut
+ )
+
+ def checkCondition(self):
+ """Vérifie l'attribut condition."""
+ if self.condition != None:
+ if type(self.condition) is not str:
+ self.cr.fatal(
+ _("L'attribut 'condition' doit être une chaine de caractères : %r"),
+ self.condition,
+ )
+ else:
+ self.cr.fatal(_("La condition ne doit pas valoir None !"))
+
+ def checkMinMax(self):
+ """Vérifie les attributs min/max."""
+ if type(self.min) != int:
+ if self.min != "**" and self.min != float("-inf"):
+ self.cr.fatal(_("L'attribut 'min' doit être un entier : %r"), self.min)
+ if type(self.max) != int:
+ if self.max != "**" and self.max != float("inf"):
+ self.cr.fatal(_("L'attribut 'max' doit être un entier : %r"), self.max)
+ if self.min > self.max:
+ self.cr.fatal(
+ _("Nombres d'occurrence min et max invalides : %r %r"),
+ self.min,
+ self.max,
+ )
+
+ def checkValidators(self):
+ """Vérifie les validateurs supplémentaires"""
+ if self.validators and not self.validators.verifCata():
+ self.cr.fatal(
+ _("Un des validateurs est incorrect. Raison : %s"),
+ self.validators.cata_info,
+ )
+
+ def checkHomo(self):
+ """Vérifie l'attribut homo."""
+ if self.homo != 0 and self.homo != 1:
+ self.cr.fatal(_("L'attribut 'homo' doit valoir 0 ou 1 : %r"), self.homo)
+
+ def checkInto(self):
+ """Vérifie l'attribut into."""
+ if self.into != None:
+ if (type(self.into) not in (list, tuple)) and (
+ type(self.into) != types.FunctionType
+ ):
+ self.cr.fatal(_("L'attribut 'into' doit être un tuple : %r"), self.into)
+
+ def checkPosition(self):
+ """Vérifie l'attribut position."""
+ if self.position not in (
+ "local",
+ "global",
+ "global_jdc",
+ "inGetAttribut",
+ "reCalculeEtape",
+ ):
+ self.cr.fatal(
+ _(
+ "L'attribut 'position' doit valoir 'local', 'global' ,'global_jdc', 'inGetAttribut', 'reCalculeEtape' "
+ "ou 'global_jdc' : %r"
+ ),
+ self.position,
+ )
+
+ def nomComplet(self):
+ if self.txtNomComplet != "":
+ return self.txtNomComplet
+ qui = self
+ while hasattr(qui, "pere"):
+ self.txtNomComplet += "_" + qui.nom
+ qui = qui.pere
+ self.txtNomComplet += "_" + qui.nom
+ return self.txtNomComplet
+
+ def geneaCompleteSousFormeDeListe(self):
+ geneaCompleteSousFormeDeListe = []
+ qui = self
+ while hasattr(qui, "pere"):
+ geneaCompleteSousFormeDeListe.append(qui)
+ qui = qui.pere
+ geneaCompleteSousFormeDeListe.append(qui)
+ return geneaCompleteSousFormeDeListe
+
+ def addDefinitionMC(self, listeMCAvant, **args):
+ ouChercher = self
+ for mot in listeMCAvant:
+ try:
+ ouChercher = ouChercher.entites[mot]
+ except:
+ print("impossible de trouver : ", mot, " ", listeMCAvant)
+ (nomMC, defMC) = args.items()[0]
+ defMC.pere = ouChercher
+ defMC.pere.propageRedefinit()
+ defMC.nom = nomMC
+ cata = CONTEXT.getCurrentCata()
+ # print (cata)
+ ouChercher.entites[nomMC] = defMC
+
+ def changeDefinitionMC(self, listeMCAvant, **args):
+ ouChercher = self
+ for mot in listeMCAvant:
+ try:
+ ouChercher = ouChercher.entites[mot]
+ except:
+ print("impossible de trouver : ", mot, " ", listeMCAvant)
+ monSIMP = ouChercher
+ for nomAttributDef, valeurAttributDef in args.items():
+ if hasattr(monSIMP, nomAttributDef):
+ setattr(monSIMP, nomAttributDef, valeurAttributDef)
+ else:
+ print("pb avec ", nomAttributdef, valeurAttributMC)
+ monSIMP.propageRedefinit()
+
+ def propageRedefinit(self):
+ # a reflechir
+ self.redefinit = True
+ # PNPN il faut remonter a l etape
+
+ def makeObjetPourVerifSignature(self, *args, **kwargs):
+ etape = self.class_instance(oper=self, args=kwargs)
+ etape.MCBuild()
+ return etape
+
+ def dumpStringDataBase(self, dPrimaryKey, dElementsRecursifs, dictKey, inBloc):
+ # ne fonctionne que
+ # on admet que si un FACT a une primaryKey, elle existe dans celui-ci
+ # ou que il s agit d un motclef frere/oncle place avant
+ # derivee pour P_SIMP et P_FACT
+ debug = True
+ if debug:
+ print("****** traitement de ", self.nom)
+ if debug:
+ print(
+ "dElementsRecursifs",
+ dElementsRecursifs,
+ )
+ if debug:
+ print(
+ "dPrimaryKey",
+ dPrimaryKey,
+ )
+ texte = ""
+ texteDesFactTables = ""
+ if debug:
+ print("dictKey", dictKey)
+ if (self.label == "OPER") or (self.label == "PROC"):
+ for mc in dPrimaryKey.values():
+ dictKey[mc] = None
+ texte = "CREATE TABLE IF NOT EXISTS {} (\n".format(self.nom)
+ for mc in self.entites.values():
+ if mc.label == "SIMP":
+ texteMC = mc.dumpStringDataBase(inBloc)
+ texte += texteMC
+ if mc.nom in dictKey:
+ dictKey[mc.nom] = (texteMC, self.nom)
+ elif mc.label == "FACT":
+ if mc.nom in dElementsRecursifs:
+ texte += mc.dumpStringDataBase(
+ dPrimaryKey, dElementsRecursifs, dictKey, inBloc
+ )
+ else:
+ texteDesFactTables += mc.dumpStringDataBase(
+ dPrimaryKey, dElementsRecursifs, dictKey, inBloc
+ )
+ else:
+ texte += mc.dumpStringDataBase(
+ dPrimaryKey, dElementsRecursifs, dictKey, inBloc
+ )
+ if self.label == "BLOC":
+ for mc in self.entites.values():
+ texte += m.dumpStringDataBase(
+ dPrimaryKey, dElementsRecursifs, inBloc, dictKey
+ )
+ # on enleve la derniere ','
+ texte = texte[0:-3]
+ texte += "\n"
+ if (self.label == "OPER") or (self.label == "PROC"):
+ if self.nom in dPrimaryKey:
+ texte += "\tPRIMARY KEY ({}), \n".format(dPrimaryKey[self.nom])
+ texte += ");\n"
+ texte += texteDesFactTables
+ return texte
+
+ def dumpGitStringFormat(self):
+ texte = ""
+ if self.label == "SIMP":
+ texte += "<ns1:{}>".format(self.nom)
+ texte += "%{}".format(self.fr)
+ texte += "</ns1:{}>".format(self.nom)
+ else:
+ if self.label == "FACT":
+ texte += "<ns1:{}>".format(self.nom)
+ for c in self.entites.values():
+ texte += c.dumpGitStringFormat()
+ if self.label == "FACT":
+ texte += "</ns1:{}>".format(self.nom)
+ return texte
+
+ def dumpStructure(self, decal=0):
+ if self.label == "SIMP":
+ texte = decal * " " + self.nom + " \n"
+ return texte
+ texte = decal * " " + self.nom
+ if self.label == "BLOC":
+ texte += " " + self.condition
+ if self.label == "OPER":
+ texte + " " + str(self.sd_prod) + "\n"
+ texte += " \n"
+ for c in self.entites.values():
+ texte += c.dumpStructure(decal + 1)
+ texte += decal * " " + "fin pour " + self.nom + " \n"
+ return texte
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+"""
+ Ce module contient la classe ETAPE qui sert a verifier et a executer
+ une commande
+"""
+
+# Modules Python
+
+import types
+import sys
+import os
+import linecache
+import traceback
+from copy import copy
+
+# Modules EFICAS
+from Accas.processing import P_MCCOMPO
+from Accas.processing.P_Exception import AsException
+from Accas.processing import P_utils
+from Accas.processing.P_utils import AsType
+from Accas.processing.P_ASSD import ASSD
+
+
+class ETAPE(P_MCCOMPO.MCCOMPO):
+
+ """
+ Cette classe herite de MCCOMPO car ETAPE est un OBJECT composite
+
+ """
+
+ nature = "OPERATEUR"
+
+ # L'attribut de classe codex est utilise pour rattacher le module de calcul eventuel (voir Build)
+ # On le met a None pour indiquer qu'il n'y a pas de module de calcul
+ # rattache
+ codex = None
+
+ def __init__(self, oper=None, reuse=None, args={}, niveau=4):
+ """
+ Attributs :
+ - definition : objet portant les attributs de definition d'une etape de type operateur. Il
+ est initialise par l'argument oper.
+ - reuse : indique le concept d'entree reutilise. Il se trouvera donc en sortie
+ si les conditions d'execution de l'operateur l'autorise
+ - valeur : arguments d'entree de type mot-cle=valeur. Initialise avec l'argument args.
+ - objPyxbDeConstruction
+ """
+ # faut il le faire ds MC_Build ?
+ # traitement de Pyxb si Pyxb
+ self.dicoPyxbDeConstruction = args.get("dicoPyxbDeConstruction", None)
+ if self.dicoPyxbDeConstruction:
+ del args["dicoPyxbDeConstruction"]
+ self.objPyxbDeConstruction = self.dicoPyxbDeConstruction["objEnPyxb"]
+ else:
+ self.objPyxbDeConstruction = None
+ self.definition = oper
+ self.reuse = reuse
+ self.valeur = args
+ self.nettoiargs()
+ self.parent = CONTEXT.getCurrentStep()
+ self.etape = self
+ self.nom = oper.nom
+ self.idracine = oper.label
+ self.appel = P_utils.calleeWhere(niveau)
+ self.mc_globaux = {}
+ self.doitEtreRecalculee = False
+ self.sd = None
+ self.actif = 1
+ self.makeRegister()
+ self.icmd = None
+ self.userASSDCrees = []
+
+ def makeRegister(self):
+ """
+ Initialise les attributs jdc, id, niveau et realise les
+ enregistrements necessaires
+ surcharge dans Ihm
+ """
+ # print ('makeRegister de ETAPE')
+ if self.parent:
+ self.jdc = self.parent.getJdcRoot()
+ self.id = self.parent.register(self)
+ self.niveau = None
+ else:
+ self.jdc = self.parent = None
+ self.id = None
+ self.niveau = None
+
+ def nettoiargs(self):
+ """
+ Cette methode a pour fonction de retirer tous les arguments egaux a None
+ de la liste des arguments. Ils sont supposes non presents et donc retires.
+ """
+ for k in list(self.valeur.keys()):
+ if self.valeur[k] == None:
+ del self.valeur[k]
+
+ def MCBuild(self):
+ """
+ Demande la construction des sous-objets et les stocke dans l'attribut
+ mcListe.
+ """
+ self.mcListe = self.buildMc()
+
+ def buildSd(self, nom):
+ """
+ Construit le concept produit de l'operateur. Deux cas
+ peuvent se presenter :
+
+ - le parent n'est pas defini. Dans ce cas, l'etape prend en charge la creation
+ et le nommage du concept.
+
+ - le parent est defini. Dans ce cas, l'etape demande au parent la creation et
+ le nommage du concept.
+
+ """
+ self.sdnom = nom
+ try:
+ if self.parent:
+ sd = self.parent.createSdprod(self, nom)
+ if type(self.definition.op_init) == types.FunctionType:
+ self.definition.op_init(*(self, self.parent.g_context))
+ else:
+ sd = self.getSdProd()
+ # On n'utilise pas self.definition.op_init car self.parent
+ # n'existe pas
+ if sd != None and self.reuse == None:
+ # On ne nomme le concept que dans le cas de non reutilisation
+ # d un concept
+ sd.setName(nom)
+ except AsException as e:
+ raise AsException(
+ "Etape ",
+ self.nom,
+ "ligne : ",
+ self.appel[0],
+ "fichier : ",
+ self.appel[1],
+ e,
+ )
+ except EOFError:
+ raise
+ except:
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ raise AsException(
+ "Etape ",
+ self.nom,
+ "ligne : ",
+ self.appel[0],
+ "fichier : ",
+ self.appel[1] + "\n",
+ "".join(l),
+ )
+
+ self.Execute()
+ return sd
+
+ def Execute(self):
+ """
+ Cette methode est un point d'entree prevu pour realiser une execution immediatement
+ apres avoir construit les mots cles et le concept produit.
+ Par defaut, elle ne fait rien. Elle doit etre surchargee dans une autre partie du programme.
+ """
+ return
+
+ def getSdProd(self):
+ """
+ Retourne le concept resultat de l'etape
+ Deux cas :
+ - cas 1 : sd_prod de oper n'est pas une fonction
+ il s'agit d'une sous classe de ASSD
+ on construit le sd a partir de cette classe
+ et on le retourne
+ - cas 2 : il s'agit d'une fonction
+ on l'evalue avec les mots-cles de l'etape (mcListe)
+ on construit le sd a partir de la classe obtenue
+ et on le retourne
+ """
+ if type(self.definition.sd_prod) == types.FunctionType:
+ d = self.creeDictValeurs(self.mcListe)
+ try:
+ sd_prod = self.definition.sd_prod(*(), **d)
+ except EOFError:
+ raise
+ except Exception as exc:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ raise AsException(
+ "impossible d affecter un type au resultat:", str(exc)
+ )
+ else:
+ sd_prod = self.definition.sd_prod
+ # on teste maintenant si la SD est reutilisee ou s'il faut la creer
+ if self.definition.reentrant != "n" and self.reuse:
+ # Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale.
+ # Elle sera traitee ulterieurement.
+ self.sd = self.reuse
+ else:
+ self.sd = sd_prod(etape=self)
+ # Si l'operateur est obligatoirement reentrant et reuse n'a pas ete specifie, c'est une erreur.
+ # On ne fait rien ici. L'erreur sera traiter par la suite.
+ # precaution
+ if self.sd is not None and not isinstance(self.sd, ASSD):
+ raise AsException(
+ """
+Impossible de typer le resultat !
+Causes possibles :
+ Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,
+ soit il y a une "," a la fin d'une commande precedente.
+ Developpeur : La fonction "sd_prod" retourne un type invalide."""
+ )
+ return self.sd
+
+ def getType_produit(self):
+ try:
+ return self.getType_produit_brut()
+ except:
+ return None
+
+ def getType_produit_brut(self):
+ """
+ Retourne le type du concept resultat de l'etape
+ Deux cas :
+ - cas 1 : sd_prod de oper n'est pas une fonction
+ il s'agit d'une sous classe de ASSD
+ on retourne le nom de la classe
+ - cas 2 : il s'agit d'une fonction
+ on l'evalue avec les mots-cles de l'etape (mcListe)
+ et on retourne son resultat
+ """
+ if type(self.definition.sd_prod) == types.FunctionType:
+ d = self.creeDictValeurs(self.mcListe)
+ sd_prod = self.definition.sd_prod(*(), **d)
+ else:
+ sd_prod = self.definition.sd_prod
+ return sd_prod
+
+ def getEtape(self):
+ """
+ Retourne l'etape a laquelle appartient self
+ Un objet de la categorie etape doit retourner self pour indiquer que
+ l'etape a ete trouvee
+ """
+ return self
+
+ def supprime(self):
+ """
+ Methode qui supprime toutes les references arrières afin que l'objet puisse
+ etre correctement detruit par le garbage collector
+ """
+ P_MCCOMPO.MCCOMPO.supprime(self)
+ self.jdc = None
+ self.appel = None
+ for name in dir(self):
+ if name.startswith("_cache_"):
+ setattr(self, name, None)
+ if self.sd:
+ self.sd.supprime()
+
+ def __del__(self):
+ pass
+
+ def getCreated_sd(self):
+ """Retourne la liste des sd reellement produites par l'etape.
+ Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans
+ cette liste."""
+ if not self.reuse and self.sd:
+ return [
+ self.sd,
+ ]
+ return []
+
+ def isActif(self):
+ """
+ Indique si l'etape est active (1) ou inactive (0)
+ """
+ return self.actif
+
+ def setCurrentStep(self):
+ """
+ Methode utilisee pour que l etape self se declare etape
+ courante. Utilise par les macros
+ """
+ cs = CONTEXT.getCurrentStep()
+ if self.parent != cs:
+ raise AsException(
+ "L'etape courante",
+ cs.nom,
+ cs,
+ "devrait etre le parent de",
+ self.nom,
+ self,
+ )
+ else:
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(self)
+
+ def resetCurrentStep(self):
+ """
+ Methode utilisee par l'etape self qui remet son etape parent comme
+ etape courante
+ """
+ cs = CONTEXT.getCurrentStep()
+ if self != cs:
+ raise AsException(
+ "L'etape courante", cs.nom, cs, "devrait etre", self.nom, self
+ )
+ else:
+ CONTEXT.unsetCurrentStep()
+ CONTEXT.setCurrentStep(self.parent)
+
+ def issubstep(self, etape):
+ """
+ Cette methode retourne un entier indiquant si etape est une
+ sous etape de self ou non
+ 1 = oui
+ 0 = non
+ Une etape simple n'a pas de sous etape
+ """
+ return 0
+
+ def getFile(self, unite=None, fic_origine="", fname=None):
+ """
+ Retourne le nom du fichier correspondant a un numero d'unite
+ logique (entier) ainsi que le source contenu dans le fichier
+ """
+ if self.jdc:
+ return self.jdc.getFile(unite=unite, fic_origine=fic_origine, fname=fname)
+ else:
+ if unite != None:
+ if os.path.exists("fort." + str(unite)):
+ fname = "fort." + str(unite)
+ if fname == None:
+ raise AsException(
+ "Impossible de trouver le fichier correspondant"
+ " a l unite %s" % unite
+ )
+ if not os.path.exists(fname):
+ raise AsException("%s n'est pas un fichier existant" % unite)
+ fproc = open(fname, "r")
+ text = fproc.read()
+ fproc.close()
+ text = text.replace("\r\n", "\n")
+ linecache.cache[fname] = 0, 0, text.split("\n"), fname
+ return fname, text
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitETAPE(self)
+
+ def updateContext(self, d):
+ """
+ Cette methode doit updater le contexte fournit par
+ l'appelant en argument (d) en fonction de sa definition
+ """
+ if type(self.definition.op_init) == types.FunctionType:
+ self.definition.op_init(*(self, d))
+ if self.sd:
+ d[self.sd.nom] = self.sd
+
+ def copy(self):
+ """Methode qui retourne une copie de self non enregistree auprès du JDC
+ et sans sd
+ """
+ etape = copy(self)
+ etape.sd = None
+ etape.state = "modified"
+ etape.reuse = None
+ etape.sdnom = None
+ etape.etape = etape
+ etape.mcListe = []
+ for objet in self.mcListe:
+ new_obj = objet.copy()
+ new_obj.reparent(etape)
+ etape.mcListe.append(new_obj)
+ return etape
+
+ def copyReuse(self, old_etape):
+ """Methode qui copie le reuse d'une autre etape."""
+ if hasattr(old_etape, "reuse"):
+ self.reuse = old_etape.reuse
+
+ def copySdnom(self, old_etape):
+ """Methode qui copie le sdnom d'une autre etape."""
+ if hasattr(old_etape, "sdnom"):
+ self.sdnom = old_etape.sdnom
+
+ def reparent(self, parent):
+ """
+ Cette methode sert a reinitialiser la parente de l'objet
+ """
+ self.parent = parent
+ self.jdc = parent.getJdcRoot()
+ self.etape = self
+ for mocle in self.mcListe:
+ mocle.reparent(self)
+ if self.sd and self.reuse == None:
+ self.sd.jdc = self.jdc
+
+ def getCmd(self, nomcmd):
+ """
+ Methode pour recuperer la definition d'une commande
+ donnee par son nom dans les catalogues declares
+ au niveau du jdc
+ Appele par un ops d'une macro en Python
+ """
+ return self.jdc.getCmd(nomcmd)
+
+ def copyIntern(self, etape):
+ """
+ Methode permettant lors du processus de recopie de copier
+ les elements internes d'une etape dans une autre
+ """
+ return
+
+ def fullCopy(self, parent=None):
+ """
+ Methode permettant d'effectuer une copie complète
+ d'une etape (y compris concept produit, elements internes)
+ Si l'argument parent est fourni, la nouvelle etape
+ aura cet objet comme parent.
+ """
+ new_etape = self.copy()
+ new_etape.copyReuse(self)
+ new_etape.copySdnom(self)
+ if parent:
+ new_etape.reparent(parent)
+ if self.sd:
+ new_sd = self.sd.__class__(etape=new_etape)
+ new_etape.sd = new_sd
+ if self.reuse == None:
+ new_etape.parent.nommerSDProd(new_sd, self.sd.nom)
+ else:
+ new_sd.setName(self.sd.nom)
+ new_etape.copyIntern(self)
+ return new_etape
+
+ def resetJdc(self, new_jdc):
+ """
+ Reinitialise le nommage du concept de l'etape lors d'un changement de jdc
+ """
+ if self.sd and self.reuse == None:
+ self.parent.nommerSDProd(self.sd, self.sd.nom)
+
+ def isInclude(self):
+ """Permet savoir si on a affaire a la commande INCLUDE
+ car le comportement de ces macros est particulier.
+ """
+ return self.nom.startswith("INCLUDE")
+
+ def sdAccessible(self):
+ """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'etape."""
+ if CONTEXT.debug:
+ print(("`- ETAPE sdAccessible :", self.nom))
+ return self.parent.sdAccessible()
+
+ def getConcept(self, nomsd):
+ """
+ Methode pour recuperer un concept a partir de son nom
+ """
+ # pourrait etre appelee par une commande fortran faisant appel a des fonctions python
+ # on passe la main au parent
+ return self.parent.getConcept(nomsd)
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+"""
+ Ce module contient la classe AsException
+"""
+# Modules EFICAS
+
+from .strfunc import getEncoding, toUnicode
+import six
+
+
+class AsException(Exception):
+ def __unicode__(self):
+ args = []
+ for x in self.args:
+ ustr = toUnicode(x)
+ if type(ustr) is not six.text_type:
+ ustr = six.text_type(repr(x))
+ args.append(ustr)
+ return " ".join(args)
+
+ def __str__(self):
+ return six.text_type(self).encode(getEncoding())
+
+
+class InterruptParsingError(Exception):
+
+ """Exception used to interrupt the parsing of the command file
+ without raising an error (see P_JDC.execCompile for usage)"""
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+""" Ce module contient la classe de definition FACT
+ qui permet de spécifier les caractéristiques des mots clés facteurs
+"""
+import types
+
+from Accas.processing import P_ENTITE
+from Accas.processing import P_MCFACT
+from Accas.processing import P_MCLIST
+from Accas.processing.P__F import _F
+from Accas.processing.P_types import isSequence
+
+from Accas.processing import P_OBJECT
+
+
+class FACT(P_ENTITE.ENTITE):
+
+ """
+ Classe pour definir un mot cle facteur
+
+ Cette classe a trois attributs de classe
+
+ - class_instance qui indique la classe qui devra etre utilisée
+ pour créer l'objet qui servira à controler la conformité d'un
+ mot-clé facteur avec sa définition
+
+ - list_instance
+
+ - label qui indique la nature de l'objet de définition (ici, FACT)
+ """
+
+ class_instance = P_MCFACT.MCFACT
+ list_instance = P_MCLIST.MCList
+ label = "FACT"
+
+ def __init__( self, fr="", docu="", regles=(), statut="f", defaut=None, ang="",
+ fenetreIhm=None, min=0, max=1, validators=None, nomXML=None,
+ **args
+ ):
+ """
+ Un mot-clé facteur est caractérisé par les attributs suivants :
+
+ - fr :
+ - statut :
+ - defaut :
+ - regles
+ - min
+ - max
+ - position
+ - docu
+ - fenetreIhm
+ """
+ P_ENTITE.ENTITE.__init__(self, validators)
+ # Initialisation des attributs
+ self.fr = fr
+ self.ang = ang
+ self.docu = docu
+ if type(regles) == tuple:
+ self.regles = regles
+ else:
+ self.regles = (regles,)
+ self.statut = statut
+ self.defaut = defaut
+ self.min = min
+ self.max = max
+ if self.max == "**":
+ self.max = float("inf")
+ if self.min == "**":
+ self.min = float("-inf")
+ self.entites = args
+ self.position = None
+ self.affecter_parente()
+ self.fenetreIhm = fenetreIhm
+ self.nomXML = nomXML
+
+ def __call__(self, val, nom, parent, dicoPyxbDeConstruction=None):
+ """
+ Construit la structure de donnee pour un mot cle facteur a partir
+ de sa definition (self) de sa valeur (val), de son nom (nom) et de
+ son parent dans l arboresence (parent)
+
+ Suivant le type de la valeur on retournera soit un objet de type
+ MCFACT soit une liste de type MCLIST.
+
+ La creation d un mot cle facteur depend de son statut
+ - Si statut ='o' il est obligatoire
+ - Si statut == 'd' il est facultatif mais ses sous mots cles avec
+ defaut sont visibles
+ - Si statut == 'f' il est facultatif et ses sous mots avec defaut ne
+ sont pas visibles
+ - Si statut == 'c' il est cache ???
+ - Si defaut != None, on utilise cette valeur pour calculer la valeur
+ par defaut du mot cle facteur
+ """
+ if val is None:
+ if self.defaut == None:
+ val = {}
+ elif type(self.defaut) == tuple:
+ val = self.defaut
+ # Est ce utile ? Le défaut pourrait etre uniquement un dict
+ elif type(self.defaut) == dict or isinstance(self.defaut, _F):
+ val = self.defaut
+ else:
+ # On ne devrait jamais passer par la
+ print("On ne devrait jamais passer par la")
+ return None
+ elif isSequence(val) and len(val) == 0 and self.statut == "o":
+ # On est dans le cas où le mcfact est présent mais est une liste/tuple
+ # vide. Il est obligatoire donc on l'initialise. Les règles, mots-clés
+ # obligatoires diront si un mcfact vide est accepté.
+ val = {}
+
+ # On cree toujours une liste de mcfact
+ l = self.list_instance()
+ l.init(nom=nom, parent=parent)
+ if type(val) in (tuple, list, self.list_instance):
+ indice = 0
+ for v in val:
+ if type(v) == dict or isinstance(v, _F):
+ if dicoPyxbDeConstruction:
+ objet = self.class_instance(
+ nom=nom,
+ definition=self,
+ val=v,
+ parent=parent,
+ dicoPyxbDeConstruction=dicoPyxbDeConstruction[indice],
+ )
+ else:
+ objet = self.class_instance(
+ nom=nom,
+ definition=self,
+ val=v,
+ parent=parent,
+ dicoPyxbDeConstruction=None,
+ )
+ indice = indice + 1
+ l.append(objet)
+ elif isinstance(v, self.class_instance):
+ # if faut gerer ici --> on passe la avec une liste de concept ?
+ # PNPN --> si pyxb
+ l.append(v)
+ else:
+ l.append(P_OBJECT.ErrorObj(self, v, parent, nom))
+ elif type(val) == dict or isinstance(val, _F):
+ if dicoPyxbDeConstruction:
+ objet = self.class_instance(
+ nom=nom,
+ definition=self,
+ val=val,
+ parent=parent,
+ dicoPyxbDeConstruction=dicoPyxbDeConstruction,
+ )
+ else:
+ objet = self.class_instance(
+ nom=nom,
+ definition=self,
+ val=val,
+ parent=parent,
+ dicoPyxbDeConstruction=None,
+ )
+ l.append(objet)
+ elif isinstance(val, self.class_instance):
+ # idem --> quand passe t on la
+ l.append(val)
+ else:
+ l.append(P_OBJECT.ErrorObj(self, val, parent, nom))
+ # pour tenir compte du validateFonction
+ if l.jdc:
+ l.cata = l.jdc.cata
+ l.buildObjPyxb(l)
+ return l
+
+ def verifCata(self):
+ self.checkMinMax()
+ self.checkFr()
+ self.checkRegles()
+ self.checkStatut()
+ self.checkDocu()
+ self.checkValidators()
+ self.verifCataRegles()
+
+ def dumpStringDataBase(self, dPrimaryKey, dElementsRecursifs, dictKey, inBloc):
+ # ne fonctionne que
+ # on admet que si un FACT a une primaryKey, elle existe dans celui-ci
+ # ou que il s agit d un motclef frere/oncle place avant
+ debug = True
+ if debug:
+ print("****** traitement de FACT ", self.nom)
+ if debug:
+ print(
+ "dElementsRecursifs",
+ dElementsRecursifs,
+ )
+ if debug:
+ print(
+ "dPrimaryKey",
+ dPrimaryKey,
+ )
+ if debug:
+ print("dictKey", dictKey)
+ texte = "CREATE TABLE IF NOT EXISTS {} (\n".format(self.nom)
+ texteForeignKey = ""
+ textePrimaryKey = ""
+ texteDesFactTables = ""
+ if self.nom in dElementsRecursifs:
+ return "\t{} XML ,\n".format(self.nom)
+ if self.nom in dPrimaryKey:
+ if debug:
+ print("FACT ", self.nom, " attend une primary key")
+ if dPrimaryKey[self.nom] not in self.entites.values():
+ if dictKey[dPrimaryKey[self.nom]] == None:
+ texte += "PB SUR LA PRIMARY KEY DE {}\n".format(self.nom)
+ elif dPrimaryKey[self.nom] not in dictKey:
+ texte += "PB SUR LA PRIMARY KEY DE {}\n".format(self.nom)
+ else:
+ texte += dictKey[dPrimaryKey[self.nom]][0]
+ textePrimaryKey = "\tPRIMARY KEY ({}), \n".format(
+ dPrimaryKey[self.nom]
+ )
+ texteForeignKey = (
+ "\tFOREIGN KEY ({}) REFERENCES {} ({}), \n".format(
+ dPrimaryKey[self.nom],
+ dictKey[dPrimaryKey[self.nom]][1],
+ dPrimaryKey[self.nom],
+ )
+ )
+ for mc in self.entites.values():
+ if mc.label == "SIMP":
+ texteMC = mc.dumpStringDataBase(inBloc)
+ texte += texteMC
+ if mc.nom in dictKey:
+ dictKey[mc.nom] = (texteMC, self.nom)
+ elif mc.label == "FACT":
+ if mc.nom in dElementsRecursifs:
+ texte += mc.dumpStringDataBase(
+ dPrimaryKey, dElementsRecursifs, dictKey, inBloc
+ )
+ else:
+ texteDesFactTables += mc.dumpStringDataBase(
+ dPrimaryKey, dElementsRecursifs, dictKey, inBloc
+ )
+ else:
+ texte += mc.dumpStringDataBase(
+ dPrimaryKey, dElementsRecursifs, dictKey, inBloc
+ )
+ texte += textePrimaryKey
+ texte += texteForeignKey
+ texte = texte[0:-3]
+ texte += "\n);\n"
+ texte += texteDesFactTables
+ return texte
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+# Attention : cet import permet d'avoir, en Python, le comportement
+# de la division réelle pour les entiers, et non la division entière
+# 1/2=0.5 (et non 0). Comportement par défaut dans Python 3.0.
+
+from builtins import zip
+from builtins import str
+from math import sin, cos, tan, asin, acos, atan2, atan, sinh, cosh, tanh
+from math import pi, exp, log, log10, sqrt
+from Accas.processing.P_ASSD import ASSD
+
+class FONCTION(ASSD):
+ pass
+
+class formule(ASSD):
+ def __init__(self, *args, **kwargs):
+ ASSD.__init__(self, *args, **kwargs)
+ self.nompar = None
+ self.expression = None
+ ctxt = {}
+ ctxt.update(getattr(self.parent, "const_context", {}))
+ ctxt.update(getattr(self.parent, "macro_const_context", {}))
+ self.parent_context = self.filter_context(ctxt)
+
+ def __call__(self, *val):
+ """Evaluation de la formule"""
+ # en POURSUITE, self.parent_context is None, on essaie de reprendre
+ # const_context
+ context = getattr(self, "parent_context") or getattr(
+ self.parent, "const_context", {}
+ )
+ for param, value in zip(self.nompar, val):
+ context[param] = value
+ try:
+ # globals() pour math.*
+ res = eval(self.code, context, globals())
+ except Exception as exc:
+ mes = "ERREUR LORS DE L EVALUATION DE LA FORMULE %s" % self.nom
+ print(mes)
+ raise
+ return res
+
+ def setFormule(self, nom_para, texte):
+ """Cette methode sert a initialiser les attributs
+ nompar, expression et code qui sont utilisés
+ dans l'évaluation de la formule."""
+ self.nompar = nom_para
+ self.expression = texte
+ try:
+ self.code = compile(texte, texte, "eval")
+ except SyntaxError as exc:
+ mes = "ERREUR LORS DE LA CREATION DE LA FORMULE %s" % self.nom
+ print(mes)
+ raise
+
+ def __setstate__(self, state):
+ """Cette methode sert a restaurer l'attribut code lors d'un unpickle."""
+ self.__dict__.update(state) # update attributes
+ self.setFormule(self.nompar, self.expression) # restore code attribute
+
+ def __getstate__(self):
+ """Pour les formules, il faut enlever l'attribut code qui n'est
+ pas picklable."""
+ d = ASSD.__getstate__(self)
+ del d["code"]
+ return d
+
+ def supprime(self, force=False):
+ """
+ Cassage des boucles de références pour destruction du JDC.
+ 'force' est utilisée pour faire des suppressions complémentaires.
+
+ Pour être évaluées, les formules ont besoin du contexte des "constantes"
+ (objets autres que les concepts) qui sont soit dans (jdc).const_context,
+ soit dans (macro).macro_const_context.
+ On le stocke dans 'parent_context'.
+ Deux précautions valent mieux qu'une : on retire tous les concepts.
+
+ Lors de la suppression du concept, 'supprime' est appelée par
+ 'build_detruire' avec force=True afin de supprimer le "const_context"
+ conservé.
+ """
+ if force:
+ for ctxt in ("parent_context", "g_context"):
+ if hasattr(self, ctxt):
+ setattr(self, ctxt, None)
+ ASSD.supprime(self, force)
+
+ def Parametres(self):
+ """Equivalent de fonction.Parametres pour pouvoir utiliser des formules
+ à la place de fonctions dans certaines macro-commandes.
+ """
+ from SD.sd_fonction import sd_formule
+ from Utilitai.Utmess import UTMESS
+
+ if self.accessible():
+ TypeProl = {"E": "EXCLU", "L": "LINEAIRE", "C": "CONSTANT", "I": "INTERPRE"}
+ sd = sd_formule(self.getName())
+ prol = sd.PROL.get()
+ nova = sd.NOVA.get()
+ if prol is None or nova is None:
+ UTMESS("F", "SDVERI_2", valk=[objev])
+ dico = {
+ "INTERPOL": ["LIN", "LIN"],
+ "NOM_PARA": [s.strip() for s in nova],
+ "NOM_RESU": prol[3][0:16].strip(),
+ "PROL_DROITE": TypeProl["E"],
+ "PROL_GAUCHE": TypeProl["E"],
+ }
+ else:
+ raise Accas.AsException("Erreur dans fonction.Parametres en PAR_LOT='OUI'")
+ return dico
+
+
+class formule_c(formule):
+ pass
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+from Accas.processing import P_MACRO
+from Accas.processing import P_FORM_ETAPE
+
+class FORM(P_MACRO.MACRO):
+
+ """
+ Cette classe sert à définir dans le catalogue des objets de type
+ FORMULE pour ASTER.
+ Elle surcharge la classe MACRO
+ """
+
+ class_instance = P_FORM_ETAPE.FORM_ETAPE
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+from Accas.processing import P_MACRO_ETAPE
+
+
+class FORM_ETAPE(P_MACRO_ETAPE.MACRO_ETAPE):
+
+ """
+ Cette classe sert à construire l'objet ACCAS correspondant à une
+ FORMULE Aster.
+ Il s'agit d'un objet MACRO_ETAPE légèrement modifié
+ """
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+"""
+"""
+
+from Accas.processing.P_ASSD import ASSD
+
+class GEOM(ASSD):
+
+ """
+ Cette classe sert à définir les types de concepts
+ géométriques comme GROUP_NO, GROUP_MA,NOEUD et MAILLE
+ inusitée
+
+ """
+
+ def __init__(self, nom, etape=None, sd=None, reg="oui"):
+ """ """
+ self.etape = etape
+ self.sd = sd
+ if etape: self.parent = etape.parent
+ else: self.parent = CONTEXT.getCurrentStep()
+ if self.parent: self.jdc = self.parent.getJdcRoot()
+ else: self.jdc = None
+
+ if not self.parent: self.id = None
+ elif reg == "oui": self.id = self.parent.regSD(self)
+ self.nom = nom
+
+ def getName(self):
+ return self.nom
+
+ def __convert__(cls, valeur):
+ if isinstance(valeur, str) and len(valeur.strip()) <= 8:
+ return valeur.strip()
+ raise ValueError(_("On attend une chaine de caractères (de longueur <= 8)."))
+
+ __convert__ = classmethod(__convert__)
+
+
+class geom(GEOM):
+ pass
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe JDC qui sert a interpreter un jeu de commandes
+"""
+from builtins import str
+from builtins import range
+import os
+import traceback
+import types
+import sys
+import linecache
+
+# Modules EFICAS
+from Accas.processing import P_OBJECT
+from Accas.processing import P_CR
+from Accas.processing.P_Exception import AsException, InterruptParsingError
+from Accas.processing.P_ASSD import ASSD
+from Accas.processing.strfunc import getEncoding
+
+
+class JDC(P_OBJECT.OBJECT):
+
+ """
+ Cette classe interprete un jeu de commandes fourni sous
+ la forme d'une chaine de caractères
+
+ Attributs de classe :
+
+ Attributs d'instance :
+
+ """
+
+ nature = "JDC"
+ CR = P_CR.CR
+ exec_init = """import Accas
+from Accas import _F
+from Accas import *
+NONE = None
+"""
+
+ from Accas.processing.P_utils import SEP
+
+ def __init__( self, definition=None, procedure=None, cata=None, cata_ord_dico=None,
+ parent=None, nom="SansNom", appliEficas=None, context_ini=None, **args):
+ self.procedure = procedure
+ self.definition = definition
+ self.cata = cata
+ self._build_reserved_kw_list()
+ self.cata_ordonne_dico = cata_ord_dico
+ self.nom = nom
+ self.appliEficas = appliEficas
+ self.parent = parent
+ self.context_ini = context_ini
+
+ # On conserve les arguments supplementaires. Il est possible de passer
+ # des informations globales au JDC par ce moyen. Il pourrait etre plus
+ # sur de mettre en place le mecanisme des mots-cles pour verifier la
+ # validite des valeurs passees.
+ # Ceci reste a faire
+ # On initialise avec les parametres de la definition puis on
+ # update avec ceux du JDC
+ self.args = self.definition.args
+ self.args.update(args)
+ self.nstep = 0
+ self.nsd = 0
+ self.parLot = "OUI"
+ self.parLot_user = None
+ if definition:
+ self.regles = definition.regles
+ self.code = definition.code
+ else:
+ self.regles = ()
+ self.code = "CODE"
+ #
+ # Creation de l objet compte rendu pour collecte des erreurs
+ #
+ self.cr = self.CR(
+ debut="CR phase d'initialisation", fin="fin CR phase d'initialisation"
+ )
+ # on met le jdc lui-meme dans le context global pour l'avoir sous
+ # l'etiquette "jdc" dans le fichier de commandes
+ self.g_context = {"jdc": self}
+ CONTEXT.unsetCurrentJdC()
+ CONTEXT.setCurrentJdC(self)
+ # Dictionnaire pour stocker tous les concepts du JDC (acces rapide par
+ # le nom)
+ self.sdsDict = {}
+ self.etapes = []
+ self.index_etapes = {}
+ self.mc_globaux = {}
+ self.currentContext = {}
+ self.condition_context = {}
+ self.index_etape_courante = 0
+ self.UserError = "UserError"
+ self.alea = None
+ # permet transitoirement de conserver la liste des etapes
+ self.hist_etape = False
+
+ def compile(self):
+ """
+ Cette methode compile la chaine procedure
+ Si des erreurs se produisent, elles sont consignees dans le
+ compte-rendu self.cr
+ """
+ try:
+ # Python 2.7 compile function does not accept unicode filename, so we encode it
+ # with the current locale encoding in order to have a correct
+ # traceback
+ encoded_filename = self.nom.encode(getEncoding())
+ self.proc_compile = compile(self.procedure, encoded_filename, "exec")
+ except SyntaxError as e:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ l = traceback.format_exception_only(SyntaxError, e)
+ self.cr.exception("Compilation impossible : " + "".join(l))
+ except SystemError as e:
+ erreurs_connues = """
+Causes possibles :
+ - offset too large : liste trop longue derrière un mot-cle.
+ Solution : liste = (valeurs, ..., )
+ MOT_CLE = *liste,
+"""
+ l = traceback.format_exception_only(SystemError, e)
+ l.append(erreurs_connues)
+ self.cr.exception("Compilation impossible : " + "".join(l))
+ return
+
+ def setCurrentContext(self):
+ # beaucoup trop simple Ne tient pas compte des imports
+ # et des include
+ # ne sert que pour le POC
+ CONTEXT.setCurrentStep(self)
+
+ def execCompile(self):
+ """
+ Cette methode execute le jeu de commandes compile dans le contexte
+ self.g_context de l'objet JDC
+ """
+
+ CONTEXT.setCurrentStep(self)
+ # Le module nommage utilise le module linecache pour acceder
+ # au source des commandes du jeu de commandes.
+ # Dans le cas d'un fichier, on accède au contenu de ce fichier
+ # Dans le cas d'une chaine de caractères il faut acceder
+ # aux commandes qui sont dans la chaine
+ import linecache
+
+ linecache.cache[self.nom] = 0, 0, self.procedure.split("\n"), self.nom
+ try:
+ exec(self.exec_init, self.g_context)
+ for obj_cata in (self.cata,):
+ if type(obj_cata) == types.ModuleType:
+ init2 = "from " + obj_cata.__name__ + " import *"
+ exec(init2, self.g_context)
+ else:
+ # ici on a un catalogue en grammaire Eficas XML
+ # il faut ajouter ce qu on a construit au contexte
+ for k, v in obj_cata.contexteXML.items():
+ self.g_context[k] = v
+ # Initialisation du contexte global pour l'evaluation des conditions de BLOC
+ # On utilise une copie de l'initialisation du contexte du jdc
+ self.condition_context = self.g_context.copy()
+
+ # Si l'attribut context_ini n'est pas vide, on ajoute au contexte global
+ # le contexte initial (--> permet d'evaluer un JDC en recuperant un contexte
+ # d'un autre par exemple)
+ if self.context_ini:
+ self.g_context.update(self.context_ini)
+ # Update du dictionnaire des concepts
+ for sdnom, sd in list(self.context_ini.items()):
+ if isinstance(sd, ASSD):
+ self.sdsDict[sdnom] = sd
+
+ # if self.appliEficas != None:
+ # self.appliEficas.afficheInfos(
+ # 'Interpretation du fichier de commandes en cours ...')
+
+ # On sauve le contexte pour garder la memoire des constantes
+ # En mode edition (EFICAS) ou lors des verifications le contexte
+ # est recalcule
+ # mais les constantes sont perdues
+ self.const_context = self.g_context
+ exec(self.proc_compile, self.g_context)
+
+ CONTEXT.unsetCurrentStep()
+
+ except InterruptParsingError:
+ # interrupt the command file parsing used by FIN to ignore the end
+ # of the file
+ pass
+
+ except EOFError:
+ # Exception utilise pour interrompre un jeu
+ # de commandes avant la fin
+ # Fonctionnement normal, ne doit pas etre considere comme une
+ # erreur
+ CONTEXT.unsetCurrentStep()
+ self.afficheFinExec()
+ self.traiterFinExec("commande")
+
+ except AsException as e:
+ # une erreur a ete identifiee
+ if CONTEXT.debug:
+ traceback.print_exc()
+ # l'exception a ete recuperee avant (ou, comment ?),
+ # donc on cherche dans le texte
+ txt = str(e)
+ self.cr.exception(txt)
+ CONTEXT.unsetCurrentStep()
+
+ except NameError as e:
+ etype, value, tb = sys.exc_info()
+ l = traceback.extract_tb(tb)
+ s = traceback.format_exception_only(NameError, e)
+ msg = "erreur de syntaxe, %s ligne %d" % (s, l[-1][1])
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.cr.exception(msg)
+ CONTEXT.unsetCurrentStep()
+
+ # except self.UserError as exc_val:
+ # self.traiterUserException(exc_val)
+ # CONTEXT.unsetCurrentStep()
+ # self.afficheFinExec()
+ # self.traiterFinExec('commande')
+
+ except:
+ # erreur inattendue
+ # sys_exc_typ,sys_exc_value,sys_exc_frame = sys_exc.info()
+ # (tuple de 3 elements)
+ if CONTEXT.debug:
+ traceback.print_exc()
+
+ traceback.print_exc()
+
+ exc_typ, exc_val, exc_fr = sys.exc_info()
+ l = traceback.format_exception(exc_typ, exc_val, exc_fr)
+ self.cr.exception(
+ "erreur non prevue et non traitee prevenir la maintenance "
+ + "\n"
+ + "".join(l)
+ )
+ del exc_typ, exc_val, exc_fr
+ CONTEXT.unsetCurrentStep()
+ idx = 0
+ for e in self.etapes:
+ self.enregistreEtapePyxb(e, idx)
+ idx = idx + 1
+
+ def afficheFinExec(self):
+ """
+ utilisee par le superviseur : obsolete
+ Cette methode realise l'affichage final des statistiques de temps
+ apres l'execution de toutes
+ les commandes en mode commande par commande ou par lot
+ Elle doit etre surchargee pour en introduire un
+ """
+ return
+
+ def traiterFinExec(self, mode, etape=None):
+ """
+ utilisee par le superviseur : obsolete
+ Cette methode realise un traitement final apres l'execution de toutes
+ les commandes en mode commande par commande ou par lot
+ Par defaut il n'y a pas de traitement. Elle doit etre surchargee
+ pour en introduire un
+ """
+ print("FIN D'EXECUTION %s %s" % s(mode, etape))
+
+ def traiterUserException(self, exc_val):
+ """Cette methode realise un traitement sur les exceptions utilisateur
+ Par defaut il n'y a pas de traitement. La methode doit etre
+ surchargee pour en introduire un.
+ """
+ return
+
+ def register(self, etape):
+ """
+ Cette methode ajoute etape dans la liste des etapes : self.etapes
+ et retourne un numero d'enregistrement
+ """
+ self.etapes.append(etape)
+ self.index_etapes[etape] = len(self.etapes) - 1
+ return self.gRegister(etape)
+
+ def o_register(self, sd):
+ """
+ Retourne un identificateur pour concept
+ """
+ self.nsd = self.nsd + 1
+ nom = sd.idracine + self.SEP + repr(self.nsd)
+ return nom
+
+ def gRegister(self, etape):
+ """
+ Retourne un identificateur pour etape
+ """
+ self.nstep = self.nstep + 1
+ idetape = etape.idracine + self.SEP + repr(self.nstep)
+ return idetape
+
+ def createSdprod(self, etape, nomsd):
+ """
+ Cette methode doit fabriquer le concept produit retourne
+ par l'etape etape et le nommer.
+
+ Elle est appelee a l'initiative de l'etape
+ pendant le processus de construction de cette etape :
+ methode __call__ de la classe CMD (OPER ou MACRO)
+
+ Ce travail est realise par le contexte superieur
+ (etape.parent) car dans certains cas, le concept ne doit
+ pas etre fabrique mais l'etape doit simplement utiliser
+ un concept preexistant.
+
+ Deux cas possibles :
+ - Cas 1 : etape.reuse != None : le concept est reutilise
+ - Cas 2 : l'etape appartient a une macro qui a declare un
+ concept de sortie qui doit etre produit par cette
+ etape.
+ Dans le cas du JDC, le deuxième cas ne peut pas se produire.
+ """
+ sd = etape.getSdProd()
+ if sd != None and (etape.definition.reentrant == "n" or etape.reuse is None):
+ # ATTENTION : On ne nomme la SD que dans le cas de non reutilisation
+ # d un concept. Commande non reentrante ou reuse absent.
+ self.nommerSDProd(sd, nomsd)
+ return sd
+
+ def nommerSDProd(self, sd, sdnom, restrict="non"):
+ """
+ Nomme la SD apres avoir verifie que le nommage est possible : nom
+ non utilise
+ Si le nom est deja utilise, leve une exception
+ Met le concept cree dans le concept global g_context
+ """
+ o = self.sdsDict.get(sdnom, None)
+ if isinstance(o, ASSD):
+ raise AsException("Nom de concept deja defini : %s" % sdnom)
+ if sdnom in self._reserved_kw:
+ raise AsException(
+ "Nom de concept invalide. '%s' est un mot-cle reserve." % sdnom
+ )
+
+ # Ajoute a la creation (appel de regSD).
+ self.sdsDict[sdnom] = sd
+ sd.setName(sdnom)
+
+ # En plus si restrict vaut 'non', on insere le concept dans le contexte
+ # du JDC
+ if restrict == "non":
+ self.g_context[sdnom] = sd
+
+ def regUserSD(self, sd):
+ # utilisee pour creer les references
+ # se contente d appeler la methode equivalente sur le jdc
+ id = self.regSD(sd)
+ self.nommerSDProd(sd, sd.nom)
+ return id
+
+ def regSD(self, sd):
+ """
+ Methode appelee dans l __init__ d un ASSD lors de sa creation
+ pour s enregistrer
+ """
+ return self.o_register(sd)
+
+ def deleteConceptAfterEtape(self, etape, sd):
+ """
+ Met a jour les etapes du JDC qui sont après etape suite a
+ la disparition du concept sd
+ """
+ # Cette methode est definie dans le processing mais ne sert que pendant
+ # la phase de creation des etapes et des concepts. Il n'y a aucun
+ # traitement particulier a realiser.
+ # Dans d'autres conditions, il faut surcharger cette methode
+ return
+
+ def supprime(self):
+ P_OBJECT.OBJECT.supprime(self)
+ for etape in self.etapes:
+ etape.supprime()
+
+ def clean(self, netapes):
+ """Nettoie les `netapes` dernières etapes de la liste des etapes."""
+ if self.hist_etape:
+ return
+ for i in range(netapes):
+ e = self.etapes.pop()
+ jdc = e.jdc
+ parent = e.parent
+ e.supprime()
+ e.parent = parent
+ e.jdc = jdc
+ del self.index_etapes[e]
+
+ def getFile(self, unite=None, fic_origine="", fname=None):
+ """
+ Retourne le nom du fichier correspondant a un numero d'unite
+ logique (entier) ainsi que le source contenu dans le fichier
+ """
+ # if self.appliEficas:
+ # Si le JDC est relie a une appliEficascation maitre, on delègue la
+ # recherche
+ # return self.appliEficas.getFile(unite, fic_origine)
+ # else:
+ # if unite != None:
+ # if os.path.exists("fort." + str(unite)):
+ # fname = "fort." + str(unite)
+ if fname == None:
+ raise AsException("Impossible de trouver le fichier correspondant")
+ if not os.path.exists(fname):
+ raise AsException(fname + " n'est pas un fichier existant")
+ fproc = open(fname, "r")
+ text = fproc.read()
+ fproc.close()
+ text = text.replace("\r\n", "\n")
+ linecache.cache[fname] = 0, 0, text.split("\n"), fname
+ return fname, text
+
+ def set_parLot(self, parLot, user_value=False):
+ """
+ utilisee par le superviseur : obsolete
+ Met le mode de traitement a PAR LOT
+ ou a COMMANDE par COMMANDE
+ en fonction de la valeur du mot cle PAR_LOT et
+ du contexte : appliEficascation maitre ou pas
+
+ En PAR_LOT='NON', il n'y a pas d'ambiguite.
+ d'analyse et juste avant la phase d'execution.
+ `user_value` : permet de stocker la valeur choisie par l'utilisateur
+ pour l'interroger plus tard (par exemple dans `getContexteAvant`).
+ """
+ if user_value:
+ self.parLot_user = parLot
+ if self.appliEficas == None:
+ # Pas d appliEficascation maitre
+ self.parLot = parLot
+ else:
+ # Avec appliEficascation maitre
+ self.parLot = "OUI"
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitJDC(self)
+
+ def interact(self):
+ """
+ essai jamais mene au bout
+ Cette methode a pour fonction d'ouvrir un interpreteur
+ pour que l'utilisateur entre des commandes interactivement
+ """
+ CONTEXT.setCurrentStep(self)
+ try:
+ # Le module nommage utilise le module linecache pour acceder
+ # au source des commandes du jeu de commandes.
+ # Dans le cas d'un fichier, on accède au contenu de ce fichier
+ # Dans le cas de la console interactive, il faut pouvoir acceder
+ # aux commandes qui sont dans le buffer de la console
+ import linecache
+ import code
+
+ console = code.InteractiveConsole(self.g_context, filename="<console>")
+ linecache.cache["<console>"] = 0, 0, console.buffer, "<console>"
+ banner = (
+ """***********************************************
+* Interpreteur interactif %s
+***********************************************"""
+ % self.code
+ )
+ console.interact(banner)
+ finally:
+ console = None
+ CONTEXT.unsetCurrentStep()
+
+ def getContexteAvant(self, etape):
+ """
+ Retourne le dictionnaire des concepts connus avant etape
+ On tient compte des commandes qui modifient le contexte
+ comme les macros, les includes
+ Si etape == None, on retourne le contexte en fin de JDC
+ """
+ # L'etape courante pour laquelle le contexte a ete calcule est
+ # memorisee dans self.index_etape_courante
+ # memorisant l'etape # courante pendant le processus
+ # de construction des etapes.
+ # Si on insère des commandes il faut prealablement
+ # remettre ce pointeur a 0
+ if etape:
+ index_etape = self.index_etapes[etape]
+ else:
+ index_etape = len(self.etapes)
+ if index_etape >= self.index_etape_courante:
+ # On calcule le contexte en partant du contexte existant
+ d = self.currentContext
+ if self.index_etape_courante == 0 and self.context_ini:
+ d.update(self.context_ini)
+ liste_etapes = self.etapes[self.index_etape_courante : index_etape]
+ else:
+ d = self.currentContext = {}
+ if self.context_ini:
+ d.update(self.context_ini)
+ liste_etapes = self.etapes
+
+ for e in liste_etapes:
+ if e is etape:
+ break
+ if e.isActif():
+ e.updateContext(d)
+ self.index_etape_courante = index_etape
+ return d
+
+ def getGlobalContexte(self):
+ """Retourne "un" contexte global ;-)"""
+ # N'est utilise que par INCLUDE (sauf erreur).
+ # g_context est remis a {} en PAR_LOT='OUI'. const_context permet
+ # de retrouver ce qui y a ete mis par execCompile.
+ # Les concepts n'y sont pas en PAR_LOT='OUI'. Ils sont ajoutes
+ # par getGlobalContexte de la MACRO.
+ d = self.const_context.copy()
+ d.update(self.g_context)
+ return d
+
+ def getContexteCourant(self, etape_courante=None):
+ """
+ Retourne le contexte tel qu'il est (ou 'sera' si on est en phase
+ de construction) au moment de l'execution de l'etape courante.
+ """
+ if etape_courante is None:
+ etape_courante = CONTEXT.getCurrentStep()
+ return self.getContexteAvant(etape_courante)
+
+ def getConcept(self, nomsd):
+ """
+ Methode pour recuperer un concept a partir de son nom
+ """
+ co = self.getContexteCourant().get(nomsd.strip(), None)
+ if not isinstance(co, ASSD):
+ co = None
+ return co
+
+ def getConceptByType(self, nomsd, typesd, etape):
+ """
+ Methode pour recuperer un concept a partir de son nom et de son type.
+ Il aura comme père 'etape'.
+ """
+ assert issubclass(typesd, ASSD), typesd
+ co = typesd(etape=etape)
+ co.setName(nomsd)
+ co.executed = 1
+ return co
+
+ def delConcept(self, nomsd):
+ """
+ Methode pour supprimer la reference d'un concept dans le sdsDict.
+ Ne detruire pas le concept (different de supprime).
+ """
+ try:
+ del self.sdsDict[nomsd.strip()]
+ except:
+ pass
+
+ def getCmd(self, nomcmd):
+ """
+ Methode pour recuperer la definition d'une commande
+ donnee par son nom dans les catalogues declares
+ au niveau du jdc
+ """
+ for cata in (self.cata,):
+ if hasattr(cata, nomcmd):
+ return getattr(cata, nomcmd)
+
+ def append_reset(self, etape):
+ """
+ Ajoute une etape provenant d'un autre jdc a la liste des etapes
+ et remet a jour la parente de l'etape et des concepts
+ """
+ self.etapes.append(etape)
+ self.index_etapes[etape] = len(self.etapes) - 1
+ etape.reparent(self)
+ etape.resetJdc(self)
+
+ def sdAccessible(self):
+ """On peut acceder aux "valeurs" (jeveux) des ASSD si le JDC est en PAR_LOT="NON"."""
+ if CONTEXT.debug:
+ print((" `- JDC sdAccessible : PAR_LOT =", self.parLot))
+ return self.parLot == "NON"
+
+ def getEtapesByName(self, name):
+ listeDEtapes = []
+ for e in self.etapes:
+ if e.nom == name:
+ listeDEtapes.append(e)
+ return listeDEtapes
+
+ def getEtapeByConceptName(self, conceptName):
+ for e in self.etapes:
+ if hasattr(e, "sdnom") and e.sdnom == conceptName:
+ return e
+
+ def _build_reserved_kw_list(self):
+ """Construit la liste des mots-cles reserves (interdits pour le
+ nommage des concepts)."""
+ # A completer avec les UserASSD ?
+ self._reserved_kw = set()
+ # for cat in self.cata:
+ cat = self.cata
+ self._reserved_kw.update(
+ # PN 14 2020 [kw for kw in dir(cat) if len(kw) <= 8 and kw == kw.upper()])
+ [kw for kw in dir(cat)]
+ )
+ self._reserved_kw.difference_update(
+ [
+ "OPER",
+ "MACRO",
+ "BLOC",
+ "SIMP",
+ "FACT",
+ "FORM",
+ "GEOM",
+ "MCSIMP",
+ "MCFACT",
+ ]
+ )
+
+ def prepareInsertInDB(self):
+ debug = 1
+ if debug:
+ print("prepareInsertInDB traitement de ", self.nom)
+ if hasattr(self, "dPrimaryKey"):
+ dPrimaryKey = self.dPrimaryKey
+ else:
+ dPrimaryKey = {}
+ if hasattr(self, "dElementsRecursifs"):
+ dElementsRecursifs = self.dElementsRecursifs
+ else:
+ dElementsRecursifs = {}
+ dictKey = {}
+ if debug:
+ print("dElementsRecursifs", dElementsRecursifs)
+ if debug:
+ print(
+ "dPrimaryKey",
+ dPrimaryKey,
+ )
+ for mc in dPrimaryKey.values():
+ dictKey[mc] = None
+ texte = ""
+ for e in self.etapes:
+ tc, tv, ta = e.prepareInsertInDB(dictKey, dElementsRecursifs, dPrimaryKey)
+ texte += tc + tv + ta
+ return texte
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe de definition JDC_CATA
+ qui permet de spécifier les caractéristiques d'un JDC
+"""
+
+import types
+import traceback
+
+from Accas.processing import P_ENTITE
+from Accas.processing import P_JDC
+
+
+class JDC_CATA(P_ENTITE.ENTITE):
+
+ """
+ Classe pour definir un jeu de commandes
+
+ Attributs de classe :
+
+ - class_instance qui indique la classe qui devra etre utilisée
+ pour créer l'objet qui servira à controler la conformité
+ du jeu de commandes avec sa définition
+
+ - label qui indique la nature de l'objet de définition (ici, JDC)
+
+ """
+
+ class_instance = P_JDC.JDC
+ label = "JDC"
+
+ def __init__( self, code="", execmodul=None, regles=(), niveaux=(),
+ fichierSource=None, fr="", ang="", **args
+ ):
+ """
+ on se laisse la possibilite d initier fichierSource avec autre chose que le nom du fichier
+ au cas ou ... pour pouvoir changer le nom du 'sous code' implemente (cf readercata)
+ """
+ self.code = code
+ self.fr = fr
+ self.ang = ang
+ self.execmodul = execmodul
+ if type(regles) == tuple: self.regles = regles
+ else: self.regles = (regles,)
+
+ # Tous les arguments supplémentaires sont stockés dans l'attribut args
+ # et seront passés au JDC pour initialiser ses paramètres propres
+ self.args = args
+ self.d_niveaux = {}
+ self.lNiveaux = niveaux
+ self.commandes = []
+ self.fichierSource = fichierSource
+ for niveau in niveaux:
+ self.d_niveaux[niveau.nom] = niveau
+ # On change d'objet catalogue. Il faut d'abord mettre le catalogue
+ # courant à None
+ CONTEXT.unsetCurrentCata()
+ CONTEXT.setCurrentCata(self)
+ self.fenetreIhm = None
+ self.definitUserASSD = False
+ self.definitUserASSDMultiple = False
+ self.dictTypesXSD = {}
+ self.dictTypesXSDJumeaux = {}
+ self.dictTypesASSDorUserASSDCrees = {}
+ self.dictTypesASSDorUserASSDUtilises = {}
+ self.listeUserASSDDumpes = set()
+ self.listeTypeTXMAvecBlancs = set()
+
+ def __call__( self, procedure=None, cata=None, cata_ord_dico=None, nom="SansNom",
+ parent=None, **args):
+ """
+ Construit l'objet JDC a partir de sa definition (self),
+ """
+ return self.class_instance(
+ definition=self,
+ procedure=procedure,
+ cata=cata,
+ cata_ord_dico=cata_ord_dico,
+ nom=nom,
+ parent=parent,
+ **args
+ )
+
+ def enregistre(self, commande):
+ """
+ Methode qui permet aux definitions de commandes de s'enregistrer aupres
+ d'un JDC_CATA
+ """
+ self.commandes.append(commande)
+
+ def verifCata(self):
+ """
+ Méthode de vérification des attributs de définition
+ """
+ self.checkRegles()
+ self.verifCataRegles()
+
+ def verifCataRegles(self):
+ """
+ Cette méthode vérifie pour tous les objets stockés dans la liste entités
+ respectent les REGLES associés à self
+ """
+ # A FAIRE
+
+ def report(self):
+ """
+ Methode pour produire un compte-rendu de Accas.validation d'un catalogue de commandes
+ """
+ self.cr = self.CR(
+ debut="Compte-rendu de Accas.validation du catalogue " + self.code,
+ fin="Fin Compte-rendu de Accas.validation du catalogue " + self.code,
+ )
+ self.verifCata()
+ for commande in self.commandes:
+ cr = commande.report()
+ cr.debut = "Début Commande :" + commande.nom
+ cr.fin = "Fin commande :" + commande.nom
+ self.cr.add(cr)
+ return self.cr
+
+ def supprime(self):
+ """
+ Méthode pour supprimer les références arrières susceptibles de provoquer
+ des cycles de références
+ """
+ for commande in self.commandes:
+ commande.supprime()
+
+ def getNiveau(self, nom_niveau):
+ """
+ Retourne l'objet de type NIVEAU de nom nom_niveau
+ ou None s'il n'existe pas
+ """
+ return self.d_niveaux.get(nom_niveau, None)
+
+ def dumpStructure(self):
+ texte = ""
+ for c in self.commandes:
+ if not (c.label != "OPER") and not (c.label != "PROC"):
+ continue
+ if c.label == "OPER":
+ texte += c.nom + " " + str(c.sd_prod) + "\n"
+ if c.label == "PROC":
+ texte += c.nom + " \n"
+ texte += c.dumpStructure()
+ return texte
+
+ def dumpStringDataBase(self, nomDataBaseACreer):
+ texte = "create database {}; \n".format(nomDataBaseACreer)
+ texte += "create user admin{}; \n".format(nomDataBaseACreer)
+ texte += "grant all privileges on database {} to admin{}; \n".format(
+ nomDataBaseACreer, nomDataBaseACreer
+ )
+ texte += "********* fin de creation de la database ********* \n"
+ dictPrimaryKey = {}
+ dictRecursif = {}
+ if hasattr(self.cata, "dPrimaryKey"):
+ dPrimaryKey = self.cata.dPrimaryKey
+ if hasattr(self.cata, "dElementsRecursifs"):
+ dElementsRecursifs = self.cata.dElementsRecursifs
+ for c in self.commandes:
+ if not (c.label != "OPER") and not (c.label != "PROC"):
+ continue # une macro ?
+ texte += c.dumpStringDataBase(dPrimaryKey, dElementsRecursifs, {}, False)
+ # print (texte)
+ return texte
+
+ def dumpGitStringFormat(self):
+ texte = "git log --pretty=format:'"
+ for c in self.commandes:
+ if not (c.label != "OPER") and not (c.label != "PROC"):
+ continue
+ texte += "<ns1:{}>".format(c.nom)
+ texte += c.dumpGitStringFormat()
+ texte += "</ns1:{}>".format(c.nom)
+ texte += "'"
+ return texte
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+from Accas.processing.P_ASSD import ASSD
+
+
+class LASSD(ASSD, list):
+ pass
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+"""
+ Ce module contient la classe de definition MACRO
+ qui permet de spécifier les caractéristiques d'une macro-commande
+"""
+
+
+import types
+import traceback
+
+from Accas.processing import P_ENTITE
+from Accas.processing import P_MACRO_ETAPE
+from Accas.processing import nommage
+
+
+class MACRO(P_ENTITE.ENTITE):
+
+ """
+ Classe pour definir une macro-commande
+
+ Cette classe a trois attributs de classe
+
+ - class_instance qui indique la classe qui devra etre utilisée
+ pour créer l'objet qui servira à controler la conformité d'un
+ macro-commande avec sa définition
+
+ - label qui indique la nature de l'objet de définition (ici, MACRO)
+
+ - nommage qui est un module Python qui fournit la fonctionnalité de nommage
+
+ et les attributs d'instance suivants :
+ - nom : son nom
+ - op : le numéro d'opérateur
+ - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
+ une classe
+ - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
+ réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
+ - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
+ non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
+ de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
+ - fr : commentaire associé en francais
+ - docu : clé de documentation associée
+ - regles : liste des règles associées
+ - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
+ fonction est exécutée lors des phases d'initialisation de l'étape associée.
+ - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
+ rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
+ Si niveau vaut None, l'opérateur est rangé au niveau global.
+ - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
+ des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
+ est initialisé avec args, c'est à dire les arguments d'appel restants.
+
+ """
+
+ class_instance = P_MACRO_ETAPE.MACRO_ETAPE
+ label = "MACRO"
+ nommage = nommage
+
+ def __init__( self, nom, op=None, sd_prod=None, reentrant="n", repetable="o", fr="",
+ ang="", fenetreIhm=None, docu="", regles=(), op_init=None, niveau=None, fichier_ini=0,
+ UIinfo=None, **args
+ ):
+ """
+ Méthode d'initialisation de l'objet MACRO. Les arguments sont utilisés pour initialiser
+ les attributs de meme nom
+ """
+ # fichier_ini n'est pas utilisé pour l'instant
+ self.nom = nom
+
+ # op est obligatoire et permet de spécifier la procédure de construction de la macro
+ # - Si op est un entier la construction de la macro est réalisée par une subroutine fortran opsxxx ou
+ # xxx est donné par la valeur absolue de op. L'execution est egalement effectuée via cette subroutine.
+ # - Si op est une fonction Python, la construction de la macro est effectuée par l'appel à cette fonction
+ # Suivant le cas on garde l info dans self.op ou dans self.proc
+ if type(op) == int:
+ self.proc = None
+ self.op = op
+ else:
+ self.op = None
+ self.proc = op
+
+ self.sd_prod = sd_prod
+ self.reentrant = reentrant
+ self.fr = fr
+ self.ang = ang
+ self.repetable = repetable
+ self.docu = docu
+ self.fenetreIhm = fenetreIhm
+ if type(regles) == tuple:
+ self.regles = regles
+ else:
+ self.regles = (regles,)
+ self.fichier_ini = fichier_ini
+ # Attribut op_init : Fonction a appeler a la construction de l
+ # operateur sauf si == None
+ self.op_init = op_init
+ self.entites = args
+ current_cata = CONTEXT.getCurrentCata()
+ if niveau == None:
+ self.niveau = None
+ current_cata.enregistre(self)
+ else:
+ self.niveau = current_cata.getNiveau(niveau)
+ self.niveau.enregistre(self)
+ self.UIinfo = UIinfo
+ self.affecter_parente()
+ self.checkDefinition(self.nom)
+
+ def __call__(self, reuse=None, **args):
+ """
+ Construit l'objet MACRO_ETAPE a partir de sa definition (self),
+ puis demande la construction de ses sous-objets et du concept produit.
+ """
+ nomsd = self.nommage.getNomConceptResultat(self.nom)
+ etape = self.class_instance(oper=self, reuse=reuse, args=args)
+ etape.MCBuild()
+ return etape.buildSd(nomsd)
+
+ def make_objet(self, mc_list="oui"):
+ """
+ Cette méthode crée l'objet MACRO_ETAPE dont la définition est self sans
+ créer sa sdprod.
+ Normalement l'étape est enregistrée auprès de son parent.
+ Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
+ des objets MCxxx.
+ """
+ etape = self.class_instance(oper=self, reuse=None, args={})
+ if mc_list == "oui":
+ etape.MCBuild()
+ return etape
+
+ def verifCata(self):
+ """
+ Méthode de vérification des attributs de définition
+ """
+ self.checkOp(valmax=0)
+ self.checkProc()
+ self.checkRegles()
+ self.checkFr()
+ self.checkDocu()
+ self.checkNom()
+ self.checkReentrant()
+ self.verifCataRegles()
+
+ def supprime(self):
+ """
+ Méthode pour supprimer les références arrières susceptibles de provoquer
+ des cycles de références
+ """
+ self.niveau = None
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe MACRO_ETAPE qui sert a verifier et a executer
+ une commande
+"""
+
+# Modules Python
+import types
+import sys
+import traceback
+from warnings import warn
+
+# Modules EFICAS
+from Accas.processing import P_MCCOMPO
+from Accas.processing import P_ETAPE
+from Accas.processing.P_Exception import AsException
+from Accas.processing import P_utils
+from Accas.processing.P_utils import AsType
+from Accas.processing.P_CO import CO
+from Accas.processing.P_ASSD import ASSD
+
+
+class MACRO_ETAPE(P_ETAPE.ETAPE):
+
+ """ """
+
+ nature = "COMMANDE"
+ typeCO = CO
+
+ def __init__(self, oper=None, reuse=None, args={}):
+ """
+ Attributs :
+ - definition : objet portant les attributs de definition d'une etape
+ de type macro-commande. Il est initialise par
+ l'argument oper.
+ - reuse : indique le concept d'entree reutilise. Il se trouvera donc
+ en sortie si les conditions d'execution de l'operateur
+ l'autorise
+ - valeur : arguments d'entree de type mot-cle=valeur. Initialise
+ avec l'argument args.
+ """
+ P_ETAPE.ETAPE.__init__(self, oper, reuse, args, niveau=5)
+ self.g_context = {}
+ # Contexte courant
+ self.currentContext = {}
+ self.macro_const_context = {}
+ self.index_etape_courante = 0
+ self.etapes = []
+ self.index_etapes = {}
+ # Dans le cas d'une macro ecrite en Python, l'attribut Outputs est un
+ # dictionnaire qui contient les concepts produits de sortie
+ # (nom : ASSD) declares dans la fonction sd_prod
+ self.Outputs = {}
+ self.sdprods = []
+ self.UserError = "UserError"
+ # permet de stocker le nom du dernier concept nomme dans la macro
+ self.last = None
+
+ def makeRegister(self):
+ """
+ Initialise les attributs jdc, id, niveau et realise les enregistrements
+ necessaires
+ """
+ P_ETAPE.ETAPE.makeRegister(self)
+ if self.parent:
+ self.UserError = self.jdc.UserError
+ else:
+ self.UserError = "UserError"
+
+ def buildSd(self, nom):
+ """
+ Construit le concept produit de l'operateur. Deux cas
+ peuvent se presenter :
+
+ - le parent n'est pas defini. Dans ce cas, l'etape prend en charge
+ la creation et le nommage du concept.
+
+ - le parent est defini. Dans ce cas, l'etape demande au parent la
+ creation et le nommage du concept.
+
+ """
+ self.sdnom = nom
+ try:
+ # On positionne la macro self en tant que current_step pour que les
+ # etapes creees lors de l'appel a sd_prod et a op_init aient la macro
+ # comme parent
+ self.setCurrentStep()
+ if self.parent:
+ sd = self.parent.createSdprod(self, nom)
+ if type(self.definition.op_init) == types.FunctionType:
+ self.definition.op_init(*(self, self.parent.g_context))
+ else:
+ sd = self.getSdProd()
+ if sd != None and self.reuse == None:
+ # On ne nomme le concept que dans le cas de non reutilisation
+ # d un concept
+ sd.setName(nom)
+ self.resetCurrentStep()
+ except AsException as e:
+ self.resetCurrentStep()
+ raise AsException(
+ "Etape ",
+ self.nom,
+ "ligne : ",
+ self.appel[0],
+ "fichier : ",
+ self.appel[1],
+ e,
+ )
+ # except (EOFError, self.UserError):
+ except EOFError:
+ # Le retablissement du step courant n'est pas strictement
+ # necessaire. On le fait pour des raisons de coherence
+ self.resetCurrentStep()
+ raise
+ except:
+ self.resetCurrentStep()
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ raise AsException(
+ "Etape ",
+ self.nom,
+ "ligne : ",
+ self.appel[0],
+ "fichier : ",
+ self.appel[1] + "\n",
+ "".join(l),
+ )
+
+ self.Execute()
+ return sd
+
+ def getSdProd(self):
+ """
+ Retourne le concept resultat d'une macro etape
+ La difference avec une etape ou une proc-etape tient a ce que
+ le concept produit peut exister ou pas
+
+ Si sd_prod == None le concept produit n existe pas on retourne None
+
+ Deux cas :
+ - cas 1 : sd_prod n'est pas une fonction
+ il s'agit d'une sous classe de ASSD
+ on construit le sd a partir de cette classe
+ et on le retourne
+ - cas 2 : sd_prod est une fonction
+ on l'evalue avec les mots-cles de l'etape (mcListe)
+ on construit le sd a partir de la classe obtenue
+ et on le retourne
+ """
+ sd_prod = self.definition.sd_prod
+ self.typret = None
+
+ if type(self.definition.sd_prod) == types.FunctionType:
+ d = self.creeDictValeurs(self.mcListe)
+ try:
+ # la sd_prod d'une macro a l'objet macro_etape lui meme en premier argument
+ # Comme sd_prod peut invoquer la methode typeSDProd qui ajoute
+ # les concepts produits dans self.sdprods, il faut le mettre a
+ # zero avant de l'appeler
+ self.sdprods = []
+ sd_prod = sd_prod(*(self,), **d)
+ # except (EOFError, self.UserError):
+ except EOFError:
+ raise
+ except Exception as exc:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ raise AsException(
+ "impossible d affecter un type au resultat:", str(exc)
+ )
+
+ # on teste maintenant si la SD est reutilisee ou s'il faut la creer
+ if self.definition.reentrant != "n" and self.reuse:
+ # Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale.
+ # Elle sera traitee ulterieurement.
+ self.sd = self.reuse
+ else:
+ if sd_prod == None:
+ self.sd = None
+ else:
+ self.sd = sd_prod(etape=self)
+ self.typret = sd_prod
+ # Si la commande est obligatoirement reentrante et reuse n'a pas ete specifie, c'est une erreur.
+ # On ne fait rien ici. L'erreur sera traitee par la suite.
+ # precaution
+ if self.sd is not None and not isinstance(self.sd, ASSD):
+ raise AsException(
+ """
+Impossible de typer le resultat !
+Causes possibles :
+ Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,
+ soit il y a une "," a la fin d'une commande precedente.
+ Developpeur : La fonction "sd_prod" retourne un type invalide."""
+ )
+ return self.sd
+
+ def getType_produit(self, force=0):
+ try:
+ return self.getType_produit_brut(force)
+ except:
+ # traceback.print_exc()
+ return None
+
+ def getType_produit_brut(self, force=0):
+ """
+ Retourne le type du concept resultat de l'etape et eventuellement type
+ les concepts produits "a droite" du signe egal (en entree)
+
+ Deux cas :
+ - cas 1 : sd_prod de oper n'est pas une fonction
+ il s'agit d'une sous classe de ASSD
+ on retourne le nom de la classe
+ - cas 2 : il s'agit d'une fonction
+ on l'evalue avec les mots-cles de l'etape (mcListe)
+ et on retourne son resultat
+ """
+ if not force and hasattr(self, "typret"):
+ return self.typret
+
+ if type(self.definition.sd_prod) == types.FunctionType:
+ d = self.creeDictValeurs(self.mcListe)
+ # Comme sd_prod peut invoquer la methode typeSDProd qui ajoute
+ # les concepts produits dans self.sdprods, il faut le mettre a zero
+ self.sdprods = []
+ sd_prod = self.definition.sd_prod(*(self,), **d)
+ else:
+ sd_prod = self.definition.sd_prod
+ return sd_prod
+
+ def getContexteAvant(self, etape):
+ """
+ Retourne le dictionnaire des concepts connus avant etape
+ pour les commandes internes a la macro
+ On tient compte des commandes qui modifient le contexte
+ comme DETRUIRE ou les macros
+ """
+ # L'etape courante pour laquelle le contexte a ete calcule est
+ # memorisee dans self.index_etape_courante
+ # self.currentContext.items() if isinstance(v, ASSD)])
+ d = self.currentContext = self.g_context.copy()
+ if etape is None:
+ return d
+ # retirer les sd produites par 'etape'
+ sd_names = [sd.nom for sd in etape.getCreated_sd()]
+ for nom in sd_names:
+ try:
+ del d[nom]
+ except KeyError:
+ pass
+ # Exemple avec INCLUDE_MATERIAU appele dans une macro.
+ # Les fonctions restent uniquement dans le contexte de INCLUDE_MATERIAU,
+ # elles ne sont donc pas dans le contexte de la macro appelante.
+ # from warnings import warn
+ # warn("concept '%s' absent du contexte de %s" % (nom, self.nom),
+ # RuntimeWarning, stacklevel=2)
+ return d
+
+ def supprime(self):
+ """
+ Methode qui supprime toutes les references arrières afin que
+ l'objet puisse etre correctement detruit par le garbage collector
+ """
+ P_MCCOMPO.MCCOMPO.supprime(self)
+ self.jdc = None
+ self.appel = None
+ if self.sd:
+ self.sd.supprime()
+ for concept in self.sdprods:
+ concept.supprime()
+ for etape in self.etapes:
+ etape.supprime()
+
+ def clean(self, netapes):
+ """Nettoie les `netapes` dernières etapes de la liste des etapes."""
+ if self.jdc.hist_etape:
+ return
+ for i in range(netapes):
+ e = self.etapes.pop()
+ jdc = e.jdc
+ parent = e.parent
+ e.supprime()
+ e.parent = parent
+ e.jdc = jdc
+ del self.index_etapes[e]
+
+ def typeSDProd(self, co, t):
+ """
+ Cette methode a pour fonction de typer le concept co avec le type t
+ dans les conditions suivantes :
+ 1. co est un concept produit de self
+ 2. co est un concept libre : on le type et on l attribue a self
+
+ Elle enregistre egalement les concepts produits (on fait l hypothese
+ que la liste sdprods a ete correctement initialisee, vide probablement)
+ """
+ if not hasattr(co, "etape"):
+ # Le concept vaut None probablement. On ignore l'appel
+ return
+ #
+ # On cherche a discriminer les differents cas de typage d'un concept
+ # produit par une macro qui est specifie dans un mot cle simple.
+ # On peut passer plusieurs fois par typeSDProd ce qui explique
+ # le nombre important de cas.
+ #
+ # Cas 1 : Le concept est libre. Il vient d'etre cree par CO(nom)
+ # Cas 2 : Le concept est produit par la macro. On est deja passe par typeSDProd.
+ # Cas semblable a Cas 1.
+ # Cas 3 : Le concept est produit par la macro englobante (parent). On transfere
+ # la propriete du concept de la macro parent a la macro courante (self)
+ # en verifiant que le type est valide
+ # Cas 4 : La concept est la propriete d'une etape fille. Ceci veut dire qu'on est
+ # deja passe par typeSDProd et que la propriete a ete transfere a une
+ # etape fille. Cas semblable a Cas 3.
+ # Cas 5 : Le concept est produit par une etape externe a la macro.
+ #
+ if co.etape == None:
+ # Cas 1 : le concept est libre
+ # On l'attache a la macro et on change son type dans le type demande
+ # Recherche du mot cle simple associe au concept
+ mcs = self.getMcsWithCo(co)
+ if len(mcs) != 1:
+ raise AsException(
+ """Erreur interne.
+Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)"""
+ % co
+ )
+ mcs = mcs[0]
+ if not self.typeCO in mcs.definition.type:
+ raise AsException(
+ """Erreur interne.
+Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)"""
+ % (co, mcs.definition.type)
+ )
+ co.etape = self
+ # affectation du bon type du concept
+ co.changeType(t)
+ self.sdprods.append(co)
+
+ elif co.etape == self:
+ # Cas 2 : le concept est produit par la macro (self)
+ # On est deja passe par typeSDProd (Cas 1 ou 3).
+ # XXX Peut-il etre creer par une autre macro ?
+ # On verifie juste que c'est un vrai CO non deja type
+ # if co.etape == co._etape:
+ if co.isTypCO() == 1:
+ # Le concept a ete cree par la macro (self)
+ # On peut changer son type
+ co.changeType(t)
+ else:
+ # Le concept a ete cree par une macro parente
+ # Le type du concept doit etre coherent avec le type demande
+ # (seulement derive)
+ if not isinstance(co, t):
+ raise AsException(
+ """Erreur interne.
+Le type demande (%s) et le type du concept (%s) devraient etre derives"""
+ % (t, co.__class__)
+ )
+
+ self.sdprods.append(co)
+
+ elif co.etape == self.parent:
+ # Cas 3 : le concept est produit par la macro parente (self.parent)
+ # on transfere la propriete du concept a la macro fille
+ # et on change le type du concept comme demande
+ # Au prealable, on verifie que le concept existant (co) est une instance
+ # possible du type demande (t)
+ # Cette règle est normalement coherente avec les règles de
+ # verification des mots-cles
+ if not isinstance(co, t):
+ raise AsException(
+ """
+Impossible de changer le type du concept produit (%s) en (%s).
+Le type actuel (%s) devrait etre une classe derivee du nouveau type (%s)"""
+ % (co, t, co.__class__, t)
+ )
+ mcs = self.getMcsWithCo(co)
+ if len(mcs) != 1:
+ raise AsException(
+ """Erreur interne.
+Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)"""
+ % co
+ )
+ mcs = mcs[0]
+ if not self.typeCO in mcs.definition.type:
+ raise AsException(
+ """Erreur interne.
+Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)"""
+ % (co, mcs.definition.type)
+ )
+ co.etape = self
+ # On ne change pas le type car il respecte la condition isinstance(co,t)
+ # co.__class__ = t
+ self.sdprods.append(co)
+
+ elif self.issubstep(co.etape):
+ # Cas 4 : Le concept est propriete d'une sous etape de la macro (self).
+ # On est deja passe par typeSDProd (Cas 3 ou 1).
+ # Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
+ # Le type du concept et t doivent etre derives.
+ # Il n'y a aucune raison pour que la condition ne soit pas
+ # verifiee.
+ if not isinstance(co, t):
+ raise AsException(
+ """Erreur interne.
+Le type demande (%s) et le type du concept (%s) devraient etre derives"""
+ % (t, co.__class__)
+ )
+ self.sdprods.append(co)
+
+ else:
+ # Cas 5 : le concept est produit par une autre etape
+ # On ne fait rien
+ return
+
+ def issubstep(self, etape):
+ """
+ Cette methode retourne un entier indiquant si etape est une
+ sous etape de la macro self ou non
+ 1 = oui
+ 0 = non
+ """
+ if etape in self.etapes:
+ return 1
+ for etap in self.etapes:
+ if etap.issubstep(etape):
+ return 1
+ return 0
+
+ def register(self, etape):
+ """
+ Enregistrement de etape dans le contexte de la macro : liste etapes
+ et demande d enregistrement global aupres du JDC
+ """
+ self.etapes.append(etape)
+ self.index_etapes[etape] = len(self.etapes) - 1
+ idetape = self.jdc.gRegister(etape)
+ return idetape
+
+ def regSD(self, sd):
+ """
+ Methode appelee dans l __init__ d un ASSD a sa creation pour
+ s enregistrer (reserve aux ASSD crees au sein d'une MACRO)
+ """
+ return self.jdc.o_register(sd)
+
+ def createSdprod(self, etape, nomsd):
+ """
+ Cette methode doit fabriquer le concept produit retourne
+ par l'etape etape et le nommer.
+
+ Elle est appelee a l'initiative de l'etape
+ pendant le processus de construction de cette etape : methode __call__
+ de la classe CMD (OPER ou MACRO)
+ Ce travail est realise par le contexte superieur (etape.parent)
+ car dans certains cas, le concept ne doit pas etre fabrique mais
+ l'etape doit simplement utiliser un concept preexistant.
+ - Cas 1 : etape.reuse != None : le concept est reutilise
+ - Cas 2 : l'etape appartient a une macro qui a declare un concept
+ de sortie qui doit etre produit par cette etape.
+ """
+ if nomsd in self.Outputs:
+ # Il s'agit d'un concept de sortie de la macro. Il ne faut pas le creer
+ # Il faut quand meme appeler la fonction sd_prod si elle existe.
+ # getType_produit le fait et donne le type attendu par la commande
+ # pour verification ulterieure.
+ sdprod = etape.getType_produit_brut()
+ sd = self.Outputs[nomsd]
+ # On verifie que le type du concept existant sd.__class__ est un sur type de celui attendu
+ # Cette règle est normalement coherente avec les règles de
+ # verification des mots-cles
+ if not issubclass(sdprod, sd.__class__):
+ raise AsException(
+ "Le type du concept produit %s devrait etre une sur classe de %s"
+ % (sd.__class__, sdprod)
+ )
+ # La propriete du concept est transferee a l'etape avec le type
+ # attendu par l'etape
+ etape.sd = sd
+ sd.etape = etape
+ if (
+ self.reuse == sd
+ and etape.reuse != sd
+ and getattr(sd, "executed", 0) == 1
+ ): # n'a pas ete pas detruit
+ raise AsException(
+ "Le concept '%s' est reentrant dans la macro-commande %s. "
+ "Il devrait donc l'etre dans %s (produit sous le nom '%s')."
+ % (sd.nom, self.nom, etape.nom, nomsd)
+ )
+ # On donne au concept le type produit par la sous commande.
+ # Le principe est le suivant : apres avoir verifie que le type deduit par la sous commande
+ # est bien coherent avec celui initialement affecte par la macro (voir ci dessus)
+ # on affecte au concept ce type car il peut etre plus precis
+ # (derive, en general)
+ sd.__class__ = sdprod
+ # On force egalement le nom stocke dans l'attribut sdnom : on lui donne le nom
+ # du concept associe a nomsd
+ etape.sdnom = sd.nom
+ # pour l'ajouter au contexte de la macro
+ self.g_context[sd.nom] = sd
+ elif etape.definition.reentrant != "n" and etape.reuse != None:
+ # On est dans le cas d'une commande avec reutilisation d'un concept existant
+ # getSdProd fait le necessaire : verifications, associations, etc. mais ne cree
+ # pas un nouveau concept. Il retourne le concept reutilise
+ sd = etape.getSdProd()
+ # Dans le cas d'un concept nomme automatiquement : _xxx, __xxx,
+ # On force le nom stocke dans l'attribut sdnom de l'objet etape : on lui donne le nom
+ # du concept reutilise (sd ou etape.reuse c'est pareil)
+ # Ceci est indispensable pour eviter des erreurs lors des verifications des macros
+ # En effet une commande avec reutilisation d'un concept verifie que le nom de
+ # la variable a gauche du signe = est le meme que celui du concept reutilise.
+ # Lorsqu'une telle commande apparait dans une macro, on supprime
+ # cette verification.
+ if etape.sdnom == "" or etape.sdnom[0] == "_":
+ etape.sdnom = sd.nom
+ else:
+ # On est dans le cas de la creation d'un nouveau concept
+ sd = etape.getSdProd()
+ if sd != None:
+ self.nommerSDProd(sd, nomsd)
+ return sd
+
+ def nommerSDProd(self, sd, sdnom, restrict="non"):
+ """
+ Cette methode est appelee par les etapes internes de la macro.
+ La macro appelle le JDC pour valider le nommage.
+ On considère que l'espace de nom est unique et gere par le JDC.
+ Si le nom est deja utilise, l'appel lève une exception.
+ Si restrict=='non', on insère le concept dans le contexte du parent de la macro.
+ Si restrict=='oui', on insère le concept uniquement dans le contexte de la macro.
+ """
+ # Normalement, lorsqu'on appelle cette methode, on ne veut nommer que des concepts nouvellement crees.
+ # Le filtrage sur les concepts a creer ou a ne pas creer est fait dans la methode
+ # createSdprod. La seule chose a verifier apres conversion eventuelle du nom
+ # est de verifier que le nom n'est pas deja attribue. Ceci est fait en delegant
+ # au JDC par l'intermediaire du parent.
+ if sdnom in self.Outputs:
+ # Il s'agit d'un concept de sortie de la macro produit par une
+ # sous commande
+ sdnom = self.Outputs[sdnom].nom
+ elif len(sdnom) > 0:
+ if sdnom[0] in ("_", ".") and sdnom[1:].isdigit():
+ # il est deja de la forme _9000012 ou .9000017
+ pass
+ elif sdnom[0] == "_":
+ # Si le nom du concept commence par le caractère '_', on lui attribue
+ # un identificateur JEVEUX construit par gcncon.
+ # nom commençant par __ : il s'agit de concepts qui seront detruits
+ # nom commençant par _ : il s'agit de concepts intermediaires
+ # qui seront gardes
+ if len(sdnom) > 1 and sdnom[1] == "_":
+ sdnom = self.gcncon(".")
+ else:
+ sdnom = self.gcncon("_")
+ elif self.nom in ("INCLUDE", "MACR_RECAL"):
+ # dans le cas d'INCLUDE, on passe
+ # MACR_RECAL fonctionne comme INCLUDE
+ pass
+ else:
+ # On est dans le cas d'un nom de concept global
+ # XXX a voir, creation de CO() dans CALC_ESSAI (sdls139a)
+ if not sd.isTypCO():
+ raise AsException(
+ "Resultat non declare par la macro %s : %s" % (self.nom, sdnom)
+ )
+ self.last = sdnom
+ if restrict == "non":
+ # On demande le nommage au parent mais sans ajout du concept dans le contexte du parent
+ # car on va l'ajouter dans le contexte de la macro
+ self.parent.nommerSDProd(sd, sdnom, restrict="oui")
+ # On ajoute dans le contexte de la macro les concepts nommes
+ # Ceci est indispensable pour les CO (macro) dans un INCLUDE
+ self.g_context[sdnom] = sd
+ else:
+ # La demande de nommage vient probablement d'une macro qui a mis
+ # le concept dans son contexte. On ne traite plus que le nommage (restrict="oui")
+ self.parent.nommerSDProd(sd, sdnom, restrict="oui")
+
+ def deleteConceptAfterEtape(self, etape, sd):
+ """
+ Met a jour les etapes de la MACRO qui sont après etape suite a
+ la disparition du concept sd
+ """
+ # Cette methode est definie dans le processing mais ne sert que pendant la phase de creation
+ # des etapes et des concepts. Il n'y a aucun traitement particulier a realiser
+ # Dans d'autres conditions, il faudrait surcharger cette methode.
+ return
+
+ def getCreated_sd(self):
+ """Retourne la liste des sd reellement produites par l'etape.
+ Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans
+ cette liste."""
+ sdprods = self.sdprods[:]
+ if not self.reuse and self.sd:
+ sdprods.append(self.sd)
+ return sdprods
+
+ def getLastConcept(self):
+ """Retourne le dernier concept produit dans la macro.
+ Peut-etre utile pour acceder au contenu 'fortran' dans une
+ clause 'except'."""
+ return self.g_context.get(self.last, None)
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitMACRO_ETAPE(self)
+
+ def updateContext(self, d):
+ """
+ Met a jour le contexte contenu dans le dictionnaire d
+ Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
+ Une fonction enregistree dans op_init peut egalement modifier le contexte
+ """
+ if type(self.definition.op_init) == types.FunctionType:
+ self.definition.op_init(*(self, d))
+ if self.sd != None:
+ d[self.sd.nom] = self.sd
+ for co in self.sdprods:
+ d[co.nom] = co
+
+ def makeInclude(self, unite=None, fname=None):
+ """Inclut un fichier dont l'unite logique est `unite` ou de nom `fname`"""
+ if unite is not None:
+ warn(
+ "'unite' is deprecated, please use 'fname' instead",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+ fname = "fort.%s" % unite
+ if not fname:
+ return
+ f, text = self.getFile(fic_origine=self.parent.nom, fname=fname)
+ self.fichier_init = f
+ if f == None:
+ return
+ self.makeContexte(f, text)
+
+ def makePoursuite(self):
+ """Inclut un fichier poursuite"""
+ raise NotImplementedError("this method must be derivated (in Eficas)")
+
+ def makeContexte(self, f, text):
+ """
+ Interprete le texte fourni (text) issu du fichier f
+ dans le contexte du parent.
+ Cette methode est utile pour le fonctionnement des
+ INCLUDE
+ """
+ # on execute le texte fourni dans le contexte forme par
+ # le contexte de l etape pere (global au sens Python)
+ # et le contexte de l etape (local au sens Python)
+ code = compile(text, f, "exec")
+ d = self.g_context = self.macro_const_context
+ globs = self.getGlobalContexte()
+ d.update(globs)
+ exec(code, globs, d)
+ # pour ne pas conserver des references sur tout
+ self.macro_const_context = {}
+
+ def getGlobalContexte(self):
+ """
+ Cette methode retourne le contexte global fourni
+ par le parent(self) a une etape fille (l'appelant) pour
+ realiser des evaluations de texte Python (INCLUDE,...)
+ """
+ # Le contexte global est forme par concatenation du contexte
+ # du parent de self et de celui de l'etape elle meme (self)
+ # Pour les concepts, cela ne doit rien changer. Mais pour les constantes,
+ # les valeurs de getContexteAvant sont moins recentes que dans
+ # getGlobalContexte. On prend donc la precaution de ne pas ecraser
+ # ce qui y est deja.
+ d = self.parent.getGlobalContexte()
+ d.update(self.g_context)
+ d.update(
+ [
+ (k, v)
+ for k, v in list(self.parent.getContexteAvant(self).items())
+ if d.get(k) is None
+ ]
+ )
+ return d
+
+ def getContexteCourant(self, etape_fille_du_jdc=None):
+ """
+ Retourne le contexte tel qu'il est au moment de l'execution de
+ l'etape courante.
+ """
+ ctx = {}
+ # update car par ricochet on modifierait jdc.currentContext
+ ctx.update(self.parent.getContexteCourant(self))
+ # on peut mettre None car toujours en PAR_LOT='NON', donc la dernière
+ ctx.update(self.getContexteAvant(None))
+ return ctx
+
+ def getConcept(self, nomsd):
+ """
+ Methode pour recuperer un concept a partir de son nom
+ dans le contexte du jdc connu avant l'execution de la macro courante.
+ """
+ # chercher dans self.getContexteAvant, puis si non trouve
+ # self.parent.getConcept est peut-etre plus performant
+ co = self.getContexteCourant().get(nomsd.strip(), None)
+ if not isinstance(co, ASSD):
+ co = None
+ return co
+
+ def getConceptByType(self, nomsd, typesd, etape=None):
+ """
+ Methode pour recuperer un concept a partir de son nom et de son type.
+ Il aura comme père 'etape' (ou la macro courante si etape est absente).
+ """
+ return self.parent.getConceptByType(nomsd, typesd, etape=etape or self)
+
+ def copy(self):
+ """Methode qui retourne une copie de self non enregistree auprès du JDC
+ et sans sd
+ On surcharge la methode de ETAPE pour exprimer que les concepts crees
+ par la MACRO d'origine ne sont pas crees par la copie mais eventuellement
+ seulement utilises
+ """
+ etape = P_ETAPE.ETAPE.copy(self)
+ etape.sdprods = []
+ return etape
+
+ def copyIntern(self, etape):
+ """Cette methode effectue la recopie des etapes internes d'une macro
+ passee en argument (etape)
+ """
+ self.etapes = []
+ self.index_etapes = {}
+ for etp in etape.etapes:
+ new_etp = etp.copy()
+ new_etp.copyReuse(etp)
+ new_etp.copySdnom(etp)
+ new_etp.reparent(self)
+ if etp.sd:
+ new_sd = etp.sd.__class__(etape=new_etp)
+ new_etp.sd = new_sd
+ if etp.reuse:
+ new_sd.setName(etp.sd.nom)
+ else:
+ self.nommerSDProd(new_sd, etp.sd.nom)
+ new_etp.copyIntern(etp)
+ self.etapes.append(new_etp)
+ self.index_etapes[new_etp] = len(self.etapes) - 1
+
+ def resetJdc(self, new_jdc):
+ """
+ Reinitialise l'etape avec un nouveau jdc parent new_jdc
+ """
+ if self.sd and self.reuse == None:
+ self.parent.nommerSDProd(self.sd, self.sd.nom)
+ for concept in self.sdprods:
+ self.parent.nommerSDProd(concept, concept.nom)
+
+ def reparent(self, parent):
+ """
+ Cette methode sert a reinitialiser la parente de l'objet
+ """
+ P_ETAPE.ETAPE.reparent(self, parent)
+ # on ne change pas la parente des concepts. On s'assure uniquement que
+ # le jdc en reference est le bon
+ for concept in self.sdprods:
+ concept.jdc = self.jdc
+ for e in self.etapes:
+ e.reparent(self)
+
+ def updateConstContext(self, d):
+ """
+ Met a jour le contexte des constantes pour l'evaluation de
+ formules dans la macro.
+ """
+ # Dans le jdc, const_context est mis a jour par execCompile
+ # Dans la macro, on n'a pas le code a compiler pour recupèrer les
+ # constantes locales a la macro. On demande donc explicitement de
+ # definir les constantes "locales".
+ self.macro_const_context.update(d)
+
+ def sdAccessible(self):
+ """On peut acceder aux "valeurs" (jeveux) des ASSD dans
+ les macro-commandes qui sont localement en PAR_LOT="NON"
+ sauf pour INCLUDE.
+ """
+ if CONTEXT.debug:
+ print((" `- MACRO sdAccessible :", self.nom))
+ return self.parent.sdAccessible() or not self.isInclude()
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe MCBLOC qui sert à controler la valeur
+ d'un bloc de mots-clés par rapport à sa définition portée par un objet
+ de type ENTITE
+"""
+
+
+import types
+from Accas.processing import P_MCCOMPO
+
+
+class MCBLOC(P_MCCOMPO.MCCOMPO):
+
+ """
+ Classe support d'un bloc de mots-clés.
+
+ """
+
+ nature = "MCBLOC"
+
+ def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction=None):
+ """
+ Attributs :
+
+ - val : valeur du bloc (dictionnaire dont les clés sont des noms de mots-clés et les valeurs
+ les valeurs des mots-clés)
+ - definition : objet de définition de type BLOC associé au bloc (porte les attributs de définition)
+ - nom : nom du bloc. Ce nom lui est donné par celui qui crée le bloc de mot-clé
+ - parent : le créateur du bloc. Ce peut etre un mot-clé facteur ou un autre objet composite de type
+ OBJECT. Si parent vaut None, le bloc ne possède pas de contexte englobant.
+ - mcListe : liste des sous-objets du bloc construite par appel à la méthode buildMc
+ """
+ # print ('MCBLOC' , val, definition, nom, parent)
+ self.definition = definition
+ self.nom = nom
+ self.val = val
+ self.parent = parent
+ self.valeur = val
+ self.objPyxbDeConstruction = None
+ self.dicoPyxbDeConstruction = dicoPyxbDeConstruction
+ self.estIdentifiePar = None
+ if parent:
+ self.jdc = self.parent.jdc
+ self.niveau = self.parent.niveau
+ self.etape = self.parent.etape
+ else:
+ # Le mot cle a été créé sans parent
+ self.jdc = None
+ self.niveau = None
+ self.etape = None
+ self.mcListe = self.buildMc()
+
+ def getValeur(self):
+ """
+ Retourne la "valeur" de l'objet bloc. Il s'agit d'un dictionnaire dont
+ les clés seront les noms des objets de self.mcListe et les valeurs
+ les valeurs des objets de self.mcListe obtenues par application de
+ la méthode getValeur.
+
+ Dans le cas particulier d'un objet bloc les éléments du dictionnaire
+ obtenu par appel de la méthode getValeur sont intégrés au niveau
+ supérieur.
+
+ """
+ dico = {}
+ for mocle in self.mcListe:
+ if mocle.isBLOC():
+ # Si mocle est un BLOC, on inclut ses items dans le dictionnaire
+ # représentatif de la valeur de self. Les mots-clés fils de blocs sont
+ # donc remontés au niveau supérieur.
+ dico.update(mocle.getValeur())
+ else:
+ dico[mocle.nom] = mocle.getValeur()
+
+ # On rajoute tous les autres mots-clés locaux possibles avec la valeur
+ # par défaut ou None
+ # Pour les mots-clés facteurs, on ne traite que ceux avec statut défaut ('d')
+ # et caché ('c')
+ # On n'ajoute aucune information sur les blocs. Ils n'ont pas de défaut seulement
+ # une condition.
+ for k, v in list(self.definition.entites.items()):
+ if not k in dico:
+ if v.label == "SIMP":
+ # Mot clé simple
+ dico[k] = v.defaut
+ elif v.label == "FACT":
+ if v.statut in ("c", "d"):
+ # Mot clé facteur avec défaut ou caché provisoire
+ dico[k] = v(val=None, nom=k, parent=self)
+ # On demande la suppression des pointeurs arrieres
+ # pour briser les eventuels cycles
+ dico[k].supprime()
+ else:
+ dico[k] = None
+
+ return dico
+
+ def isBLOC(self):
+ """
+ Indique si l'objet est un BLOC
+ """
+ return 1
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitMCBLOC(self)
+
+ def makeobjet(self):
+ return self.definition(val=None, nom=self.nom, parent=self.parent)
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe MCCOMPO qui sert à factoriser les comportements
+ des OBJECT composites
+"""
+
+from copy import copy
+from Accas.processing import P_OBJECT
+
+
+class MCCOMPO(P_OBJECT.OBJECT):
+ """
+ Classe support d'un OBJECT composite
+
+ """
+
+ def buildMc(self):
+ """
+ Construit la liste des sous-entites du MCCOMPO
+ à partir du dictionnaire des arguments (valeur)
+ """
+
+ # import traceback
+ # traceback.print_stack()
+ # print(("MCCOMPO.buildMc _____________________________________", self.nom))
+ if CONTEXT.debug:
+ print(("MCCOMPO.buildMc ", self.nom))
+ # Dans la phase de reconstruction args peut contenir des mots-clés
+ # qui ne sont pas dans le dictionnaire des entites de definition (self.definition.entites)
+ # de l'objet courant (self)
+ # mais qui sont malgré tout des descendants de l'objet courant
+ # (petits-fils, ...)
+ args = self.valeur
+ # print ('MCCOMPO___________________', self.valeur)
+ if args == None:
+ args = {}
+ mcListe = []
+
+ # On recopie le dictionnaire des arguments pour protéger l'original des
+ # delete (del args[k])
+ args = args.copy()
+
+ # Phase 1:
+ # On construit les sous entites presentes ou obligatoires
+ # 1- les entites présentes dans les arguments et dans la définition
+ # 2- les entités non présentes dans les arguments, présentes dans la définition avec un défaut
+ # Phase 1.1 : on traite d'abord les SIMP pour enregistrer les mots cles
+ # globaux
+ if not hasattr(self, "dicoPyxbDeConstruction"):
+ self.dicoPyxbDeConstruction = {}
+ for k, v in list(self.definition.entites.items()):
+ if v.label != "SIMP":
+ continue
+ if k in args or v.statut in ("o", "d"):
+ #
+ # Creation par appel de la methode __call__ de la definition de la sous entite k de self
+ # si une valeur existe dans args ou est obligatoire (generique si toutes les
+ # entites ont l attribut statut )
+ #
+ if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction:
+ objPyxbDeConstruction = self.dicoPyxbDeConstruction[k]
+ del self.dicoPyxbDeConstruction[k]
+ else:
+ objPyxbDeConstruction = None
+ # print (args.get(k, None))
+ objet = v(
+ val=args.get(k, None),
+ nom=k,
+ parent=self,
+ objPyxbDeConstruction=objPyxbDeConstruction,
+ )
+ mcListe.append(objet)
+ # Si l'objet a une position globale on l'ajoute aux listes
+ # correspondantes
+ if hasattr(objet.definition, "position"):
+ if objet.definition.position == "global":
+ self.append_mc_global(objet)
+ if objet.definition.position == "reCalculeEtape":
+ # print ('-------------------------- rencontre reCalculeEtape: ', objet.nom)
+ self.append_mc_global_avecRecalcule(objet)
+ elif objet.definition.position == "global_jdc":
+ self.append_mc_global_jdc(objet)
+ if k in args:
+ del args[k]
+
+ # Phase 1.2 : on traite les autres entites que SIMP
+ # FACT ou listeDeFAct en fait car un BLOC ne peut etre present dans les args
+ for k, v in list(self.definition.entites.items()):
+ if v.label == "SIMP":
+ continue
+ if k in args or v.statut == "o":
+ # print ('construit', k)
+ #
+ # Creation par appel de la methode __call__ de la definition de la sous entite k de self
+ # si une valeur existe dans args ou est obligatoire (generique si toutes les
+ # entites ont l attribut statut )
+ #
+ if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction:
+ dicoPyxbDeConstruction = self.dicoPyxbDeConstruction[k]
+ del self.dicoPyxbDeConstruction[k]
+ else:
+ dicoPyxbDeConstruction = None
+ objet = v(
+ val=args.get(k, None),
+ nom=k,
+ parent=self,
+ dicoPyxbDeConstruction=dicoPyxbDeConstruction,
+ )
+ mcListe.append(objet)
+ if k in args:
+ del args[k]
+
+ # Phase 2:
+ # On construit les objets (en général, blocs) conditionnés par les mots-clés précédemment créés.
+ # A ce stade, mcListe ne contient que les fils de l'objet courant
+ # args ne contient plus que des mots-clés qui n'ont pas été attribués car ils sont
+ # à attribuer à des blocs du niveau inférieur ou bien sont des mots-clés erronés
+ for k, v in list(self.definition.entites.items()):
+ if v.label != "BLOC":
+ continue
+ # PNPN on recalcule dico_valeurs dans le for
+ # pour les globaux imbriques (exple Telemac Advection)
+ # avant le calcul etait avant le for
+ dico_valeurs = self.creeDictCondition(mcListe, condition=1)
+ globs = self.jdc and self.jdc.condition_context or {}
+ if v.verifPresence(dico_valeurs, globs):
+ # print ('appel construit bloc', k, 'avec', args, 'a partir de', self.nom )
+ # Si le bloc existe :
+ # 1- on le construit
+ # 2- on l'ajoute à mcListe
+ # 3- on récupère les arguments restant
+ # 4- on reconstruit le dictionnaire équivalent à mcListe
+ bloc = v(
+ nom=k,
+ val=args,
+ parent=self,
+ dicoPyxbDeConstruction=self.dicoPyxbDeConstruction,
+ )
+ mcListe.append(bloc)
+ args = bloc.reste_val
+ # print ('les args deviennent ', args)
+ # On ne recalcule pas le contexte car on ne tient pas compte des blocs
+ # pour évaluer les conditions de présence des blocs
+ # dico_valeurs = self.creeDictValeurs(mcListe)
+
+ # On conserve les arguments superflus dans l'attribut reste_val
+ # les reste_val des blocs vont contenir trop de MC
+ # car ils sont appeles avec tous les MC de leur niveau qui n ont pas ete consommes
+ # et le reste_val n est pas remis a jour
+ # est-ce un pb ? a priori non
+ self.reste_val = args
+ # print ('self.reste_val de ', self.nom, self.reste_val)
+ # On ordonne la liste ainsi créée suivant l'ordre du catalogue
+ # (utile seulement pour IHM graphique)
+ mcListe = self.ordonneListe(mcListe)
+ # on retourne la liste ainsi construite
+ if self.jdc:
+ self.cata = self.jdc.cata
+ else:
+ self.cata = None
+ self.buildObjPyxb(mcListe)
+ # print ('______________________________________ fin ', self.nom)
+ return mcListe
+
+ def buildMcApresGlobalEnSuppression(self):
+ blocsDejaLa = []
+ for mc in self.mcListe:
+ if mc.nature == "MCBLOC":
+ blocsDejaLa.append(mc)
+ for mc in blocsDejaLa:
+ dico_valeurs = self.creeDictCondition(self.mcListe, condition=1)
+ globs = self.jdc and self.jdc.condition_context or {}
+ defBloc = mc.definition
+ if not (defBloc.verifPresence(dico_valeurs, globs)):
+ self.suppEntite(mc)
+
+ def reConstruitResteVal(self):
+ # normal que apres buildMcApresGlobalEnCreation les reste_val ne soient pas corrects
+ for mc in self.mcListe:
+ if mc.nom in self.reste_val:
+ del self.reste_val[mc.nom]
+ if mc.nature == "MCBLOC":
+ ancetre = mc.parent
+ for mcFDuMc in mc.mcListe:
+ while ancetre.nature == "MCBLOC":
+ ancetre = ancetre.parent
+ if mcFDuMc.nom in ancetre.reste_val:
+ del ancetre.reste_val[mcFDuMc.nom]
+ if mc.nature == "MCSIMP":
+ continue
+ if mc.nature == "MCList":
+ for mcObj in mc.data:
+ mcObj.reConstruitResteVal()
+ else:
+ mc.reConstruitResteVal()
+
+ def buildMcApresGlobalEnCreation(self):
+ nouveau_args = self.reste_val
+ blocsDejaLa = []
+ for mc in self.mcListe:
+ if mc.nature == "MCBLOC":
+ blocsDejaLa.append(mc.nom)
+ for k, v in list(self.definition.entites.items()):
+ if v.label != "BLOC":
+ continue
+ if k in blocsDejaLa:
+ continue
+ dico_valeurs = self.creeDictCondition(self.mcListe, condition=1)
+ globs = self.jdc and self.jdc.condition_context or {}
+ if v.verifPresence(dico_valeurs, globs):
+ bloc = v(
+ nom=k,
+ val=nouveau_args,
+ parent=self,
+ dicoPyxbDeConstruction=self.dicoPyxbDeConstruction,
+ )
+ if bloc:
+ self.mcListe.append(bloc)
+ bloc.addObjPyxb(self.chercheIndiceDsLeContenu(bloc))
+ nouveau_args = self.reste_val
+ self.reste_val = bloc.reste_val
+
+ def ordonneListe(self, mcListe):
+ """
+ Ordonne la liste suivant l'ordre du catalogue.
+ Seulement pour IHM graphique
+ """
+ if self.jdc and self.jdc.cata_ordonne_dico != None:
+ liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(
+ self.getGenealogie(), self.jdc.cata_ordonne_dico
+ )
+ return self.ordonneListeMc(mcListe, liste_noms_mc_ordonnee)
+ else:
+ return mcListe
+
+ def creeDictValeurs(self, liste=[], condition=0):
+ """
+ Cette méthode crée un contexte (sous la forme d'un dictionnaire)
+ à partir des valeurs des mots clés contenus dans l'argument liste.
+ L'opération consiste à parcourir la liste (d'OBJECT) et à la
+ transformer en un dictionnaire dont les clés sont les noms des
+ mots clés et les valeurs dépendent du type d'OBJECT.
+ Ce dictionnaire servira de liste d'arguments d'appel pour les
+ fonctions sd_prod de commandes et ops de macros ou de contexte
+ d'évaluation des conditions de présence de BLOC.
+
+ Si l'argument condition de la méthode vaut 1, on ne
+ remonte pas les valeurs des mots clés contenus dans des blocs
+ pour eviter les bouclages.
+
+ Cette méthode réalise les opérations suivantes en plus de transformer
+ la liste en dictionnaire :
+
+ - ajouter tous les mots-clés non présents avec la valeur None
+ - ajouter tous les mots-clés globaux (attribut position = 'global'
+ et 'global_jdc')
+
+ L'argument liste est, en général, une mcListe en cours de
+ construction, contenant les mots-clés locaux et les blocs déjà créés.
+
+ """
+ dico = {}
+ for v in liste:
+ if v.isBLOC():
+ # Si v est un BLOC, on inclut ses items dans le dictionnaire
+ # représentatif du contexte. Les blocs sont retournés par getValeur
+ # sous la forme d'un dictionnaire : les mots-clés fils de blocs sont
+ # donc remontés au niveau du contexte.
+ if not condition:
+ dadd = v.getValeur()
+ assert intersection_vide(dico, dadd)
+ dico.update(dadd)
+ else:
+ assert not v.nom in dico, "deja vu : %s" % v.nom
+ dico[v.nom] = v.getValeur()
+
+ # On rajoute tous les autres mots-clés locaux possibles avec la valeur
+ # par défaut ou None
+ # Pour les mots-clés facteurs, on ne traite que ceux avec statut défaut ('d')
+ # et caché ('c')
+ # On n'ajoute aucune information sur les blocs. Ils n'ont pas de défaut seulement
+ # une condition.
+ # XXX remplacer le not has_key par un dico différent et faire dico2.update(dico)
+ # ce n'est qu'un pb de perf
+ for k, v in list(self.definition.entites.items()):
+ if not k in dico:
+ if v.label == "SIMP":
+ # Mot clé simple
+ dico[k] = v.defaut
+ elif v.label == "FACT":
+ if v.statut in ("c", "d"):
+ # Mot clé facteur avec défaut ou caché provisoire
+ dico[k] = v(val=None, nom=k, parent=self)
+ # On demande la suppression des pointeurs arrieres
+ # pour briser les eventuels cycles
+ dico[k].supprime()
+ else:
+ dico[k] = None
+ # A ce stade on a rajouté tous les mots-clés locaux possibles (fils directs) avec leur
+ # valeur par défaut ou la valeur None
+
+ # On rajoute les mots-clés globaux sans écraser les clés existantes
+ dico_mc = self.rechercheMcGlobaux()
+ dico_mc.update(dico)
+ dico = dico_mc
+
+ return dico
+
+ def creeDictToutesValeurs(self):
+ """Semblable à `creeDictValeurs(liste=self.mcListe)` en supprimant les
+ valeurs None."""
+ dico = self.creeDictValeurs(self.mcListe, condition=0)
+ dico = dict([(k, v) for k, v in list(dico.items()) if v is not None])
+ return dico
+
+ def creeDictCondition(self, liste=[], condition=0):
+ """
+ Methode pour construire un contexte qui servira dans l'évaluation
+ des conditions de présence de blocs. Si une commande a un concept
+ produit réutilisé, on ajoute la clé 'reuse'
+ """
+ dico = self.creeDictValeurs(liste, condition=1)
+ # On ajoute la cle "reuse" pour les MCCOMPO qui ont un attribut reuse. A destination
+ # uniquement des commandes. Ne devrait pas etre dans cette classe mais
+ # dans une classe dérivée
+ if not "reuse" in dico and hasattr(self, "reuse"):
+ dico["reuse"] = self.reuse
+ return dico
+
+ def rechercheMcGlobaux(self):
+ """
+ Retourne la liste des mots-clés globaux de l'étape à laquelle appartient self
+ et des mots-clés globaux du jdc
+ """
+ etape = self.getEtape()
+ if etape:
+ dict_mc_globaux_fac = self.rechercheMcGlobauxFacultatifs()
+ for k, v in list(etape.mc_globaux.items()):
+ dict_mc_globaux_fac[k] = v.getValeur()
+ if self.jdc:
+ for k, v in list(self.jdc.mc_globaux.items()):
+ dict_mc_globaux_fac[k] = v.getValeur()
+ return dict_mc_globaux_fac
+ else:
+ return {}
+
+ def rechercheMcGlobauxFacultatifs(self):
+ """
+ Cette méthode interroge la définition de self et retourne la liste des mots-clés fils
+ directs de self de type 'global'.
+ position='global' n'est donc possible (et n'a de sens) qu'au plus haut niveau.
+ du coup ici on ajoute les globaux de l etape qui sont dans mc_recalculeEtape
+ """
+ # print ('je passe par ici', self.nom)
+ dico = {}
+ etape = self.getEtape()
+ if not etape:
+ return {}
+ for k, v in list(etape.definition.entites.items()):
+ if v.label != "SIMP":
+ continue
+ if v.position == "local":
+ continue
+ if v.position == "inGetAttribut":
+ continue
+ if v.position == "reCalculeEtape":
+ continue
+ if v.statut == "o":
+ continue
+ obj = v(val=None, nom=k, parent=etape)
+ dico[k] = obj.getValeur()
+ return dico
+
+ def supprime(self):
+ """
+ Méthode qui supprime toutes les références arrières afin que l'objet puisse
+ etre correctement détruit par le garbage collector
+ """
+ P_OBJECT.OBJECT.supprime(self)
+ for child in self.mcListe:
+ child.supprime()
+
+ def __getitem__(self, key):
+ """
+ Cette méthode retourne la valeur d'un sous mot-clé (key)
+ """
+ return self.getMocle(key)
+
+ def getMocle(self, key):
+ """
+ Retourne la valeur du sous mot-clé key
+ Ce sous mot-clé peut exister, avoir une valeur par defaut ou etre
+ dans un BLOC fils de self
+ """
+ # on cherche dans les mots cles presents, le mot cle de nom key
+ # s'il est là on retourne sa valeur (méthode getVal)
+ for child in self.mcListe:
+ if child.nom == key:
+ return child.getValeur()
+ # Si on n a pas trouve de mot cle present on retourne le defaut
+ # eventuel pour les mots cles accessibles dans la definition
+ # a ce niveau
+ try:
+ d = self.definition.entites[key]
+ if d.label == "SIMP":
+ return d.defaut
+ elif d.label == "FACT":
+ # il faut construire les objets necessaires pour
+ # evaluer les conditions des blocs eventuels (a faire)
+ if d.statut == "o":
+ return None
+ if d.statut != "c" and d.statut != "d":
+ return None
+ else:
+ return d(val=None, nom=key, parent=self)
+ except KeyError:
+ # le mot cle n est pas defini a ce niveau
+ pass
+ # Si on a toujours rien trouve, on cherche dans les blocs presents
+ # On suppose que tous les blocs possibles ont ete crees meme ceux
+ # induits par un mot cle simple absent avec defaut (???)
+ for mc in self.mcListe:
+ if not mc.isBLOC():
+ continue
+ try:
+ return mc.getMocle(key)
+ except:
+ # On n a rien trouve dans ce bloc, on passe au suivant
+ pass
+ # On a rien trouve, le mot cle est absent.
+ # On leve une exception
+ raise IndexError("Le mot cle %s n existe pas dans %s" % (key, self))
+
+ def getChild(self, name, restreint="non"):
+ """
+ Retourne le fils de self de nom name ou None s'il n'existe pas
+ Si restreint vaut oui : ne regarde que dans la mcListe
+ Si restreint vaut non : regarde aussi dans les entites possibles
+ avec defaut (Ce dernier cas n'est utilisé que dans le catalogue)
+ """
+ for v in self.mcListe:
+ if v.nom == name:
+ return v
+ if restreint == "non":
+ try:
+ entite = self.definition.entites[name]
+ if entite.label == "SIMP" or (
+ entite.label == "FACT" and entite.statut in ("c", "d")
+ ):
+ return entite(None, name, None)
+ except:
+ pass
+
+ return None
+
+ def getChildOrChildInBloc(self, name, restreint="non"):
+ # cherche dans les fils et les fils des blocs
+ # tout est base sur le fait que deux freres ne peuvent pas avoir le meme nom
+ # dans des blocs non exclusifs, sinon le .comm n est pas du python valide
+ for v in self.mcListe:
+ if v.nom == name:
+ return v
+ if restreint == "non":
+ try:
+ entite = self.definition.entites[name]
+ if entite.label == "SIMP" or (
+ entite.label == "FACT" and entite.statut in ("c", "d")
+ ):
+ return entite(None, name, None)
+ except:
+ pass
+ for v in self.mcListe:
+ if v.nature == "MCBLOC":
+ petitFils = v.getChildOrChildInBloc(name, restreint)
+ if petitFils != None:
+ return petitFils
+ return None
+
+ def append_mc_global_avecRecalcule(self, mc):
+ etape = self.getEtape()
+ if etape:
+ nom = mc.nom
+ if not (nom in etape.mc_globaux):
+ etape.doitEtreRecalculee = True
+ etape.mc_globaux[nom] = mc
+ # print ('ajout de nom', mc.nom, 'ds les mc_globaux de', etape.nom)
+
+ def append_mc_global(self, mc):
+ """
+ Ajoute le mot-clé mc à la liste des mots-clés globaux de l'étape
+ """
+ etape = self.getEtape()
+ if etape:
+ nom = mc.nom
+ etape.mc_globaux[nom] = mc
+
+ def append_mc_global_jdc(self, mc):
+ """
+ Ajoute le mot-clé mc à la liste des mots-clés globaux du jdc
+ """
+ nom = mc.nom
+ self.jdc.mc_globaux[nom] = mc
+
+ def copy(self):
+ """Retourne une copie de self"""
+ objet = self.makeobjet()
+ # attention !!! avec makeobjet, objet a le meme parent que self
+ # ce qui n'est pas du tout bon dans le cas d'une copie !!!!!!!
+ # le pb c'est qu'on vérifie ensuite quel parent avait l'objet
+ # Il me semble preferable de changer le parent a la fin quand la copie
+ # est acceptee
+ objet.valeur = copy(self.valeur)
+ objet.val = copy(self.val)
+ objet.mcListe = []
+ for obj in self.mcListe:
+ new_obj = obj.copy()
+ new_obj.reparent(objet)
+ objet.mcListe.append(new_obj)
+ return objet
+
+ def reparent(self, parent):
+ """
+ Cette methode sert a reinitialiser la parente de l'objet
+ """
+ self.parent = parent
+ self.jdc = parent.getJdcRoot()
+ self.etape = parent.etape
+ for mocle in self.mcListe:
+ mocle.reparent(self)
+
+ def getSd_utilisees(self):
+ """
+ Retourne la liste des concepts qui sont utilisés à l'intérieur de self
+ ( comme valorisation d'un MCS)
+ """
+ l = []
+ for child in self.mcListe:
+ l.extend(child.getSd_utilisees())
+ return l
+
+ def getSdMCSUtilisees(self):
+ """
+ Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
+ - Si aucune sd n'est utilisée, le dictionnaire est vide.
+ - Sinon, les clés du dictionnaire sont les mots-clés derrière lesquels on
+ trouve des sd ; la valeur est la liste des sd attenante.
+ Exemple ::
+
+ { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
+ <Cata.cata.fonction_sdaster instance at 0x941a204> ],
+ 'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
+ """
+ dico = {}
+ for child in self.mcListe:
+ daux = child.getSdMCSUtilisees()
+ for cle in daux:
+ dico[cle] = dico.get(cle, [])
+ dico[cle].extend(daux[cle])
+ return dico
+
+ def getMcsWithCo(self, co):
+ """
+ Cette methode retourne l'objet MCSIMP fils de self
+ qui a le concept co comme valeur.
+ En principe, elle ne doit etre utilisee que pour les concepts
+ instances de la classe CO
+ """
+ l = []
+ for child in self.mcListe:
+ l.extend(child.getMcsWithCo(co))
+ return l
+
+ def getAllCo(self):
+ """
+ Cette methode retourne tous les concepts instances de CO
+ """
+ l = []
+ for child in self.mcListe:
+ l.extend(child.getAllCo())
+ return l
+
+ # def getSdCreeParObjetAvecFiltre(self,objetAssdMultiple):
+ # est-ce que si on est bloc, il faut passer à parent ?
+ # ou prevoir une autre fonction qui tienne compte de cela
+ # ou prevoir un xpath
+ # classeAChercher = objetAssdMultiple.definition.type
+ # filtre = objetAssdMultiple.definition.filtre
+ # print ('getSdCreeParObjetAvecFiltre', classeAChercher, filtre)
+ # dicoValeurs = self.creeDictCondition(self.mcListe, condition=1)
+ # l=[]
+ # for k,v in self.jdc.sdsDict.items():
+ # if (isinstance(v, classeAChercher)) :
+ # if v.executeExpression(filtre,dicoValeurs) : l.append(k)
+ # return l
+
+
+def intersection_vide(dict1, dict2):
+ """Verification qu'il n'y a pas de clé commune entre 'dict1' et 'dict2'."""
+ sk1 = set(dict1)
+ sk2 = set(dict2)
+ inter = sk1.intersection(sk2)
+ ok = len(inter) == 0
+ if not ok:
+ print(("ERREUR: Mot(s)-clef(s) vu(s) plusieurs fois :", tuple(inter)))
+ return ok
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe MCFACT qui sert à controler la valeur
+ d'un mot-clé facteur par rapport à sa définition portée par un objet
+ de type ENTITE
+"""
+from Accas.processing import P_MCCOMPO
+
+
+class MCFACT(P_MCCOMPO.MCCOMPO):
+ nature = "MCFACT"
+
+ def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction):
+ """
+ Attributs :
+ - val : valeur du mot clé simple
+ - definition
+ - nom
+ - parent
+ """
+ # print ('MCFACT', self, val, definition, nom, parent, dicoPyxbDeConstruction)
+ # import traceback
+ # traceback.print_stack()
+ self.dicoPyxbDeConstruction = dicoPyxbDeConstruction
+ if self.dicoPyxbDeConstruction:
+ self.objPyxbDeConstruction = self.dicoPyxbDeConstruction["objEnPyxb"]
+ del self.dicoPyxbDeConstruction["objEnPyxb"]
+ else:
+ self.objPyxbDeConstruction = None
+ self.definition = definition
+ self.nom = nom
+ self.val = val
+ self.parent = parent
+ self.estIdentifiePar = None
+ self.valeur = self.getValeurEffective(self.val)
+ if parent:
+ self.jdc = self.parent.jdc
+ self.niveau = self.parent.niveau
+ self.etape = self.parent.etape
+ else:
+ # Le mot cle a été créé sans parent
+ self.jdc = None
+ self.niveau = None
+ self.etape = None
+ self.mcListe = self.buildMc()
+
+ def getValeurEffective(self, val):
+ """
+ Retourne la valeur effective du mot-clé en fonction
+ de la valeur donnée. Defaut si val == None
+ """
+ if val is None and hasattr(self.definition, "defaut"):
+ return self.definition.defaut
+ else:
+ return val
+
+ def getValeur(self):
+ """
+ Retourne la "valeur" d'un mot-clé facteur qui est l'objet lui-meme.
+ Cette valeur est utilisée lors de la création d'un contexte
+ d'évaluation d'expressions à l'aide d'un interpréteur Python
+ """
+ return self
+
+ def getVal(self):
+ """
+ Une autre méthode qui retourne une "autre" valeur du mot clé facteur.
+ Elle est utilisée par la méthode getMocle
+ """
+ return [self]
+
+ def __getitem__(self, key):
+ """
+ Dans le cas d un mot cle facteur unique on simule une liste de
+ longueur 1
+ """
+ if key == 0:
+ return self
+ return self.getMocle(key)
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitMCFACT(self)
+
+ def makeobjet(self):
+ return self.definition.class_instance(
+ val=None, nom=self.nom, definition=self.definition, parent=self.parent
+ )
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe MCList qui sert à controler la valeur
+ d'une liste de mots-clés facteur par rapport à sa définition portée par un objet
+ de type ENTITE
+"""
+from copy import copy
+import types
+from collections import UserList
+
+class MCList(UserList):
+
+ """Liste semblable a la liste Python
+ mais avec quelques methodes en plus
+ = liste de MCFACT
+ """
+
+ nature = "MCList"
+
+ def init(self, nom, parent):
+ self.objPyxbDeConstruction = None
+ self.definition = None
+ self.nom = nom
+ self.parent = parent
+ if parent:
+ self.jdc = self.parent.jdc
+ self.niveau = self.parent.niveau
+ self.etape = self.parent.etape
+ else:
+ # Le mot cle a été créé sans parent
+ self.jdc = None
+ self.niveau = None
+ self.etape = None
+
+ def getValeur(self):
+ """
+ Retourne la "valeur" d'un objet MCList. Sert à construire
+ un contexte d'évaluation pour une expression Python.
+ On retourne l'objet lui-meme.
+ """
+ return self
+
+ def getVal(self):
+ """
+ Une autre méthode qui retourne une "autre" valeur d'une MCList
+ Elle est utilisée par la méthode getMocle
+ """
+ return self
+
+ def supprime(self):
+ """
+ Méthode qui supprime toutes les références arrières afin que l'objet puisse
+ etre correctement détruit par le garbage collector
+ """
+ self.parent = None
+ self.etape = None
+ self.jdc = None
+ self.niveau = None
+ for child in self.data:
+ child.supprime()
+
+ def getChild(self, name, restreint="non"):
+ """
+ Retourne le fils de nom name s'il est contenu dans self
+ Par défaut retourne le fils du premier de la liste
+ """
+ obj = self.data[0]
+ # Phase 1 : on cherche dans les fils directs de obj
+ for child in obj.mcListe:
+ if child.nom == name:
+ return child
+ # Phase 2 : on cherche dans les blocs de self
+ for child in obj.mcListe:
+ if child.isBLOC():
+ resu = child.getChild(name)
+ if resu != None:
+ return resu
+ # Phase 3 : on cherche dans les entites possibles pour les défauts
+ for k, v in list(obj.definition.entites.items()):
+ # if k == name: return v.defaut
+ if k == name:
+ if v.defaut != None:
+ return v(None, k, None)
+ # si on passe ici, c'est que l'on demande un fils qui n'est pas possible --> erreur
+ # print "Erreur : %s ne peut etre un descendant de %s" %(name,self.nom)
+ return None
+
+ def getAllChild(self, name):
+ # A utiliser uniquement dans un filtre
+ maListeRetour = MCList()
+ for obj in self.data:
+ for objFils in obj.getChild(name):
+ maListeRetour.append(objFils)
+ return maListeRetour
+
+ def isBLOC(self):
+ """
+ Indique si l'objet est de type BLOC
+ """
+ return 0
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitMCList(self)
+
+ def getSd_utilisees(self):
+ """
+ Retourne la liste des concepts qui sont utilisés à l'intérieur de self
+ ( comme valorisation d'un MCS)
+ """
+ l = []
+ for child in self.data:
+ l.extend(child.getSd_utilisees())
+ return l
+
+ def getSdMCSUtilisees(self):
+ """
+ Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
+ - Si aucune sd n'est utilisée, le dictionnaire est vide.
+ - Sinon, les clés du dictionnaire sont les mots-clés derrière lesquels on
+ trouve des sd ; la valeur est la liste des sd attenante.
+
+ Exemple ::
+
+ { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
+ <Cata.cata.fonction_sdaster instance at 0x941a204> ],
+ 'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
+ """
+ dico = {}
+ for child in self.data:
+ daux = child.getSdMCSUtilisees()
+ for cle in daux:
+ dico[cle] = dico.get(cle, [])
+ dico[cle].extend(daux[cle])
+ return dico
+
+ def getMcsWithCo(self, co):
+ """
+ Cette methode retourne l'objet MCSIMP fils de self
+ qui a le concept co comme valeur.
+ En principe, elle ne doit etre utilisee que pour les concepts
+ instances de la classe CO
+ """
+ l = []
+ for child in self.data:
+ l.extend(child.getMcsWithCo(co))
+ return l
+
+ def getAllCo(self):
+ """
+ Cette methode retourne tous les concepts instances de CO
+ """
+ l = []
+ for child in self.data:
+ l.extend(child.getAllCo())
+ return l
+
+ def copy(self):
+ """
+ Réalise la copie d'une MCList
+ """
+ liste = self.data[0].definition.list_instance()
+ # FR -->Il faut spécifier un parent pour la méthode init qui attend 2
+ # arguments ...
+ liste.init(self.nom, self.parent)
+ for objet in self:
+ new_obj = objet.copy()
+ # Pour etre coherent avec le constructeur de mots cles facteurs P_FACT.__call__
+ # dans lequel le parent de l'element d'une MCList est le parent de
+ # la MCList
+ new_obj.reparent(self.parent)
+ liste.append(new_obj)
+ return liste
+
+ def reparent(self, parent):
+ """
+ Cette methode sert a reinitialiser la parente de l'objet
+ """
+ self.parent = parent
+ self.jdc = parent.jdc
+ self.etape = parent.etape
+ for mcfact in self.data:
+ mcfact.reparent(parent)
+
+ def getEtape(self):
+ """
+ Retourne l'étape à laquelle appartient self
+ Un objet de la catégorie etape doit retourner self pour indiquer que
+ l'étape a été trouvée
+ XXX double emploi avec self.etape ???
+ """
+ if self.parent == None:
+ return None
+ return self.parent.getEtape()
+
+ def __getitem__(self, key):
+ """
+ Dans le cas d un mot cle facteur de longueur 1 on simule un scalaire
+ """
+ if type(key) != int and len(self) == 1:
+ return self.data[0].getMocle(key)
+ else:
+ return self.data[key]
+
+ def List_F(self):
+ """
+ Retourne une liste de dictionnaires (eventuellement singleton) qui peut etre
+ passe directement derriere un mot-cle facteur (pour les macros).
+ """
+ dresu = []
+ for mcf in self:
+ dico = mcf.creeDictValeurs(mcf.mcListe)
+ for i in list(dico.keys()):
+ if dico[i] == None:
+ del dico[i]
+ dresu.append(dico)
+ return dresu
+
+ def longueurDsArbre(self):
+ # pour Pyxb : longueur dans le orderedcontent de pyxb
+ return len(self)
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe MCSIMP qui sert à controler la valeur
+ d'un mot-clé simple par rapport à sa définition portée par un objet
+ de type ENTITE
+"""
+
+from copy import copy
+from Accas.processing.P_ASSD import ASSD
+from Accas.processing.P_UserASSDMultiple import UserASSDMultiple
+from Accas.processing.P_CO import CO
+from Accas.processing import P_OBJECT
+from Accas.processing.P_CONVERT import ConversionFactory
+from Accas.processing.P_types import forceList, isSequence
+
+
+class MCSIMP(P_OBJECT.OBJECT):
+
+ """ """
+
+ nature = "MCSIMP"
+
+ def __init__(self, val, definition, nom, parent, objPyxbDeConstruction):
+ """
+ Attributs :
+ - val : valeur du mot clé simple
+ - definition
+ - nom
+ - parent
+
+ Autres attributs :
+
+ - valeur : valeur du mot-clé simple en tenant compte de la valeur par défaut
+
+ """
+ # print (self, val, definition, nom, parent)
+ self.definition = definition
+ self.nom = nom
+ self.val = val
+ self.parent = parent
+ self.objPyxbDeConstruction = objPyxbDeConstruction
+ if parent:
+ self.jdc = self.parent.jdc
+ if self.jdc:
+ self.cata = self.jdc.cata
+ else:
+ self.cata = None
+ self.niveau = self.parent.niveau
+ self.etape = self.parent.etape
+ else:
+ # Le mot cle simple a été créé sans parent
+ # est-ce possible ?
+ print("P_MCSIMP dans le else sans parent du build")
+ self.jdc = None
+ self.cata = None
+ self.niveau = None
+ self.etape = None
+ if self.definition.creeDesObjets:
+ if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple):
+ self.convProto = ConversionFactory(
+ "UserASSDMultiple", self.definition.creeDesObjetsDeType
+ )
+ else:
+ self.convProto = ConversionFactory(
+ "UserASSD", self.definition.creeDesObjetsDeType
+ )
+ else:
+ self.convProto = ConversionFactory("type", typ=self.definition.type)
+ self.valeur = self.getValeurEffective(self.val)
+ if self.definition.utiliseUneReference:
+ if self.valeur != None:
+ if not type(self.valeur) in (list, tuple):
+ self.valeur.ajoutUtilisePar(self)
+ else:
+ # PNPN --> chgt pour Vimmp
+ for v in self.valeur:
+ # print (v, type(v))
+ v.ajoutUtilisePar(self)
+ # try : v.ajoutUtilisePar(self)
+ # except : print ('il y a un souci ici', self.nom, self.valeur)
+ self.buildObjPyxb()
+ self.listeNomsObjsCrees = []
+
+ def getValeurEffective(self, val):
+ """
+ Retourne la valeur effective du mot-clé en fonction
+ de la valeur donnée. Defaut si val == None
+ Attention aux UserASSD et aux into (exple Wall gp de maille et 'Wall')
+ """
+ # print ('getValeurEffective ________________', val)
+ if val is None and hasattr(self.definition, "defaut"):
+ val = self.definition.defaut
+ if self.definition.type[0] == "TXM" and isinstance(val, str):
+ return val
+ if self.definition.creeDesObjets:
+ # isinstance(val, self.definition.creeDesObjetsDeType) ne fonctionne pas car il y a un avec cata devant et l autre non
+ if val == None:
+ return val
+ if not isinstance(val, (list, tuple)):
+ valATraiter = [
+ val,
+ ]
+ else:
+ valATraiter = val
+ listeRetour = []
+ for v in valATraiter:
+ # print (v.__class__.__name__, self.definition.creeDesObjetsDeType.__name__)
+ if not (
+ v.__class__.__name__ == self.definition.creeDesObjetsDeType.__name__
+ ):
+ if self.jdc != None and v in list(self.jdc.sdsDict.keys()):
+ v = self.jdc.sdsDict[v]
+ else:
+ v = self.convProto.convert(v)
+ if v.parent == None:
+ v.initialiseParent(self)
+ if issubclass(
+ self.definition.creeDesObjetsDeType, UserASSDMultiple
+ ):
+ v.ajouteUnPere(self)
+ else:
+ if v.nom == "sansNom":
+ for leNom, laVariable in self.jdc.g_context.items():
+ # print (leNom,laVariable)
+ if id(laVariable) == id(v) and (leNom != "sansNom"):
+ v.initialiseNom(leNom)
+ if v.parent == None:
+ v.initialiseParent(self)
+ if issubclass(
+ self.definition.creeDesObjetsDeType, UserASSDMultiple
+ ):
+ v.ajouteUnPere(self)
+ listeRetour.append(v)
+ if isinstance(val, (list, tuple)):
+ newVal = listeRetour
+ else:
+ newVal = listeRetour[0]
+ return newVal
+ if self.convProto:
+ val = self.convProto.convert(val)
+ return val
+
+ def creeUserASSDetSetValeur(self, val):
+ self.state = "changed"
+ nomVal = val
+ if nomVal in self.jdc.sdsDict.keys():
+ if isinstance(
+ self.jdc.sdsDict[nomVal], self.definition.creeDesObjetsDeType
+ ):
+ if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple):
+ p = self.parent
+ while p in self.parent:
+ if hasattr(p, "listeDesReferencesCrees"):
+ p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal])
+ else:
+ p.listeDesReferencesCrees = [
+ self.jdc.sdsDict[nomVal],
+ ]
+ p = p.parent
+ self.jdc.sdsDict[nomVal].ajouteUnPere(self)
+ # return (1, 'reference ajoutee')
+ else:
+ return (0, "concept non multiple deja reference")
+ else:
+ return (0, "concept d un autre type existe deja")
+ if self.convProto:
+ objVal = self.convProto.convert(nomVal)
+ objVal.initialiseNom(nomVal)
+ if objVal.parent == None:
+ objVal.initialiseParent(self)
+ objVal.ajouteUnPere(self)
+ p = self.parent
+ while p in self.parent:
+ # print ('mise a jour de ',p)
+ if hasattr(p, "listeDesReferencesCrees"):
+ p.listeDesReferencesCrees.append(objVal)
+ else:
+ p.listeDesReferencesCrees = [
+ objVal,
+ ]
+ p = p.parent
+ return (self.setValeur(objVal), "reference creee")
+
+ def creeUserASSD(self, val):
+ self.state = "changed"
+ nomVal = val
+ if nomVal in self.jdc.sdsDict.keys():
+ if isinstance(
+ self.jdc.sdsDict[nomVal], self.definition.creeDesObjetsDeType
+ ):
+ if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple):
+ p = self.parent
+ while p in self.parent:
+ if hasattr(p, "listeDesReferencesCrees"):
+ p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal])
+ else:
+ p.listeDesReferencesCrees = [
+ self.jdc.sdsDict[nomVal],
+ ]
+ p = p.parent
+ self.jdc.sdsDict[nomVal].ajouteUnPere(self)
+ return (1, self.jdc.sdsDict[nomVal], "reference ajoutee")
+ else:
+ return (0, None, "concept d un autre type existe deja")
+ else:
+ return (0, None, "concept d un autre type existe deja")
+ if self.convProto:
+ objVal = self.convProto.convert(nomVal)
+ objVal.initialiseNom(nomVal)
+ objVal.ajouteUnPere(self)
+ return (1, objVal, "reference creee")
+
+ def rattacheUserASSD(self, objASSD):
+ if objASSD.parent == None:
+ objASSD.initialiseParent(self)
+ p = self.parent
+ while p in self.parent:
+ if hasattr(p, "listeDesReferencesCrees"):
+ p.listeDesReferencesCrees.append(objASSD)
+ else:
+ p.listeDesReferencesCrees = [
+ objASSD,
+ ]
+ p = p.parent
+
+ def getValeur(self):
+ """
+ Retourne la "valeur" d'un mot-clé simple.
+ Cette valeur est utilisée lors de la création d'un contexte
+ d'évaluation d'expressions à l'aide d'un interpréteur Python
+ """
+ v = self.valeur
+ # Si singleton et max=1, on retourne la valeur.
+ # Si une valeur simple et max='**', on retourne un singleton.
+ # (si liste de longueur > 1 et max=1, on sera arrêté plus tard)
+ # Pour accepter les numpy.array, on remplace : "type(v) not in (list, tuple)"
+ # par "not has_attr(v, '__iter__')".
+ if v is None:
+ pass
+ elif isSequence(v) and len(v) == 1 and self.definition.max == 1:
+ v = v[0]
+ elif not isSequence(v) and self.definition.max != 1:
+ v = (v,)
+ # traitement particulier pour les complexes ('RI', r, i)
+ if (
+ "C" in self.definition.type
+ and self.definition.max != 1
+ and v != None
+ and v[0] in ("RI", "MP")
+ ):
+ v = (v,)
+ return v
+
+ def getVal(self):
+ """
+ Une autre méthode qui retourne une "autre" valeur du mot clé simple.
+ Elle est utilisée par la méthode getMocle
+ """
+ return self.valeur
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitMCSIMP(self)
+
+ def copy(self):
+ """Retourne une copie de self"""
+ objet = self.makeobjet()
+ # il faut copier les listes et les tuples mais pas les autres valeurs
+ # possibles (réel,SD,...)
+ if type(self.valeur) in (list, tuple):
+ objet.valeur = copy(self.valeur)
+ else:
+ objet.valeur = self.valeur
+ objet.val = objet.valeur
+ return objet
+
+ def makeobjet(self):
+ return self.definition(val=None, nom=self.nom, parent=self.parent)
+
+ def reparent(self, parent):
+ """
+ Cette methode sert a reinitialiser la parente de l'objet
+ """
+ self.parent = parent
+ self.jdc = parent.jdc
+ self.etape = parent.etape
+
+ def getSd_utilisees(self):
+ """
+ Retourne une liste qui contient la ou les SD utilisée par self si c'est le cas
+ ou alors une liste vide
+ """
+ l = []
+ if isinstance(self.valeur, ASSD):
+ l.append(self.valeur)
+ elif type(self.valeur) in (list, tuple):
+ for val in self.valeur:
+ if isinstance(val, ASSD):
+ l.append(val)
+ return l
+
+ def getSdMCSUtilisees(self):
+ """
+ Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
+ - Si aucune sd n'est utilisée, le dictionnaire est vide.
+ - Sinon, la clé du dictionnaire est le mot-clé simple ; la valeur est
+ la liste des sd attenante.
+
+ Exemple ::
+ { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
+ <Cata.cata.fonction_sdaster instance at 0x941a204> ] }
+ """
+ l = self.getSd_utilisees()
+ dico = {}
+ if len(l) > 0:
+ dico[self.nom] = l
+ return dico
+
+ def getMcsWithCo(self, co):
+ """
+ Cette methode retourne l'objet MCSIMP self s'il a le concept co
+ comme valeur.
+ """
+ if co in forceList(self.valeur):
+ return [
+ self,
+ ]
+ return []
+
+ def getAllCo(self):
+ """
+ Cette methode retourne la liste de tous les concepts co
+ associés au mot cle simple
+ """
+ return [
+ co for co in forceList(self.valeur) if isinstance(co, CO) and co.isTypCO()
+ ]
+
+ def supprime(self):
+ if not type(self.valeur) in (list, tuple):
+ lesValeurs = (self.valeur,)
+ else:
+ lesValeurs = self.valeur
+ if self.valeur == None or self.valeur == []:
+ lesValeurs = []
+ for val in lesValeurs:
+ if self.definition.creeDesObjets:
+ val.deleteReference(self)
+ else:
+ if hasattr(val, "enleveUtilisePar"):
+ val.enleveUtilisePar(self)
+ P_OBJECT.OBJECT.supprime(self)
+
+ def getUserAssdPossible(self):
+ debug = False
+ if self.nom == "ApplyOn":
+ debug = True
+ if debug:
+ print("____________", self, self.nom)
+ classeAChercher = self.definition.type
+ if debug:
+ print("____________", classeAChercher)
+ l = []
+ dicoValeurs = {}
+ d = {}
+ if debug:
+ print("____________", self.definition.filtreVariables)
+ if self.definition.filtreVariables != None:
+ for nomMC, Xpath in self.definition.filtreVariables:
+ if debug:
+ print(nomMC, Xpath)
+ if Xpath == None:
+ dicoValeurs[nomMC] = getattr(self, nomMC)
+ else:
+ try: # if 1 :
+ pereMC = eval(Xpath)
+ if debug:
+ print("pereMC :", pereMC)
+ if pereMC:
+ exp = Xpath + '.getChild("' + nomMC + '")'
+ leMotCle = eval(exp)
+ else:
+ leMotCle = None
+ if debug:
+ print("leMotCle", leMotCle)
+ if leMotCle:
+ if leMotCle.val:
+ dicoValeurs[nomMC] = leMotCle.val
+ elif leMotCle.definition.max != 1:
+ dicoValeurs[nomMC] = []
+ else:
+ dicoValeurs[nomMC] = None
+ if debug:
+ print("dicoValeurs", dicoValeurs)
+ else:
+ # PN PN est-ce sur ? sinon quoi None ou []
+ # je pense que les 2 valeurs doivent être renseignees si le filtre depend de 2 valeurs
+ return l
+ except:
+ return l
+
+ for k, v in self.parent.jdc.sdsDict.items():
+ if isinstance(v, classeAChercher):
+ if debug:
+ print("je traite", v)
+ if self.definition.filtreExpression:
+ if debug:
+ print("expression", self.definition.filtreExpression)
+ if debug:
+ print(
+ v.executeExpression(
+ self.definition.filtreExpression, dicoValeurs
+ )
+ )
+ try:
+ if v.executeExpression(
+ self.definition.filtreExpression, dicoValeurs
+ ):
+ l.append(v)
+ except:
+ print("il faut comprendre except pour", self.nom)
+ # print (self.nom)
+ # print (self.parent.nom)
+ # print (k,v)
+ else:
+ l.append(v)
+ return l
--- /dev/null
+## coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe OBJECT classe mère de tous les objets
+ servant à controler les valeurs par rapport aux définitions
+"""
+from builtins import object
+from Accas.processing.P_CR import CR
+
+
+class OBJECT(object):
+
+ """
+ Classe OBJECT : cette classe est virtuelle et sert de classe mère
+ aux classes de type ETAPE et MOCLES.
+ Elle ne peut etre instanciée.
+ Une sous classe doit obligatoirement implémenter les méthodes :
+
+ - __init__
+
+ """
+
+ def getEtape(self):
+ """
+ Retourne l'étape à laquelle appartient self
+ Un objet de la catégorie etape doit retourner self pour indiquer que
+ l'étape a été trouvée
+ XXX double emploi avec self.etape ???
+ """
+ if self.parent == None:
+ return None
+ return self.parent.getEtape()
+
+ def supprime(self):
+ """
+ Méthode qui supprime les références arrières suffisantes pour
+ que l'objet puisse etre correctement détruit par le
+ garbage collector
+ """
+ self.parent = None
+ self.etape = None
+ self.jdc = None
+ self.niveau = None
+
+ def getVal(self):
+ """
+ Retourne la valeur de l'objet. Cette méthode fournit
+ une valeur par defaut. Elle doit etre dérivée pour chaque
+ type d'objet
+ """
+ return self
+
+ def getJdcRoot(self):
+ """
+ Cette méthode doit retourner l'objet racine c'est à dire celui qui
+ n'a pas de parent
+ """
+ if self.parent:
+ return self.parent.getJdcRoot()
+ else:
+ return self
+
+ def getValeurEffective(self, val):
+ """
+ Retourne la valeur effective du mot-clé en fonction
+ de la valeur donnée. Defaut si val == None
+ """
+ if val is None and hasattr(self.definition, "defaut"):
+ return self.definition.defaut
+ else:
+ return val
+
+ def reparent(self, parent):
+ """
+ Cette methode sert a reinitialiser la parente de l'objet
+ """
+ self.parent = parent
+ self.jdc = parent.jdc
+
+ def isBLOC(self):
+ """
+ Indique si l'objet est un BLOC
+ surcharge dans MCBLOC
+ """
+ return 0
+
+ def longueurDsArbre(self):
+ if self.nom == "Consigne":
+ return 0
+ if self.nom == "blocConsigne":
+ return 0
+ return 1
+
+ def prepareInsertInDB(self, dictKey, dElementsRecursifs, dPrimaryKey):
+ # Comme c est recursif doit etre dans Objet
+ # derive pour MCSIMP et MCLIST
+ debug = 1
+ if debug:
+ print("prepareInsertInDB traitement de ", self.nom)
+ if self.nature in ("OPERATEUR", "PROCEDURE"):
+ texteColonnes = "INSERT INTO {} (".format(self.nom)
+ texteValeurs = " VALUES("
+ elif self.nom in dPrimaryKey:
+ texteColonnes = "INSERT INTO {} (".format(self.nom)
+ texteValeurs = " VALUES("
+ texteColonnes += dPrimaryKey[self.nom]
+ texteValeurs += dictKey[dPrimaryKey[self.nom]]
+ else:
+ texteColonnes = ""
+ texteValeurs = ""
+ texteAutresTables = ""
+ for mc in self.mcListe:
+ if debug:
+ print("prepareInsertInDB appel pour", mc.nom, dictKey)
+ if mc.nom in dElementsRecursifs:
+ print("Mot Clef Recursifs", mc.nom)
+ if mc.nature == "MCSIMP":
+ col, val = mc.prepareInsertInDB()
+ if mc.nom in dictKey:
+ dictKey[mc.nom] = val
+ texteValeurs += val + " ,"
+ texteColonnes += col + " ,"
+ else:
+ tc, tv, ta = mc.prepareInsertInDB(
+ dictKey, dElementsRecursifs, dPrimaryKey
+ )
+ texteValeurs += val + " ,"
+ texteColonnes += col + " ,"
+ texteAutresTables += ta
+
+ if self.nature in ("OPERATEUR", "PROCEDURE") or self.nom in dPrimaryKey:
+ texteColonnes = texteColonnes[0:-1] + ") "
+ texteValeurs = texteValeurs[0:-1] + ");\n"
+ return (texteColonnes, texteValeurs, texteAutresTables)
+
+
+class ErrorObj(OBJECT):
+
+ """Classe pour objets errones : emule le comportement d'un objet tel mcsimp ou mcfact"""
+
+ def __init__(self, definition, valeur, parent, nom="err"):
+ self.nom = nom
+ self.definition = definition
+ self.valeur = valeur
+ self.parent = parent
+ self.mcListe = []
+ if parent:
+ self.jdc = self.parent.jdc
+ # self.niveau = self.parent.niveau
+ # self.etape = self.parent.etape
+ else:
+ # Pas de parent
+ self.jdc = None
+ # self.niveau = None
+ # self.etape = None
+
+ def isValid(self, cr="non"):
+ return 0
+
+ def report(self):
+ """génère le rapport de Accas.validation de self"""
+ self.cr = CR()
+ self.cr.debut = "Mot-clé invalide : " + self.nom
+ self.cr.fin = "Fin Mot-clé invalide : " + self.nom
+ self.cr.fatal(
+ _("Type non autorisé pour le mot-clé %s : '%s'"), self.nom, self.valeur
+ )
+ return self.cr
+
+
+def newGetattr(self, name):
+ try:
+ fils = self.getChildOrChildInBloc(name, restreint="non")
+ if fils:
+ if fils.nature == "MCSIMP":
+ return fils.valeur
+ if fils.nature == "MCList":
+ if fils[0].definition.max == 1:
+ return fils[0]
+ return fils
+ except:
+ raise AttributeError(
+ "%r object has no attribute %r" % (self.__class__.__name__, name)
+ )
+ raise AttributeError(
+ "%r object has no attribute %r" % (self.__class__.__name__, name)
+ )
+
+
+def newGetattrForEtape(self, name):
+ try:
+ lesFils = self.getEtapesByName(name)
+ if lesFils != []:
+ return lesFils
+ except:
+ raise AttributeError(
+ "%r object has no attribute %r" % (self.__class__.__name__, name)
+ )
+ raise AttributeError(
+ "%r object has no attribute %r" % (self.__class__.__name__, name)
+ )
+
+
+def activeSurcharge():
+ from .P_MCCOMPO import MCCOMPO
+
+ MCCOMPO.__getattr__ = newGetattr
+ from .P_JDC import JDC
+
+ JDC.__getattr__ = newGetattrForEtape
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe de definition OPER
+ qui permet de spécifier les caractéristiques d'un opérateur
+"""
+
+
+import types
+import traceback
+
+from Accas.processing import P_ENTITE
+from Accas.processing import P_ETAPE
+from Accas.processing import nommage
+
+
+class OPER(P_ENTITE.ENTITE):
+
+ """
+ Classe pour definir un opérateur
+
+ Cette classe a trois attributs de classe
+
+ - class_instance qui indique la classe qui devra etre utilisée
+ pour créer l'objet qui servira à controler la conformité d'un
+ opérateur avec sa définition
+
+ - label qui indique la nature de l'objet de définition (ici, OPER)
+
+ - nommage qui est un module Python qui fournit la fonctionnalité de nommage
+
+ et les attributs d'instance suivants :
+
+ - nom : son nom
+
+ - op : le numéro d'opérateur
+
+ - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
+ une classe
+
+ - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
+ réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
+
+ - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
+ non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
+ de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
+
+ - fr : commentaire associé en francais
+
+ - docu : clé de documentation associée
+
+ - regles : liste des règles associées
+
+ - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
+ fonction est exécutée lors des phases d'initialisation de l'étape associée.
+
+ - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
+ rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
+ Si niveau vaut None, l'opérateur est rangé au niveau global.
+
+ - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
+ des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
+ est initialisé avec args, c'est à dire les arguments d'appel restants.
+
+
+ """
+
+ class_instance = P_ETAPE.ETAPE
+ label = "OPER"
+ nommage = nommage
+
+ def __init__(
+ self,
+ nom,
+ op=None,
+ sd_prod=None,
+ reentrant="n",
+ repetable="o",
+ fr="",
+ ang="",
+ fenetreIhm=None,
+ docu="",
+ regles=(),
+ op_init=None,
+ niveau=None,
+ UIinfo=None,
+ **args
+ ):
+ """
+ Méthode d'initialisation de l'objet OPER. Les arguments sont utilisés pour initialiser
+ les attributs de meme nom
+ """
+ self.nom = nom
+ self.op = op
+ self.sd_prod = sd_prod
+ self.reentrant = reentrant
+ self.fr = fr
+ self.ang = ang
+ self.repetable = repetable
+ self.docu = docu
+ self.fenetreIhm = fenetreIhm
+ if type(regles) == tuple:
+ self.regles = regles
+ else:
+ self.regles = (regles,)
+ # Attribut op_init : Fonction a appeler a la construction de l
+ # operateur sauf si == None
+ self.op_init = op_init
+ self.entites = args
+ current_cata = CONTEXT.getCurrentCata()
+ if niveau == None:
+ self.niveau = None
+ current_cata.enregistre(self)
+ else:
+ self.niveau = current_cata.getNiveau(niveau)
+ self.niveau.enregistre(self)
+ self.UIinfo = UIinfo
+ self.affecter_parente()
+ self.checkDefinition(self.nom)
+ self.txtNomComplet = ""
+ self.dejaPrepareDump = False
+
+ def __call__(self, reuse=None, nomXML=None, **args):
+ """
+ Construit l'objet ETAPE a partir de sa definition (self),
+ puis demande la construction de ses sous-objets et du concept produit.
+ """
+ if nomXML == None:
+ nomsd = self.nommage.getNomConceptResultat(self.nom)
+ else:
+ nomsd = nomXML
+ etape = self.class_instance(oper=self, reuse=reuse, args=args)
+ etape.MCBuild()
+ while etape.doitEtreRecalculee == True:
+ etape.doitEtreRecalculee = False
+ etape.deepUpdateConditionBlocApresCreation()
+ etape.reConstruitResteVal()
+ etape.state = "modified"
+ # print ('on recalcule la validite depuis P_OPER')
+ # etape.isValid(cr='oui')
+ etape.metAJourNomASSD(nomsd)
+ return etape.buildSd(nomsd)
+
+ def make_objet(self, mc_list="oui"):
+ """
+ Cette méthode crée l'objet ETAPE dont la définition est self sans
+ l'enregistrer ni créer sa sdprod.
+ Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
+ des objets MCxxx.
+ """
+ etape = self.class_instance(oper=self, reuse=None, args={})
+ if mc_list == "oui":
+ etape.MCBuild()
+ return etape
+
+ def verifCata(self):
+ """
+ Méthode de vérification des attributs de définition
+ """
+ self.checkRegles()
+ self.checkFr()
+ self.checkReentrant()
+ self.checkDocu()
+ self.checkNom()
+ self.checkOp(valmin=0)
+ self.verifCataRegles()
+
+ def supprime(self):
+ """
+ Méthode pour supprimer les références arrières susceptibles de provoquer
+ des cycles de références
+ """
+ self.niveau = None
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+from builtins import object
+from .P_utils import importObject
+
+
+class OPS(object):
+
+ """Wrapper to ops functions.
+ This allows to import them only when they are needed."""
+
+ def __init__(self, uri):
+ """Initialization"""
+ self.uri = uri
+
+ def __call__(self, *args, **kwargs):
+ """Import the real function and call it."""
+ func = importObject(self.uri)
+ return func(*args, **kwargs)
+
+
+# Obsolete mais garde a titre d exemple
+# utilisé par exemple par des macros où tout est fait dans l'init.
+class NOTHING(OPS):
+
+ """OPS which does nothing."""
+
+ def __call__(self, macro, *args, **kwargs):
+ macro.set_icmd(1)
+ return 0
+
+
+EMPTY_OPS = NOTHING(None)
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe de definition PROC
+ qui permet de spécifier les caractéristiques d'une procédure
+"""
+
+
+import types
+import traceback
+
+from Accas.processing import P_ENTITE
+from Accas.processing import P_PROC_ETAPE
+
+
+class PROC(P_ENTITE.ENTITE):
+
+ """
+ Classe pour definir un opérateur
+
+ Cette classe a deux attributs de classe
+
+ - class_instance qui indique la classe qui devra etre utilisée
+ pour créer l'objet qui servira à controler la conformité d'un
+ opérateur avec sa définition
+
+ - label qui indique la nature de l'objet de définition (ici, PROC)
+
+
+ et les attributs d'instance suivants :
+
+ - nom : son nom
+
+ - op : le numéro d'opérateur
+
+ - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
+ réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
+
+ - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
+ non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
+ de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
+
+ - fr : commentaire associé en francais
+
+ - docu : clé de documentation associée
+
+ - regles : liste des règles associées
+
+ - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
+ fonction est exécutée lors des phases d'initialisation de l'étape associée.
+
+ - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
+ rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
+ Si niveau vaut None, l'opérateur est rangé au niveau global.
+
+ - fenetreIhm : specification de la fenetre
+
+ - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
+ des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
+ est initialisé avec args, c'est à dire les arguments d'appel restants.
+
+
+ """
+
+ class_instance = P_PROC_ETAPE.PROC_ETAPE
+ label = "PROC"
+
+ def __init__(
+ self,
+ nom,
+ op=None,
+ reentrant="n",
+ repetable="o",
+ fr="",
+ ang="",
+ fenetreIhm=None,
+ docu="",
+ regles=(),
+ op_init=None,
+ niveau=None,
+ UIinfo=None,
+ **args
+ ):
+ """
+ Méthode d'initialisation de l'objet PROC. Les arguments sont utilisés pour initialiser
+ les attributs de meme nom
+ """
+ self.nom = nom
+ self.op = op
+ self.reentrant = reentrant
+ self.repetable = repetable
+ self.fenetreIhm = fenetreIhm
+ self.fr = fr
+ # self.ang=""
+ self.ang = ang
+ self.docu = docu
+ if type(regles) == tuple:
+ self.regles = regles
+ else:
+ self.regles = (regles,)
+ # Attribut op_init : Fonction a appeler a la construction de l
+ # operateur sauf si == None
+ self.op_init = op_init
+ self.entites = args
+ current_cata = CONTEXT.getCurrentCata()
+ if niveau == None:
+ self.niveau = None
+ current_cata.enregistre(self)
+ else:
+ self.niveau = current_cata.getNiveau(niveau)
+ self.niveau.enregistre(self)
+ self.UIinfo = UIinfo
+ self.affecter_parente()
+ self.checkDefinition(self.nom)
+ self.dejaPrepareDump = False
+ self.txtNomComplet = ""
+
+ def __call__(self, **args):
+ """
+ Construit l'objet PROC_ETAPE a partir de sa definition (self),
+ puis demande la construction de ses sous-objets et du concept produit.
+ """
+ etape = self.class_instance(oper=self, args=args)
+ etape.MCBuild()
+ while etape.doitEtreRecalculee == True:
+ etape.doitEtreRecalculee = False
+ etape.deepUpdateConditionBlocApresCreation()
+ etape.reConstruitResteVal()
+ return etape.buildSd()
+
+ def make_objet(self, mc_list="oui"):
+ """
+ Cette méthode crée l'objet PROC_ETAPE dont la définition est self sans
+ l'enregistrer ni créer sa sdprod.
+ Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
+ des objets MCxxx.
+ """
+ etape = self.class_instance(oper=self, args={})
+ if mc_list == "oui":
+ etape.MCBuild()
+ return etape
+
+ def verifCata(self):
+ """
+ Méthode de vérification des attributs de définition
+ """
+ self.checkRegles()
+ self.checkFr()
+ self.checkReentrant()
+ self.checkDocu()
+ self.checkNom()
+ self.checkOp(valmin=0)
+ self.verifCataRegles()
+
+ def supprime(self):
+ """
+ Méthode pour supprimer les références arrières susceptibles de provoquer
+ des cycles de références
+ """
+ self.niveau = None
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe PROC_ETAPE qui sert à vérifier et à exécuter
+ une procédure
+"""
+
+# Modules Python
+
+import types
+import sys
+import traceback
+
+# Modules EFICAS
+from Accas.processing import P_MCCOMPO
+from Accas.processing import P_ETAPE
+from Accas.processing.P_Exception import AsException
+from Accas.processing import P_utils
+
+
+class PROC_ETAPE(P_ETAPE.ETAPE):
+
+ """
+ Cette classe hérite de ETAPE. La seule différence porte sur le fait
+ qu'une procédure n'a pas de concept produit
+
+ """
+
+ nature = "PROCEDURE"
+
+ def __init__(self, oper=None, reuse=None, args={}):
+ """
+ Attributs :
+ - definition : objet portant les attributs de définition d'une étape de type opérateur. Il
+ est initialisé par l'argument oper.
+ - valeur : arguments d'entrée de type mot-clé=valeur. Initialisé avec l'argument args.
+ - reuse : forcément None pour une PROC
+ """
+ P_ETAPE.ETAPE.__init__(self, oper, reuse=None, args=args, niveau=5)
+ self.reuse = None
+
+ def buildSd(self):
+ """
+ Cette methode applique la fonction op_init au contexte du parent
+ et lance l'exécution en cas de traitement commande par commande
+ Elle doit retourner le concept produit qui pour une PROC est toujours None
+ En cas d'erreur, elle leve une exception : AsException ou EOFError
+ """
+ if not self.isActif():
+ return
+ try:
+ if self.parent:
+ if type(self.definition.op_init) == types.FunctionType:
+ self.definition.op_init(*(self, self.parent.g_context))
+ else:
+ pass
+ except AsException as e:
+ raise AsException(
+ "Etape ",
+ self.nom,
+ "ligne : ",
+ self.appel[0],
+ "fichier : ",
+ self.appel[1],
+ e,
+ )
+ except EOFError:
+ raise
+ except:
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ raise AsException(
+ "Etape ",
+ self.nom,
+ "ligne : ",
+ self.appel[0],
+ "fichier : ",
+ self.appel[1] + "\n",
+ "".join(l),
+ )
+
+ self.Execute()
+ return None
+
+ def supprime(self):
+ """
+ Méthode qui supprime toutes les références arrières afin que l'objet puisse
+ etre correctement détruit par le garbage collector
+ """
+ P_MCCOMPO.MCCOMPO.supprime(self)
+ self.jdc = None
+ self.appel = None
+
+ def accept(self, visitor):
+ """
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
+ """
+ visitor.visitPROC_ETAPE(self)
+
+ def updateContext(self, d):
+ """
+ Met à jour le contexte de l'appelant passé en argument (d)
+ Une PROC_ETAPE n ajoute pas directement de concept dans le contexte
+ Seule une fonction enregistree dans op_init pourrait le faire
+ """
+ if type(self.definition.op_init) == types.FunctionType:
+ self.definition.op_init(*(self, d))
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient la classe mere pour les classes de definition des regles d exclusion.
+
+ La classe REGLE est la classe de base : elle est virtuelle, elle ne doit pas etre instanciee.
+
+ Les classes regles dérivées qui seront instanciées doivent implementer la methode verif
+ dont l argument est le dictionnaire des mots cles effectivement presents
+ sur lesquels sera operee la verification de la regle
+
+ A la creation de l'objet regle on lui passe la liste des noms de mots cles concernes
+
+ Exemple ::
+
+ # Création de l'objet règle UNPARMI
+ r=UNPARMI("INFO","AFFE")
+ # Vérification de la règle r sur le dictionnaire passé en argument
+ r.verif({"INFO":v1,"AFFE":v2)
+"""
+
+import types
+
+
+class REGLE(object):
+ def __init__(self, *args):
+ """
+ Les classes dérivées peuvent utiliser cet initialiseur par défaut ou
+ le surcharger
+ """
+ self.mcs = args
+
+ def verif(self, args):
+ """
+ Les classes dérivées doivent implémenter cette méthode
+ qui doit retourner une paire dont le premier élément est une chaine de caractère
+ et le deuxième un entier.
+
+ L'entier peut valoir 0 ou 1. -- s'il vaut 1, la règle est vérifiée
+ s'il vaut 0, la règle n'est pas vérifiée et le texte joint contient
+ un commentaire de la non validité.
+ """
+ raise NotImplementedError("class REGLE should be derived")
+
+ def listeToDico(self, args):
+ """
+ Cette méthode est utilitaire pour les seuls besoins
+ des classes dérivées.
+
+ Elle transforme une liste de noms de mots clés en un
+ dictionnaire équivalent dont les clés sont les noms des mts-clés
+
+ Ceci permet d'avoir un traitement identique pour les listes et les dictionnaires
+ """
+ if type(args) == dict:
+ return args
+ elif type(args) == list:
+ dico = {}
+ for arg in args:
+ dico[arg] = 0
+ return dico
+ else:
+ raise Exception("Erreur ce n'est ni un dictionnaire ni une liste %s" % args)
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+"""
+ Ce module contient les règles nécessaires aux commandes sensibles
+ pour renseigner l'attribut etape.sd.sensi, gérer le caractère réentrant
+ sur présence de la sensibilité.
+"""
+
+
+from Accas.processing.P_REGLE import REGLE
+
+
+# -----------------------------------------------------------------------------
+class CONCEPT_SENSIBLE(REGLE):
+ """
+ Obsolete. unquement pour Aster
+ Règle permettant de renseigner au niveau du catalogue comment sera
+ rempli le concept (valeur nominale ou dérivée(s) ou les deux...).
+ """
+
+ def __init__(self, mode, mocle="SENSIBILITE"):
+ """Constructeur.
+
+ mode : manière dont la commande rempli le concept
+ - 'ENSEMBLE' : concept nominal ET dérivées en une seule passe
+ - 'SEPARE' : concept nominal OU dérivée (une ou plusieurs)
+
+ mocle : mot-clé contenant les paramètres sensibles.
+ """
+ REGLE.__init__(self)
+ self.mocle = mocle
+ self._modes = {"ENSEMBLE": 0, "SEPARE": 1}
+ self.mode = self._modes.get(mode, self._modes["ENSEMBLE"])
+
+ def getText(self):
+ """Pour EFICAS"""
+ return ""
+
+ def verif(self, args):
+ """Retourne texte + 1 si ok, 0 si nook.
+ On stocke dans sd.sensi l'étape courante, c'est-à-dire celle qui
+ renseigne le concept si cela n'a pas déjà été fait (car verif est
+ appelé à chaque Accas.validation).
+ """
+ obj = args["self"]
+ etape = obj.etape
+ id_etape = "%s_%s" % (etape.id, id(etape))
+ if etape.sd == None:
+ return "", 1
+ if not hasattr(etape.sd, "sensi"):
+ etape.sd.sensi = {}
+ # si ENSEMBLE, la sd nominale est forcément produite
+ if self.mode == self._modes["ENSEMBLE"] and not "nominal" in etape.sd.sensi:
+ etape.sd.sensi["nominal"] = id_etape
+ # liste des paramètres sensibles
+ valeur = obj[self.mocle]
+ if valeur == None:
+ # pas de sensibilité, la sd nominale est produite
+ if not "nominal" in etape.sd.sensi:
+ etape.sd.sensi["nominal"] = id_etape
+ return "", 1
+ if not type(valeur) in (list, tuple):
+ valeur = [
+ valeur,
+ ]
+ for v in valeur:
+ if not v.getName() in etape.sd.sensi:
+ etape.sd.sensi[v.getName()] = id_etape
+ return "", 1
+
+
+# -----------------------------------------------------------------------------
+class REUSE_SENSIBLE(REGLE):
+ """
+ Obsolete : Uniquement pour Aster
+ Limite le caractère réentrant de la commande.
+ On autorisera reuse seulement si le concept (au sens fortran) n'a pas déjà
+ été calculé (d'après sd.sensi). Ce sera interdit dans les cas suivants :
+ - sd nominale calculée et SENSIBILITE absent
+ - PS1 dans SENSIBILITE et sd dérivée par rapport à PS1 calculée
+ """
+
+ def __init__(self, mocle="SENSIBILITE"):
+ """Constructeur.
+ mocle : mot-clé SENSIBILITE.
+ """
+ REGLE.__init__(self)
+ self.mocle = mocle
+
+ def getText(self):
+ """Pour EFICAS"""
+ return ""
+
+ def verif(self, args):
+ """Retourne texte + 1 si ok, 0 si nook = reuse interdit.
+ Comme CONCEPT_SENSIBLE est appelé avant (et à chaque Accas.validation),
+ on regarde si sd.sensi[ps] a été renseigné par une étape précédente.
+ """
+ obj = args["self"]
+ etape = obj.etape
+ id_etape = "%s_%s" % (etape.id, id(etape))
+ sd = etape.sd
+ # si la commande n'est pas réentrante, rien à faire
+ if etape.reuse is not None:
+ valeur = obj[self.mocle]
+ if valeur is None:
+ if (
+ not hasattr(sd, "sensi")
+ or sd.sensi.get("nominal", id_etape) != id_etape
+ ):
+ # pas de sensibilite et concept nominal déjà calculé : reuse interdit
+ text = "Commande non réentrante en l'absence de sensibilité."
+ return text, 0
+ else:
+ if not type(valeur) in (list, tuple):
+ valeur = [
+ valeur,
+ ]
+ for ps in valeur:
+ if (
+ hasattr(sd, "sensi")
+ and sd.sensi.get(ps.nom, id_etape) != id_etape
+ ):
+ # concept dérivé par rapport à ps déjà calculé : reuse interdit
+ text = (
+ "Commande non réentrante : dérivée par rapport à %s déjà calculée"
+ % ps.nom
+ )
+ return text, 0
+ return "", 1
+
+
+# -----------------------------------------------------------------------------
+class DERIVABLE(REGLE):
+ """Déclare que le concept fourni derrière un mot-clé est dérivable.
+ Sa présence ne suffit pas à le valider, il faut encore que son attribut
+ '.sensi' soit cohérent avec le contenu du mot-clé SENSIBILITE (ou l'absence
+ de celui-ci).
+ """
+
+ def __init__(self, mocle):
+ """Constructeur.
+ mocle : mot-clé dérivable.
+ """
+ REGLE.__init__(self)
+ self.mocle = mocle
+
+ def getText(self):
+ """Pour EFICAS"""
+ return ""
+
+ def verif(self, args):
+ """ """
+ obj = args["self"]
+ try:
+ concept = obj[self.mocle]
+ except IndexError:
+ return "", 1
+ if not type(concept) in (list, tuple):
+ concept = [
+ concept,
+ ]
+ l_ps = obj["SENSIBILITE"]
+ for co in concept:
+ if co is None:
+ text = "Concept non défini (None) sous le mot-clé %s" % self.mocle
+ return text, 0
+ if not l_ps:
+ # pas de sensibilité
+ if hasattr(co, "sensi") and not co.sensi.get("nominal"):
+ text = (
+ "%s ne contient que des valeurs dérivées, utilisez le mot cle SENSIBILITE"
+ % co.nom
+ )
+ return text, 0
+ else:
+ # sensibilité spécifiée
+ if not type(l_ps) in (list, tuple):
+ l_ps = [
+ l_ps,
+ ]
+ for ps in l_ps:
+ if not hasattr(co, "sensi") or not co.sensi.get(ps.nom):
+ text = (
+ "La dérivée de %s par rapport à %s n'est pas disponible."
+ % (co.nom, ps.nom)
+ )
+ return text, 0
+ return "", 1
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+""" Ce module contient la classe de definition SIMP
+ qui permet de spécifier les caractéristiques des mots clés simples
+"""
+
+
+import types
+
+import Accas
+from Accas.processing import P_ENTITE
+from Accas.processing import P_MCSIMP
+
+dictPourSql = {
+ "I": "BIGINT",
+ "R": "FLOAT8",
+ "BOOL": "BOOL",
+ "TXM": "TEXT",
+ "date": "DATE",
+}
+
+
+class SIMP(P_ENTITE.ENTITE):
+
+ """
+ Classe pour definir un mot cle simple
+
+ Cette classe a deux attributs de classe
+
+ - class_instance qui indique la classe qui devra etre utilisée
+ pour créer l'objet qui servira à controler la conformité d'un
+ mot-clé simple avec sa définition
+
+ - label qui indique la nature de l'objet de définition (ici, SIMP)
+
+ """
+
+ class_instance = P_MCSIMP.MCSIMP
+ label = "SIMP"
+
+ def __init__( self, typ, ang="", fr="", statut="f", into=None, intoSug=None, siValide=None,
+ defaut=None, min=1, max=1, homo=1, position="local", filtre=None, val_min=float("-inf"),
+ val_max=float("inf"), docu="", validators=None, nomXML=None, sug=None, fenetreIhm=None,
+ attribut=False, sortie="n", intoXML=None, metAJour=None, avecBlancs=False, unite=None,
+ typeXSD=None, formatGit=None, affichage=None,):
+ """
+ Un mot-clé simple est caractérisé par les attributs suivants :
+ - type : cet attribut est obligatoire et indique le type de valeur attendue
+ - fr : chaîne documentaire en français
+ - statut : obligatoire ou facultatif ou caché ou cache avec defaut (d)
+ - into : valeurs autorisées
+ - intoSug : valeurs possibles mais des valeurs autres du bon type peuvent etre entrees par l utilsateur
+ - defaut : valeur par défaut
+ - min : nombre minimal de valeurs
+ - max : nombre maximal de valeurs
+ - homo : un certatin nb de choses qui il faut redispacher ailleurs (information, constant)
+ - ang : doc
+ - position : si global, le mot-clé peut-être lu n'importe où dans la commande
+ - val_min : valeur minimale autorisée
+ - val_max : valeur maximale autorisée
+ - docu : clef sur de la documentation utilisateur
+ - sug : valeur suggere
+ - fenetreIhm : si widget particulier
+ - attribut : si projection XSD sur attribut
+ - creeDesObjetsDeType : type des UserASSD si siValide en cree
+ - nomXML : se projette en XSD avec un autre nom pour accepter les tirets
+ - sortie : force l ecriture dans le fichier de sortie (utile pour Telemac)
+ - affichage : Tuple contenant un nom de gridLayout, puis ligne et colonne pour l affichage
+ """
+ # print (self)
+ # import traceback
+ # traceback.print_stack()
+ # print (self)
+ P_ENTITE.ENTITE.__init__(self, validators)
+ # Initialisation des attributs
+ self.creeDesObjets = False
+ self.utiliseUneReference = False
+ self.creeDesObjetsDeType = None
+ self.utiliseDesObjetsDeType = None
+ if type(typ) == tuple:
+ self.type = typ
+ else:
+ self.type = (typ,)
+ for t in self.type:
+ try:
+ if issubclass(t, Accas.UserASSDMultiple):
+ creeDesObjetsDeType = t
+ self.utiliseUneReference = True
+ elif issubclass(t, Accas.UserASSD):
+ creeDesObjetsDeType = t
+ self.utiliseUneReference = True
+ except:
+ pass
+ if t == "createObject":
+ self.creeDesObjets = True
+ if self.utiliseUneReference:
+ if self.creeDesObjets:
+ self.utiliseUneReference = False
+ self.creeDesObjetsDeType = creeDesObjetsDeType
+ else:
+ self.utiliseDesObjetsDeType = creeDesObjetsDeType
+ self.fr = fr
+ self.statut = statut
+ self.into = into
+ self.intoSug = intoSug
+ self.siValide = siValide
+ self.defaut = defaut
+ self.min = min
+ self.max = max
+ self.homo = homo
+ self.position = position
+ self.val_min = val_min
+ self.val_max = val_max
+ self.docu = docu
+ self.sug = sug
+ self.ang = ang
+ if self.max == "**":
+ self.max = float("inf")
+ if self.val_max == "**":
+ self.val_max = float("inf")
+ if self.min == "**":
+ self.min = float("-inf")
+ if self.val_min == "**":
+ self.val_min = float("-inf")
+ self.fenetreIhm = fenetreIhm
+ self.attribut = attribut
+ self.nomXML = nomXML
+ self.intoXML = intoXML
+ self.sortie = sortie
+ self.filtre = filtre
+ self.avecBlancs = avecBlancs
+ self.unite = unite
+ self.formatGit = formatGit
+ self.affichage = affichage
+ if typeXSD:
+ self.typeXSD = typeXSD
+ if (
+ not (self.avecBlancs)
+ and self.max > 1
+ and "TXM" in self.type
+ and self.into != None
+ ):
+ for val in self.into:
+ if val.find(" ") > -1:
+ self.avecBlancs = True
+ break
+ if (
+ not (self.avecBlancs)
+ and self.max > 1
+ and "TXM" in self.type
+ and self.intoXML != None
+ ):
+ for val in self.intoXML:
+ if val.find(" ") > -1:
+ self.avecBlancs = True
+ break
+ if self.avecBlancs and not ("TXM" in self.type):
+ print("definition incoherente avecBlanc et non texte pour ", self)
+ exit()
+ if self.filtre:
+ self.filtreExpression = self.filtre[0]
+ self.filtreVariables = self.filtre[1]
+ else:
+ self.filtreExpression = []
+ self.filtreVariables = []
+ self.metAJour = metAJour
+
+ def changeInto(self, listeDesIntos):
+ self.into = listeDesIntos
+
+ def changeIntoSelonValeurs(self, mcRecepteur):
+ mcRecepteur.changeInto(self.valeurs)
+
+ def addInto(self, nvlInto):
+ if self.into == None:
+ self.into = []
+ if nvlInto in self.into:
+ return
+ self.into.append(nvlInto)
+
+ def changeStatut(self, nvlStatut):
+ self.statut = nvlStatut
+
+ def changeSiValide(self, nvlFonction):
+ self.siValide = nvlFonction
+
+ def verifCata(self):
+ """
+ Cette methode sert à valider les attributs de l'objet de définition
+ de la classe SIMP
+ """
+ self.checkMinMax()
+ self.checkFr()
+ self.checkStatut()
+ self.checkHomo()
+ self.checkInto()
+ self.checkPosition()
+ self.checkValidators()
+
+ def dumpStringDataBase(self, inBloc):
+ if self.type[0] in dictPourSql:
+ leTypeSql = dictPourSql[self.type[0]]
+ else:
+ leTypeSql = "texte"
+ # est-ce toujours vrai ? est ce que cela ne depend pas un peu des tables
+ if self.statut == "o" and not inBloc:
+ contraintes = "NOT NULL"
+ else:
+ contraintes = ""
+ texte = "\t{} {} {} ,\n".format(self.nom, leTypeSql, contraintes)
+ return texte
+
+ def __call__(self, val, nom, parent=None, objPyxbDeConstruction=None):
+ """
+ Construit un objet mot cle simple (MCSIMP) a partir de sa definition (self)
+ de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
+ """
+ return self.class_instance(
+ nom=nom,
+ definition=self,
+ val=val,
+ parent=parent,
+ objPyxbDeConstruction=objPyxbDeConstruction,
+ )
--- /dev/null
+import types
+import Accas
+import inspect
+
+
+class P_Tuple:
+ def __init__(self, ntuple):
+ self.ntuple = ntuple
+
+ def __convert__(self, valeur):
+ try:
+ if isinstance(valeur, basestring):
+ return None
+ except NameError:
+ if isinstance(valeur, str):
+ return None
+ if len(valeur) != self.ntuple:
+ return None
+ return valeur
+
+ def info(self):
+ return "Tuple de %s elements" % self.ntuple
+
+
+class P_Matrice:
+ def __init__( self, nbLigs=None, nbCols=None, methodeCalculTaille=None, formatSortie="ligne",
+ valSup=None, valMin=None, structure=None, typElt="R", typEltInto=None,
+ listeHeaders=None, coloree=False, defaut=None,):
+ self.nbLigs = nbLigs
+ self.nbCols = nbCols
+ self.methodeCalculTaille = methodeCalculTaille
+ self.formatSortie = formatSortie
+ self.valSup = valSup
+ self.valMin = valMin
+ self.structure = structure
+ self.typElt = typElt
+ self.listeHeaders = listeHeaders
+ self.typEltInto = typEltInto
+ self.jdc = None
+ self.coloree = coloree
+ self.defaut = defaut
+ if self.coloree:
+ self.activeCouleur()
+
+ def __convert__(self, valeur):
+ # Attention ne verifie pas grand chose
+ if not isinstance(valeur, types.ListType):
+ return None
+ return valeur
+
+ def verifItem(self, texte, mc):
+ val = ""
+ if self.typElt == "R":
+ try:
+ val = float(str(texte))
+ ok = True
+ except:
+ return (False, "Entrer un float SVP")
+ if self.typElt == "I":
+ try:
+ val = int(str(texte))
+ ok = True
+ except:
+ return (False, "Entrer un float SVP")
+ if self.typElt in ("R", "I") and self.valSup != None:
+ if val > self.valSup:
+ return (False, "Entrer un nombre inferieur a " + repr(self.valSup))
+ if self.typElt in ("R", "I") and self.valMin != None:
+ if val < self.valMin:
+ return (False, "Entrer un nombre superieur a " + repr(self.valMin))
+ if val == "":
+ val = texte
+ if self.typEltInto != None and val not in self.typEltInto:
+ return "Entrer une valeur contenue dans " + str(self.typEltInto)
+ try:
+ if issubclass(self.typElt, Accas.ASSD):
+ if not self.jdc:
+ self.jdc = CONTEXT.getCurrentJdC()
+ if not (val in self.jdc.sdsDict.keys()):
+ return (False, "Concept inexistant")
+ if not (isinstance(self.jdc.sdsDict[val], self.typElt)):
+ return (False, "Concept d un autre type")
+ a = self.jdc.getSdAvantDuBonType(mc.etape, (self.typElt,))
+ if texte not in self.jdc.getSdAvantDuBonType(mc.etape, (self.typElt,)):
+ return (False, "Le concept doit etre defini avant")
+ except:
+ pass
+ return (True, "")
+
+ def convertItem(self, texte):
+ if self.typElt == "R":
+ val = float(str(texte))
+ if self.typElt == "I":
+ val = int(str(texte))
+ try:
+ if issubclass(self.typElt, Accas.ASSD):
+ return self.jdc.sdsDict[texte]
+ except:
+ pass
+
+ def info(self):
+ return "Matrice %s x %s" % (self.nbLigs, self.nbCols)
+
+ __repr__ = info
+ __str__ = info
+
+
+class P_Matrice_Correlation(P_Matrice):
+ pass
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+"""
+
+"""
+
+import traceback
+import sys
+
+from Accas.processing.P_ASSD import ASSD
+from Accas.accessor import CONNECTOR
+
+
+class UserASSD(ASSD):
+ """
+ Classe de base pour definir des types de structures de donnees definie par
+ l utilisateur
+ equivalent d un concept ASSD pour un SIMP ou un FACT
+ Attention : le parent est a None au debut et non le MC createur que l on ne connait pas
+ Lorsqu on ecrit le jdc, n ecrit nom=UserASSD()
+ le parent est le SIMP qui cree l objet
+ a la lecture si la classe commence par un majuscule on fait le boulot dans MCSIMP, sinon dans
+ l init de parametre car le parsing considere qu on a un parametre
+ """
+
+ def __init__(self, nom="sansNom"):
+ # print ('dans init de UserASSD pour ', nom, type(nom))
+ self.nom = nom
+ self.jdc = CONTEXT.getCurrentJdC()
+ self.parent = None
+ self.initialiseValeur()
+ self.utilisePar = set()
+ if self.nom != "sansNom":
+ self.id = self.jdc.regSD(self)
+ if self.nom != "sansNom":
+ self.initialiseNom(nom)
+ else:
+ self.id = None
+ self.ptr_sdj = None
+
+ def initialiseParent(self, parent):
+ # attention parent.parent peut être un bloc
+ # print ('je passe initialiseParent pour : ', self, parent.nom)
+ self.parent = parent
+ self.etape = self.parent.getEtape()
+ self.etape.userASSDCrees.append(self)
+ if self.parent.parent != self.etape:
+ if self.parent.parent.estIdentifiePar != None:
+ print(
+ "il y a un souci dans l initialisation de l identifiant pour",
+ self.parent.parent.nom,
+ )
+ print(self.parent.nom)
+ print(self.nom)
+ self.parent.parent.estIdentifiePar = self
+
+ def initialiseNom(self, nom):
+ # print ('je passe initialiseNom pour : ', self, nom, type(nom))
+ for i, j in list(self.jdc.sdsDict.items()):
+ if j == self:
+ del self.jdc.sdsDict[i]
+ self.jdc.sdsDict[nom] = self
+ self.nom = nom
+ if self.nom != "sansNom" and self.id == None:
+ self.id = self.jdc.regSD(self)
+
+ def initialiseValeur(self, valeur=None):
+ self.valeur = valeur
+
+ def ajoutUtilisePar(self, mc):
+ # print ('je passe ajoutUtilisePar pour : ', self.nom)
+ self.utilisePar.add(mc)
+
+ def enleveUtilisePar(self, mc):
+ try:
+ self.utilisePar.remove(mc)
+ except:
+ pass
+
+ def renomme(self, nouveauNom):
+ print("je passe dans renomme")
+ self.jdc.delConcept(self.nom)
+ self.jdc.sdsDict[nouveauNom] = self
+ self.setName(nouveauNom)
+ # print ('je suis dans renomme',nouveauNom, self.nom)
+ # print (self.utilisePar)
+ for mc in self.utilisePar:
+ mc.demandeRedessine()
+
+ def transfere(self, obj):
+ # uniquement utise pour les lectures XML
+ self.utilisePar = obj.utilisePar
+ self.id = obj.id
+ for mc in self.utilisePar:
+ mc.valeur = self
+
+ def deleteReference(self, mcCreateur=None):
+ print("je passe dans supprime de P_UserASSDMultiple")
+ # meme signature que UserASSDMultiple
+ for MC in self.utilisePar:
+ # le delete est appele en cascade par toute la hierachie
+ # du mcsimp (au cas ou on detruise le fact ou le proc)
+ # du coup pas beau
+ try:
+ if type(MC.valeur) in (list, tuple):
+ MC.valeur = list(MC.valeur)
+ while self in MC.valeur:
+ MC.valeur.remove(self)
+ if MC.valeur == []:
+ MC.Valeur = None
+ else:
+ MC.valeur = None
+ MC.state = "changed"
+ MC.isValid()
+ CONNECTOR.Emit(MC, "valid")
+ except:
+ pass
+ # on peut avoir des listes qui contiennent plusieurs fois la meme valeur
+ self.jdc.delConcept(self.nom)
+
+ def executeExpression(self, condition, dico):
+ # if self.nom == 'shape1' : print ('je suis dans executeExpression ', self.nom, ' ', condition)
+ dict = locals()
+ dict.update(dico)
+ # if self.nom == 'shape1' or self.nom == 'G1' : print (dict)
+ # if self.nom == 'shape1' :
+ # print (self.getParentsWithId().getListeUserASSD("systemGeometryId"))
+ # print (self.getParentsWithId().getListeUserASSD("SystemGeometryId"))
+ # test = eval(condition, globals(), dict)
+ # print ('-------------------------------------------------------------------------')
+ try:
+ test = eval(condition, globals(), dict)
+ except:
+ print("executeExpression ", self.nom, " ", condition, "exception")
+ test = 0
+ return test
+
+ def getEficasAttribut(self, attribut):
+ # print ('je suis dans getEficasAttr', attribut)
+ if self.parent == None:
+ return None
+ # print ('apres if')
+ # parent est le SIMP donc c est bien parent.parent
+ try:
+ valeur = self.parent.parent.getMocle(attribut)
+ except:
+ valeur = None
+ # print (valeur)
+ return valeur
+
+ def supprime(self, mcCreateur=None):
+ # mcCreateur utile pour P_UserASSDMultiple
+ print("je passe dans supprime de P_UserASSDMultiple")
+ self.deleteReference(mcCreateur)
+
+ def __repr__(self):
+ return "concept " + self.getName() + " type " + self.__class__.__name__
+
+ def __str__(self):
+ return self.getName() or "<None>"
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+"""
+"""
+
+import traceback
+import sys
+
+from Accas.processing.P_UserASSD import UserASSD
+from Accas.processing.P_ASSD import ASSD
+
+from collections import UserList
+
+
+class UserASSDMultiple(UserASSD):
+ """
+ Classe de base pour definir des types de structures de donnees definie par
+ l utilisateur
+ equivalent d un concept ASSD pour un SIMP ou un FACT
+ mais pouvant referencer 2 objets par exemple les groupes de mailles qui peuvent porter
+ le meme nom dans 2 maillages differents
+ """
+
+ def __init__(self, nom="sansNom"):
+ # print ('dans init de UserASSDMultiple ',nom)
+ UserASSD.__init__(self, nom)
+ self.peres = []
+
+ def ajouteUnPere(self, pere):
+ # print ('dans ajouteUnPere', self.peres, self.nom, pere)
+ if pere not in self.peres:
+ self.peres.append(pere)
+ etape = pere.getEtape()
+ if self not in etape.userASSDCrees:
+ etape.userASSDCrees.append(self)
+
+ def renomme(self, nouveauNom):
+ print("je passe dans renomme")
+ # import traceback
+ # traceback.print_stack()
+ self.jdc.delConcept(self.nom)
+ self.jdc.sdsDict[nouveauNom] = self
+ self.setName(nouveauNom)
+ for mc in self.utilisePar:
+ mc.demandeRedessine()
+
+ def initialiseParent(self, pere):
+ # surcharge P_UserASSD parent ici n a pas de sens
+ pass
+
+ def deleteReference(self, mcCreateur):
+ print("je passe dans deleteReference", mcCreateur.nom)
+ if not (mcCreateur in self.peres):
+ return
+ self.peres.pop(self.peres.index(mcCreateur))
+ if len(self.peres) == 0:
+ UserASSD.deleteReference(self)
+
+ def getParentsWithId(self):
+ # print ('je suis dans getParentsWithId ')
+ listeRetour = listUserASSD()
+ for pere in self.peres:
+ pereWithId = pere.parent
+ monEtape = pere.getEtape()
+ while pereWithId:
+ if pereWithId == monEtape:
+ listeRetour.append(pereWithId)
+ break
+ if pereWithId.estIdentifiePar != None:
+ listeRetour.append(pereWithId)
+ break
+ pereWithId = pereWithId.parent
+ return listeRetour
+
+ def getEtapes(self):
+ listeRetour = listUserASSD()
+ for pere in self.peres:
+ if pere.etape not in listeRetour:
+ listeRetour.append(pere.etape)
+ return listeRetour
+
+
+class listUserASSD(UserList):
+ def getListeMotsCles(self, nomMc):
+ if self.data == None:
+ return []
+ listeRetour = []
+ for concept in self.data:
+ listeRetour.append(concept.getChild(nomMc).val)
+ return listeRetour
+
+ def getListeNomsUserASSD(self, nomMc):
+ if self.data == None:
+ return []
+ listeRetour = []
+ for concept in self.data:
+ listeRetour.append(concept.getChild(nomMc).val.nom)
+ return listeRetour
+
+ def getListeUserASSD(self, nomMc):
+ if self.data == None:
+ return []
+ listeRetour = []
+ for concept in self.data:
+ if concept.getChild(nomMc):
+ if concept.getChild(nomMc).val:
+ listeRetour.append(concept.getChild(nomMc).val)
+ return listeRetour
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# ======================================================================
+
+"""
+ Ce module contient toutes les classes necessaires pour
+ implanter le concept de validateur dans Accas
+"""
+
+
+from builtins import object
+
+import types
+import traceback
+import re
+import os
+from Accas.processing.P_types import isInt, isFloat_or_int, isComplex
+from Accas.processing.P_types import isNumber, isStr, isSequence
+from Accas.extensions.eficas_translation import tr
+
+
+class ValError(Exception):
+ pass
+
+
+def cls_mro(cls):
+ if hasattr(cls, "__mro__"):
+ return cls.__mro__
+ mro = [cls]
+ for base in cls.__bases__:
+ mro.extend(cls_mro(base))
+ return mro
+
+
+class Protocol(object):
+ def __init__(self, name):
+ self.registry = {}
+ self.name = name
+ self.args = {}
+
+ def register(self, T, A):
+ print("register Protocol", T, A)
+ self.registry[T] = A
+
+ def adapt(self, obj):
+ # (a) verifier si l'objet peut s'adapter au protocole
+ adapt = getattr(obj, "__adapt__", None)
+ if adapt is not None:
+ # on demande à l'objet obj de réaliser lui-meme l'adaptation
+ return adapt(self)
+
+ # (b) verifier si un adapteur est enregistré (si oui l'utiliser)
+ if self.registry:
+ for T in cls_mro(obj.__class__):
+ if T in self.registry:
+ return self.registry[T](obj, self, **self.args)
+
+ # (c) utiliser l'adapteur par defaut
+ return self.default(obj, **self.args)
+
+ def default(self, obj, **args):
+ raise TypeError("Can't adapt %s to %s" % (obj.__class__.__name__, self.name))
+
+
+class PProtocol(Protocol):
+
+ """Verificateur de protocole paramétré (classe de base)"""
+
+ # Protocole paramétré. Le registre est unique pour toutes les instances.
+ # La methode register est une methode de classe
+ registry = {}
+
+ def __init__(self, name, **args):
+ self.name = name
+ self.args = args
+
+ def register(cls, T, A):
+ cls.registry[T] = A
+
+ register = classmethod(register)
+
+
+class ListProtocol(Protocol):
+
+ """Verificateur de protocole liste : convertit un objet quelconque en liste pour Accas.validation ultérieure"""
+
+ def default(self, obj):
+ from Accas import Tuple
+ if type(obj) is Tuple:
+ if len(obj) > 0 and obj[0] in ("RI", "MP"):
+ # il s'agit d'un complexe ancienne mode. La cardinalite vaut 1
+ return (obj,)
+ else:
+ return obj
+ elif type(obj) is list:
+ return obj
+ elif obj == None:
+ # pas de valeur affecte. La cardinalite vaut 0
+ return obj
+ elif isStr(obj):
+ # il s'agit d'une chaine. La cardinalite vaut 1
+ return (obj,)
+ else:
+ try:
+ # si l'objet supporte len, on a la cardinalite
+ length = len(obj)
+ return obj
+ except:
+ # sinon elle vaut 1
+ return (obj,)
+
+
+listProto = ListProtocol("list")
+
+
+class TypeProtocol(PProtocol):
+
+ """Verificateur de type parmi une liste de types possibles"""
+
+ # pas de registre par instance. Registre unique pour toutes les instances
+ # de TypeProtocol
+ registry = {}
+
+ def __init__(self, name, typ=None):
+ PProtocol.__init__(self, name, typ=typ)
+ self.typ = typ
+
+ def default(self, obj, typ):
+ err = ""
+ from Accas import Tuple
+ for type_permis in typ:
+ if type_permis == "createObject": continue
+ if type_permis == "R":
+ if isFloat_or_int(obj): return obj
+ elif type_permis == "I":
+ if isInt(obj): return obj
+ elif type_permis == "C":
+ if self.isComplexe(obj): return obj
+ elif type_permis == "TXM":
+ if isStr(obj): return obj
+ elif type_permis == "date":
+ from datetime import datetime
+ try:
+ d = datetime.strptime(obj, "%Y-%m-%d")
+ return obj
+ except:
+ raise ValError("%s n'est pas une date valide" % repr(obj))
+ # obsolete
+ elif type_permis == "shell":
+ if isStr(obj): return obj
+ # a refaire
+ elif type_permis == "Fichier":
+ try:
+ if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj):
+ return obj
+ else:
+ raise ValError("%s n'est pas un fichier valide" % repr(obj))
+ except:
+ raise ValError("%s n'est pas un fichier valide" % repr(obj))
+
+ elif type_permis == "FichierNoAbs":
+ if (len(typ) > 2 and typ[2] == "Sauvegarde") or isinstance( obj, type("")):
+ return obj
+ else:
+ raise ValError("%s n'est pas un fichier valide" % repr(obj))
+
+ elif type_permis == "Repertoire":
+ try:
+ if os.path.isdir(obj): return obj
+ else:
+ raise ValError("%s n'est pas un repertoire valide" % repr(obj))
+ except:
+ raise ValError("%s n'est pas un repertoire valide" % repr(obj))
+ elif type_permis == "FichierOuRepertoire":
+ try:
+ if os.path.isdir(obj) or os.path.isfile(obj): return obj
+ else:
+ raise ValError(
+ "%s n'est pas un fichier ou un repertoire valide"
+ % repr(obj)
+ )
+ except:
+ raise ValError(
+ "%s n'est pas un fichier ou un repertoire valide" % repr(obj)
+ )
+ elif type(type_permis) == type or isinstance(type_permis, type):
+ try:
+ if self.isObjectFrom(obj, type_permis): return obj
+ except Exception as err:
+ pass
+ elif isinstance(type_permis, Tuple):
+ try:
+ if type_permis.__convert__(obj): return obj
+ except Exception as err:
+ pass
+ elif isinstance(type_permis, object):
+ try:
+ if type_permis.__convert__(obj): return obj
+ except Exception as err:
+ pass
+ else:
+ print(("Type non encore gere %s" % type_permis))
+ raise ValError(
+ tr("%s (de type %s) n'est pas d'un type autorise: %s ")
+ % (repr(obj), type(obj), typ)
+ )
+ # import traceback; traceback.print_stack()
+ # print (object, type_permis,)
+
+ def isComplexe(self, valeur):
+ """Retourne 1 si valeur est un complexe, 0 sinon"""
+ from Accas import Tuple
+ if isNumber(valeur):
+ # Pour permettre l'utilisation de complexes Python (accepte les
+ # entiers et réels)
+ return 1
+ elif type(valeur) != Tuple:
+ # On n'autorise pas les listes pour les complexes
+ return 0
+ elif len(valeur) != 3:
+ return 0
+ else:
+ # Un complexe doit etre un tuple de longueur 3 avec 'RI' ou 'MP' comme premiere
+ # valeur suivie de 2 reels.
+ if valeur[0].strip() in ("RI", "MP"):
+ try:
+ v1 = reelProto.adapt(valeur[1]), reelProto.adapt(valeur[2])
+ return 1
+ except:
+ return 0
+ else:
+ return 0
+
+ def isObjectFrom(self, objet, classe):
+ """
+ Retourne 1 si objet est une instance de la classe classe, 0 sinon
+ """
+ convert = getattr(classe, "__convert__", None)
+ if convert is not None:
+ # classe verifie les valeurs
+ try:
+ v = convert(objet)
+ return v is not None
+ except ValueError as err:
+ raise
+ except:
+ return 0
+ # On accepte les instances de la classe et des classes derivees
+ return isinstance(objet, classe)
+
+
+reelProto = TypeProtocol("reel", typ=("R",))
+
+
+class CardProtocol(PProtocol):
+
+ """Verificateur de cardinalité"""
+
+ # pas de registre par instance. Registre unique pour toutes les instances
+ registry = {}
+
+ def __init__(self, name, min=1, max=1):
+ PProtocol.__init__(self, name, min=min, max=max)
+
+ def default(self, obj, min, max):
+ length = len(obj)
+ if (length < min) or (length > max):
+ raise ValError(
+ "Nombre d'arguments de %s incorrect (min = %s, max = %s)"
+ % (repr(obj), min, max)
+ )
+ return obj
+
+
+class IntoProtocol(PProtocol):
+
+ """Verificateur de choix possibles : liste discrète ou intervalle"""
+
+ # pas de registre par instance. Registre unique pour toutes les instances
+ registry = {}
+
+ def __init__(self, name, into=None, val_min=float("-inf"), val_max=float("inf")):
+ PProtocol.__init__(self, name, into=into, val_min=val_min, val_max=val_max)
+ self.val_min = val_min
+ self.val_max = val_max
+
+ def default(self, obj, into, val_min, val_max):
+ if type(into) == types.FunctionType:
+ maListeDeValeur = into()
+ into = maListeDeValeur
+ if into:
+ if obj not in into:
+ raise ValError(
+ tr("La valeur : %s ne fait pas partie des choix possibles %s")
+ % (repr(obj), into)
+ )
+ else:
+ # on est dans le cas d'un ensemble continu de valeurs possibles
+ # (intervalle)
+ if isFloat_or_int(obj):
+ if val_min == "**":
+ val_min = obj - 1
+ if val_max == "**":
+ val_max = obj + 1
+ if obj < val_min or obj > val_max:
+ raise ValError(
+ tr(
+ "La valeur : %s est en dehors du domaine de validite [ %s , %s ]"
+ )
+ % (repr(obj), self.val_min, self.val_max)
+ )
+ return obj
+
+
+class MinStr(object):
+ # exemple de classe pour verificateur de type
+ # on utilise des instances de classe comme type (typ=MinStr(3,6), par
+ # exemple)
+
+ def __init__(self, min, max):
+ self.min = min
+ self.max = max
+
+ def __convert__(self, valeur):
+ if isStr(valeur) and self.min <= len(valeur) <= self.max:
+ return valeur
+ raise ValError(
+ "%s n'est pas une chaine de longueur comprise entre %s et %s"
+ % (valeur, self.min, self.max)
+ )
+
+ def __repr__(self):
+ return tr("TXM de longueur entre %s et %s" % (self.min, self.max))
+
+
+class Valid(PProtocol):
+
+ """
+ Cette classe est la classe mere des validateurs Accas
+ Elle doit etre derivee
+ Elle presente la signature des methodes indispensables pour son bon
+ fonctionnement et dans certains cas leur comportement par défaut.
+
+ @ivar cata_info: raison de la validite ou de l'invalidite du validateur meme
+ @type cata_info: C{}
+ """
+
+ registry = {}
+
+ def __init__(self, **args):
+ PProtocol.__init__(self, "valid", **args)
+
+ def info(self):
+ """
+ Cette methode retourne une chaine de caractères informative sur
+ la Accas.validation demandée par le validateur. Elle est utilisée
+ pour produire le compte-rendu de validité du mot clé associé.
+ """
+ return "valeur valide"
+
+ def aide(self):
+ """
+ Cette methode retourne une chaine de caractère qui permet
+ de construire un message d'aide en ligne.
+ En général, le message retourné est le meme que celui retourné par la
+ méthode info.
+ """
+ return self.info()
+
+ def infoErreurItem(self):
+ """
+ Cette méthode permet d'avoir un message d'erreur pour un item
+ dans une liste dans le cas ou le validateur fait des vérifications
+ sur les items d'une liste. Si le validateur fait seulement des
+ vérifications sur la liste elle meme et non sur ses items, la méthode
+ doit retourner une chaine vide.
+ """
+ return " "
+
+ def infoErreurListe(self):
+ """
+ Cette méthode a un comportement complémentaire de celui de
+ infoErreurItem. Elle retourne un message d'erreur lié uniquement
+ aux vérifications sur la liste elle meme et pas sur ses items.
+ Dans le cas où le validateur ne fait pas de vérification sur des
+ listes, elle retourne une chaine vide
+ """
+ return " "
+
+ def verif(self, valeur):
+ """
+ Cette methode sert a verifier si la valeur passee en argument est consideree
+ comme valide ou non par le validateur. Dans le premier cas le validateur retourne 1
+ (valide) sinon 0 (invalide).
+
+ @type valeur: tout type python
+ @param valeur: valeur du mot cle a valider
+ @rtype: C{boolean}
+ @return: indicateur de validite 1 (valide) ou 0 (invalide)
+ """
+ raise NotImplementedError("Must be implemented")
+
+ def verifItem(self, valeur):
+ """
+ La methode verif du validateur effectue une Accas.validation complete de
+ la valeur. valeur peut etre un scalaire ou une liste. Le validateur
+ doit traiter les 2 aspects s'il accepte des listes (dans ce cas la
+ methode isList doit retourner 1).
+ La methode valid_item sert pour effectuer des Accas.validations partielles
+ de liste. Elle doit uniquement verifier la validite d'un item de
+ liste mais pas les caracteristiques de la liste.
+ """
+ return 0
+
+ def valideListePartielle(self, liste_courante):
+ """
+ Cette methode retourne un entier qui indique si liste_courante est partiellement valide (valeur 1)
+ ou invalide (valeur 0). La Accas.validation partielle concerne les listes en cours de construction : on
+ veut savoir si la liste en construction peut etre complétée ou si elle peut déjà etre considérée
+ comme invalide.
+ En général un validateur effectue la meme Accas.validation pour les listes partielles et les
+ listes complètes.
+ """
+ return self.verif(liste_courante)
+
+ def verifCata(self):
+ """
+ Cette methode sert a realiser des verifications du validateur lui meme.
+ Elle est facultative et retourne 1 (valide) par defaut.
+ Elle retourne 0 si le validateur est lui meme invalide si par exemple ses
+ parametres de definition ne sont pas corrects.
+ La raison de l'invalidite est stockee dans l'attribut cata_info.
+
+ @rtype: C{boolean}
+ @return: indicateur de validite 1 (valide) ou 0 (invalide)
+ """
+ return 1
+
+ def isList(self):
+ """
+ Cette méthode retourne un entier qui indique si le validateur
+ permet les listes (valeur 1) ou ne les permet pas (valeur 0).
+ Par défaut, un validateur n'autorise que des scalaires.
+ """
+ return 0
+
+ def hasInto(self):
+ """
+ Cette méthode retourne un entier qui indique si le validateur
+ propose une liste de choix (valeur 1) ou n'en propose pas.
+ Par défaut, un validateur n'en propose pas.
+ """
+ return 0
+
+ def getInto(self, liste_courante=None, into_courant=None):
+ """
+ Cette méthode retourne la liste de choix proposée par le validateur.
+ Si le validateur ne propose pas de liste de choix, la méthode
+ retourne None.
+ L'argument d'entrée liste_courante, s'il est différent de None, donne
+ la liste des choix déjà effectués par l'utilisateur. Dans ce cas, la
+ méthode getInto doit calculer la liste des choix en en tenant
+ compte. Par exemple, si le validateur n'autorise pas les répétitions,
+ la liste des choix retournée ne doit pas contenir les choix déjà
+ contenus dans liste_courante.
+ L'argument d'entrée into_courant, s'il est différent de None, donne
+ la liste des choix proposés par d'autres validateurs. Dans ce cas,
+ la méthode getInto doit calculer la liste des choix à retourner
+ en se limitant à cette liste initiale. Par exemple, si into_courant
+ vaut (1,2,3) et que le validateur propose la liste de choix (3,4,5),
+ la méthode ne doit retourner que (3,).
+
+ La méthode getInto peut retourner une liste vide [], ce qui veut
+ dire qu'il n'y a pas (ou plus) de choix possible. Cette situation
+ peut etre normale : l''utilisateur a utilisé tous les choix, ou
+ résulter d'une incohérence des validateurs :
+ choix parmi (1,2,3) ET choix parmi (4,5,6). Il est impossible de
+ faire la différence entre ces deux situations.
+ """
+ return into_courant
+
+
+class ListVal(Valid):
+
+ """
+ Cette classe sert de classe mère pour tous les validateurs qui acceptent
+ des listes.
+ """
+
+ def isList(self):
+ return 1
+
+ def getInto(self, liste_courante=None, into_courant=None):
+ """
+ Cette méthode getInto effectue un traitement général qui consiste
+ a filtrer la liste de choix into_courant, si elle existe, en ne
+ conservant que les valeurs valides (appel de la méthode valid).
+ """
+ if into_courant is None:
+ return None
+ else:
+ liste_choix = []
+ for e in into_courant:
+ if self.verif(e):
+ liste_choix.append(e)
+ return liste_choix
+
+ def convert(self, valeur):
+ """
+ Méthode convert pour les validateurs de listes. Cette méthode
+ fait appel à la méthode convertItem sur chaque élément de la
+ liste.
+ """
+ if isSequence(valeur):
+ for val in valeur:
+ self.convertItem(val)
+ return valeur
+ else:
+ return self.convertItem(valeur)
+
+ def verif(self, valeur):
+ """
+ Méthode verif pour les validateurs de listes. Cette méthode
+ fait appel à la méthode verifItem sur chaque élément de la
+ liste. Si valeur est un paramètre, on utilise sa valeur effective
+ valeur.valeur.
+ """
+ if isSequence(valeur):
+ for val in valeur:
+ if not self.verifItem(val):
+ return 0
+ return 1
+ else:
+ return self.verifItem(valeur)
+
+
+class Compulsory(ListVal):
+ """
+ Validateur operationnel
+ Verification de la présence obligatoire d'un élément dans une liste
+ """
+
+ registry = {}
+
+ def __init__(self, elem=()):
+ if not isSequence(elem):
+ elem = (elem,)
+ Valid.__init__(self, elem=elem)
+ self.elem = elem
+ self.cata_info = ""
+
+ def info(self):
+ return tr("valeur %s obligatoire") % self.elem
+
+ def default(self, valeur, elem):
+ return valeur
+
+ def verifItem(self, valeur):
+ return 1
+
+ def convert(self, valeur):
+ elem = list(self.elem)
+ for val in valeur:
+ v = self.adapt(val)
+ if v in elem:
+ elem.remove(v)
+ if elem:
+ raise ValError(
+ tr("%s ne contient pas les elements obligatoires : %s ")
+ % (valeur, elem)
+ )
+ return valeur
+
+ def hasInto(self):
+ return 1
+
+ def verif(self, valeur):
+ if not isSequence(valeur):
+ liste = list(valeur)
+ else:
+ liste = valeur
+ for val in self.elem:
+ if val not in liste:
+ return 0
+ return 1
+
+ def infoErreurItem(self):
+ return tr("La valeur n'est pas dans la liste des choix possibles")
+
+
+class Together(ListVal):
+ """
+ Validateur operationnel
+ si un des éléments est présent les autres doivent aussi l'être
+ """
+
+ registry = {}
+
+ def __init__(self, elem=()):
+ if not isSequence(elem):
+ elem = (elem,)
+ Valid.__init__(self, elem=elem)
+ self.elem = elem
+ self.cata_info = ""
+
+ def info(self):
+ return tr("%s present ensemble") % self.elem
+
+ def default(self, valeur, elem):
+ return valeur
+
+ def verifItem(self, valeur):
+ return 1
+
+ def convert(self, valeur):
+ elem = list(self.elem)
+ for val in valeur:
+ v = self.adapt(val)
+ if v in elem:
+ elem.remove(v)
+ if len(elem) == 0:
+ return valeur
+ if len(elem) != len(list(self.elem)):
+ raise ValError(
+ tr("%s ne contient pas les elements devant etre presents ensemble: %s ")
+ % (valeur, elem)
+ )
+ return valeur
+
+ def hasInto(self):
+ return 1
+
+ def verif(self, valeur):
+ if not isSequence(valeur):
+ liste = list(valeur)
+ else:
+ liste = valeur
+ compte = 0
+ for val in self.elem:
+ if val in liste:
+ compte += 1
+ if compte == 0:
+ return 1
+ if compte != len(list(self.elem)):
+ return 0
+ return 1
+
+ def infoErreurItem(self):
+ return tr("La valeur n'est pas dans la liste des choix possibles")
+
+
+class Absent(ListVal):
+ """
+ Validateur operationnel
+ si un des éléments est présent non valide
+ """
+
+ registry = {}
+
+ def __init__(self, elem=()):
+ if not isSequence(elem):
+ elem = (elem,)
+ Valid.__init__(self, elem=elem)
+ self.elem = elem
+ self.cata_info = ""
+
+ def info(self):
+ return tr("%s absent") % self.elem
+
+ def default(self, valeur, elem):
+ return valeur
+
+ def verifItem(self, valeur):
+ return 1
+
+ def convert(self, valeur):
+ elem = list(self.elem)
+ for val in valeur:
+ v = self.adapt(val)
+ if v in elem:
+ raise ValError(tr("%s n'est pas autorise : %s ") % (v, elem))
+ return valeur
+
+ def hasInto(self):
+ return 1
+
+ def verif(self, valeur):
+ if not isSequence(valeur):
+ liste = list(valeur)
+ else:
+ liste = valeur
+ for val in self.elem:
+ if val in liste:
+ return 0
+ return 1
+
+ def infoErreurItem(self):
+ return tr("La valeur n'est pas dans la liste des choix possibles")
+
+
+class NoRepeat(ListVal):
+ """
+ Validateur operationnel
+ Verification d'absence de doublons dans la liste.
+ """
+
+ def __init__(self):
+ Valid.__init__(self)
+ self.cata_info = ""
+
+ def info(self):
+ return tr("Pas de doublon dans la liste")
+
+ def infoErreurListe(self):
+ return tr("Les doublons ne sont pas permis")
+
+ def default(self, valeur):
+ if valeur in self.liste:
+ raise ValError(tr("%s est un doublon") % valeur)
+ return valeur
+
+ def convert(self, valeur):
+ self.liste = []
+ for val in valeur:
+ v = self.adapt(val)
+ self.liste.append(v)
+ return valeur
+
+ def verifItem(self, valeur):
+ return 1
+
+ def verif(self, valeur):
+ if isSequence(valeur):
+ liste = list(valeur)
+ for val in liste:
+ if liste.count(val) != 1:
+ return 0
+ return 1
+ else:
+ return 1
+
+ def getInto(self, liste_courante=None, into_courant=None):
+ """
+ Methode getInto spécifique pour validateur NoRepeat, on retourne
+ une liste de choix qui ne contient aucune valeur de into_courant
+ déjà contenue dans liste_courante
+ """
+ if into_courant is None:
+ liste_choix = None
+ else:
+ liste_choix = []
+ for e in into_courant:
+ if e in liste_choix:
+ continue
+ if liste_courante is not None and e in liste_courante:
+ continue
+ liste_choix.append(e)
+ return liste_choix
+
+
+class LongStr(ListVal):
+
+ """
+ Validateur operationnel
+ Verification de la longueur d une chaine
+ """
+
+ def __init__(self, low, high):
+ ListVal.__init__(self, low=low, high=high)
+ self.low = low
+ self.high = high
+ self.cata_info = ""
+
+ def info(self):
+ return tr("longueur de la chaine entre %s et %s") % (self.low, self.high)
+
+ def infoErreurItem(self):
+ return tr("Longueur de la chaine incorrecte")
+
+ def convert(self, valeur):
+ for val in valeur:
+ v = self.adapt(val)
+ return valeur
+
+ def verifItem(self, valeur):
+ try:
+ self.adapt(valeur)
+ return 1
+ except:
+ return 0
+
+ def default(self, valeur, low, high):
+ if not isStr(valeur):
+ raise ValError("%s n'est pas une chaine" % repr(valeur))
+ if valeur[0] == "'" and valeur[-1] == "'":
+ low = low + 2
+ high = high + 2
+ if len(valeur) < low or len(valeur) > high:
+ raise ValError("%s n'est pas de la bonne longueur" % repr(valeur))
+ return valeur
+
+
+class OnlyStr(ListVal):
+
+ """
+ Validateur operationnel
+ Valide que c'est une chaine
+ """
+
+ def __init__(self):
+ ListVal.__init__(self)
+ self.cata_info = ""
+
+ def info(self):
+ return tr("regarde si c'est une chaine")
+
+ def infoErreurItem(self):
+ return tr("Ce n'est pas une chaine")
+
+ def convert(self, valeur):
+ for val in valeur:
+ v = self.adapt(val)
+ return valeur
+
+ def verifItem(self, valeur):
+ try:
+ self.adapt(valeur)
+ return 1
+ except:
+ return 0
+
+ def default(self, valeur):
+ if not isStr(valeur):
+ raise ValError(tr("%s n'est pas une chaine") % repr(valeur))
+ return valeur
+
+
+class OrdList(ListVal):
+
+ """
+ Validateur operationnel
+ Verification qu'une liste est croissante ou decroissante
+ """
+
+ def __init__(self, ord):
+ ListVal.__init__(self, ord=ord)
+ self.ord = ord
+ self.cata_info = ""
+
+ def info(self):
+ return "liste %s" % self.ord
+
+ def infoErreurListe(self):
+ return tr("La liste doit etre en ordre %s") % self.ord
+
+ def convert(self, valeur):
+ self.val = None
+ self.liste = valeur
+ for v in valeur:
+ self.adapt(v)
+ return valeur
+
+ def default(self, valeur, ord):
+ if self.ord == "croissant":
+ if self.val is not None and valeur < self.val:
+ raise ValError(
+ (tr("%s n'est pas par valeurs croissantes") % repr(self.liste))
+ )
+ elif self.ord == "decroissant":
+ if self.val is not None and valeur > self.val:
+ raise ValError(
+ (tr("%s n'est pas par valeurs decroissantes") % repr(self.liste))
+ )
+ self.val = valeur
+ return valeur
+
+ def verifItem(self, valeur):
+ return 1
+
+ def getInto(self, liste_courante=None, into_courant=None):
+ """
+ Methode getInto spécifique pour validateur OrdList, on retourne
+ une liste de choix qui ne contient aucune valeur de into_courant
+ dont la valeur est inférieure à la dernière valeur de
+ liste_courante, si elle est différente de None.
+ """
+ if into_courant is None:
+ return None
+ elif not liste_courante:
+ return into_courant
+ else:
+ liste_choix = []
+ last_val = liste_choix[-1]
+ for e in into_courant:
+ if self.ord == "croissant" and e <= last_val:
+ continue
+ if self.ord == "decroissant" and e >= last_val:
+ continue
+ liste_choix.append(e)
+ return liste_choix
+
+
+class OrVal(Valid):
+
+ """
+ Validateur operationnel
+ Cette classe est un validateur qui controle une liste de validateurs
+ Elle verifie qu'au moins un des validateurs de la liste valide la valeur
+ """
+
+ def __init__(self, validators=()):
+ if not isSequence(validators):
+ validators = (validators,)
+ self.validators = []
+ for validator in validators:
+ if type(validator) == types.FunctionType:
+ self.validators.append(FunctionVal(validator))
+ else:
+ self.validators.append(validator)
+ self.cata_info = ""
+
+ def info(self):
+ return "\n ou ".join([v.info() for v in self.validators])
+
+ def convert(self, valeur):
+ for validator in self.validators:
+ try:
+ return validator.convert(valeur)
+ except:
+ pass
+ raise ValError(tr("%s n'est pas du bon type") % repr(valeur))
+
+ def infoErreurItem(self):
+ l = []
+ for v in self.validators:
+ err = v.infoErreurItem()
+ if err != " ":
+ l.append(err)
+ chaine = " \n ou ".join(l)
+ return chaine
+
+ def infoErreurListe(self):
+ l = []
+ for v in self.validators:
+ err = v.infoErreurListe()
+ if err != " ":
+ l.append(err)
+ chaine = " \n ou ".join(l)
+ return chaine
+
+ def isList(self):
+ """
+ Si plusieurs validateurs sont reliés par un OU
+ il suffit qu'un seul des validateurs attende une liste
+ pour qu'on considère que leur union attend une liste.
+ """
+ for validator in self.validators:
+ v = validator.isList()
+ if v:
+ return 1
+ return 0
+
+ def verif(self, valeur):
+ for validator in self.validators:
+ v = validator.verif(valeur)
+ if v:
+ return 1
+ return 0
+
+ def verifItem(self, valeur):
+ for validator in self.validators:
+ v = validator.verifItem(valeur)
+ if v:
+ return 1
+ return 0
+
+ def verifCata(self):
+ infos = []
+ for validator in self.validators:
+ v = validator.verifCata()
+ if not v:
+ infos.append(validator.cata_info)
+ if infos:
+ self.cata_info = "\n".join(infos)
+ return 0
+ self.cata_info = ""
+ return 1
+
+ def hasInto(self):
+ """
+ Dans le cas ou plusieurs validateurs sont reliés par un OU
+ il faut que tous les validateurs proposent un choix pour
+ qu'on considère que leur union propose un choix.
+ Exemple : Enum(1,2,3) OU entier pair, ne propose pas de choix
+ En revanche, Enum(1,2,3) OU Enum(4,5,6) propose un choix (1,2,3,4,5,6)
+ """
+ for validator in self.validators:
+ v = validator.hasInto()
+ if not v:
+ return 0
+ return 1
+
+ def getInto(self, liste_courante=None, into_courant=None):
+ """
+ Dans le cas ou plusieurs validateurs sont reliés par un OU
+ tous les validateurs doivent proposer un choix pour
+ qu'on considère que leur union propose un choix. Tous les choix
+ proposés par les validateurs sont réunis (opérateur d'union).
+ Exemple : Enum(1,2,3) OU entier pair, ne propose pas de choix
+ En revanche, Enum(1,2,3) OU Enum(4,5,6) propose un
+ choix (1,2,3,4,5,6)
+ """
+ validator_into = []
+ for validator in self.validators:
+ v_into = validator.getInto(liste_courante, into_courant)
+ if v_into is None:
+ return v_into
+ validator_into.extend(v_into)
+ return validator_into
+
+ def valideListePartielle(self, liste_courante=None):
+ """
+ Méthode de Accas.validation de liste partielle pour le validateur Or.
+ Si un des validateurs gérés par le validateur Or considère la
+ liste comme valide, le validateur Or la considère comme valide.
+ """
+ for validator in self.validators:
+ v = validator.valideListePartielle(liste_courante)
+ if v:
+ return 1
+ return 0
+
+
+class AndVal(Valid):
+
+ """
+ Validateur operationnel
+ Cette classe est un validateur qui controle une liste de validateurs
+ Elle verifie que tous les validateurs de la liste valident la valeur
+ """
+
+ def __init__(self, validators=()):
+ if not isSequence(validators):
+ validators = (validators,)
+ self.validators = []
+ for validator in validators:
+ if type(validator) == types.FunctionType:
+ self.validators.append(FunctionVal(validator))
+ else:
+ self.validators.append(validator)
+ if hasattr(validator, "fonctions"):
+ for fonction in validator.fonctions:
+ f = getattr(validator, fonction)
+ setattr(self, fonction, f)
+ self.cata_info = ""
+
+ def set_MCSimp(self, MCSimp):
+ for validator in self.validators:
+ if hasattr(validator, "set_MCSimp"):
+ validator.set_MCSimp(MCSimp)
+
+ def info(self):
+ return "\n et ".join([v.info() for v in self.validators])
+
+ def convert(self, valeur):
+ for validator in self.validators:
+ valeur = validator.convert(valeur)
+ return valeur
+
+ def infoErreurItem(self):
+ chaine = ""
+ a = 1
+ for v in self.validators:
+ if v.infoErreurItem() != " ":
+ if a == 1:
+ chaine = v.infoErreurItem()
+ a = 0
+ else:
+ chaine = chaine + " \n et " + v.infoErreurItem()
+ return chaine
+
+ def infoErreurListe(self):
+ chaine = ""
+ a = 1
+ for v in self.validators:
+ if v.infoErreurListe() != " ":
+ if a == 1:
+ chaine = v.infoErreurListe()
+ a = 0
+ else:
+ chaine = chaine + " \n et " + v.infoErreurListe()
+ return chaine
+
+ def verif(self, valeur):
+ for validator in self.validators:
+ v = validator.verif(valeur)
+ if not v:
+ self.local_info = validator.info()
+ return 0
+ return 1
+
+ def verifItem(self, valeur):
+ for validator in self.validators:
+ v = validator.verifItem(valeur)
+ if not v:
+ # L'info n'est probablement pas la meme que pour verif ???
+ self.local_info = validator.info()
+ return 0
+ return 1
+
+ def verifCata(self):
+ infos = []
+ for validator in self.validators:
+ v = validator.verifCata()
+ if not v:
+ infos.append(validator.cata_info)
+ if infos:
+ self.cata_info = "\n".join(infos)
+ return 0
+ self.cata_info = ""
+ return 1
+
+ def valideListePartielle(self, liste_courante=None):
+ """
+ Méthode de Accas.validation de liste partielle pour le validateur And.
+ Tous les validateurs gérés par le validateur And doivent considérer
+ la liste comme valide, pour que le validateur And la considère
+ comme valide.
+ """
+ for validator in self.validators:
+ v = validator.valideListePartielle(liste_courante)
+ if not v:
+ return 0
+ return 1
+
+ def isList(self):
+ """
+ Si plusieurs validateurs sont reliés par un ET
+ il faut que tous les validateurs attendent une liste
+ pour qu'on considère que leur intersection attende une liste.
+ Exemple Range(2,5) ET Card(1) n'attend pas une liste
+ Range(2,5) ET Pair attend une liste
+ """
+ for validator in self.validators:
+ v = validator.isList()
+ if v == 0:
+ return 0
+ return 1
+
+ def hasInto(self):
+ """
+ Dans le cas ou plusieurs validateurs sont reliés par un ET
+ il suffit qu'un seul validateur propose un choix pour
+ qu'on considère que leur intersection propose un choix.
+ Exemple : Enum(1,2,3) ET entier pair, propose un choix
+ En revanche, entier pair ET superieur à 10 ne propose pas de choix
+ """
+ for validator in self.validators:
+ v = validator.hasInto()
+ if v:
+ return 1
+ return 0
+
+ def getInto(self, liste_courante=None, into_courant=None):
+ """
+ Dans le cas ou plusieurs validateurs sont reliés par un ET
+ il suffit qu'un seul validateur propose un choix pour
+ qu'on considère que leur intersection propose un choix. Tous les
+ choix proposés par les validateurs sont croisés (opérateur
+ d'intersection)
+ Exemple : Enum(1,2,3) ET entier pair, propose un choix (2,)
+ En revanche, Enum(1,2,3) ET Enum(4,5,6) ne propose pas de choix.
+ """
+ for validator in self.validators:
+ into_courant = validator.getInto(liste_courante, into_courant)
+ if into_courant in ([], None):
+ break
+ return into_courant
+
+
+def do_liste(validators):
+ """
+ Convertit une arborescence de validateurs en OrVal ou AndVal
+ validators est une liste de validateurs ou de listes ou de tuples
+ """
+ valids = []
+ for validator in validators:
+ if type(validator) == types.FunctionType:
+ valids.append(FunctionVal(validator))
+ elif type(validator) is tuple:
+ valids.append(OrVal(do_liste(validator)))
+ elif type(validator) is list:
+ valids.append(AndVal(do_liste(validator)))
+ else:
+ valids.append(validator)
+ return valids
+
+
+def validatorFactory(validator):
+ if type(validator) == types.FunctionType:
+ return FunctionVal(validator)
+ elif type(validator) is tuple:
+ return OrVal(do_liste(validator))
+ elif type(validator) is list:
+ return AndVal(do_liste(validator))
+ else:
+ return validator
+
+
+# Ci-dessous : exemples de validateur (peu testés)
+
+
+class RangeVal(ListVal):
+
+ """
+ Exemple de classe validateur : verification qu'une valeur
+ est dans un intervalle.
+ Pour une liste on verifie que tous les elements sont
+ dans l'intervalle
+ Susceptible de remplacer les attributs "vale_min" "vale_max"
+ dans les catalogues
+ """
+
+ def __init__(self, low, high):
+ self.low = low
+ self.high = high
+ self.cata_info = tr("%s doit etre inferieur a %s") % (low, high)
+
+ def info(self):
+ return tr("valeur dans l'intervalle %s , %s") % (self.low, self.high)
+
+ def convertItem(self, valeur):
+ if valeur > self.low and valeur < self.high:
+ return valeur
+ raise ValError(
+ tr("%s devrait etre comprise entre %s et %s")
+ % (valeur, self.low, self.high)
+ )
+
+ def verifItem(self, valeur):
+ return valeur > self.low and valeur < self.high
+
+ def infoErreurItem(self):
+ return tr("la valeur %s doit etre comprise entre %s et %s") % (
+ valeur,
+ self.low,
+ self.high,
+ )
+
+ def verifCata(self):
+ if self.low > self.high:
+ return 0
+ return 1
+
+
+class CardVal(Valid):
+
+ """
+ Exemple de classe validateur : verification qu'une liste est
+ d'une longueur superieur a un minimum (min) et inferieure
+ a un maximum (max).
+ Susceptible de remplacer les attributs "min" "max" dans les
+ catalogues
+ """
+
+ def __init__(self, min=float("-inf"), max=float("inf")):
+ self.min = min
+ self.max = max
+ self.cata_info = tr("%s doit etre inferieur a %s") % (min, max)
+
+ def info(self):
+ return tr("longueur de liste comprise entre %s et %s") % (self.min, self.max)
+
+ def infoErreurListe(self):
+ return tr("Le cardinal de la liste doit etre compris entre %s et %s") % (
+ self.min,
+ self.max,
+ )
+
+ def isList(self):
+ return self.max == "**" or self.max > 1
+
+ def getInto(self, liste_courante=None, into_courant=None):
+ if into_courant is None:
+ return None
+ elif liste_courante is None:
+ return into_courant
+ elif self.max == "**":
+ return into_courant
+ elif len(liste_courante) < self.max:
+ return into_courant
+ else:
+ return []
+
+ def convert(self, valeur):
+ if isSequence(valeur):
+ l = len(valeur)
+ elif valeur is None:
+ l = 0
+ else:
+ l = 1
+ if self.max != "**" and l > self.max:
+ raise ValError(
+ tr("%s devrait etre de longueur inferieure a %s") % (valeur, self.max)
+ )
+ if self.min != "**" and l < self.min:
+ raise ValError(
+ tr("%s devrait etre de longueur superieure a %s") % (valeur, self.min)
+ )
+ return valeur
+
+ def verifItem(self, valeur):
+ return 1
+
+ def verif(self, valeur):
+ if isSequence(valeur):
+ if self.max != "**" and len(valeur) > self.max:
+ return 0
+ if self.min != "**" and len(valeur) < self.min:
+ return 0
+ return 1
+ else:
+ if self.max != "**" and 1 > self.max:
+ return 0
+ if self.min != "**" and 1 < self.min:
+ return 0
+ return 1
+
+ def verifCata(self):
+ if self.min != "**" and self.max != "**" and self.min > self.max:
+ return 0
+ return 1
+
+ def valideListePartielle(self, liste_courante=None):
+ validite = 1
+ if liste_courante != None:
+ if len(liste_courante) > self.max:
+ validite = 0
+ return validite
+
+
+class PairVal(ListVal):
+
+ """
+ Exemple de classe validateur : verification qu'une valeur
+ est paire.
+ Pour une liste on verifie que tous les elements sont
+ pairs
+ """
+
+ def __init__(self):
+ ListVal.__init__(self)
+ self.cata_info = ""
+
+ def info(self):
+ return _("valeur paire")
+
+ def infoErreurItem(self):
+ return tr("La valeur saisie doit etre paire")
+
+ def convert(self, valeur):
+ for val in valeur:
+ v = self.adapt(val)
+ if v % 2 != 0:
+ raise ValError(tr("%s contient des valeurs non paires") % repr(valeur))
+ return valeur
+
+ def default(self, valeur):
+ return valeur
+
+ def verifItem(self, valeur):
+ if type(valeur) not in six.integer_types:
+ return 0
+ return valeur % 2 == 0
+
+ def verif(self, valeur):
+ if isSequence(valeur):
+ for val in valeur:
+ if val % 2 != 0:
+ return 0
+ return 1
+ else:
+ if valeur % 2 != 0:
+ return 0
+ return 1
+
+
+class EnumVal(ListVal):
+
+ """
+ Exemple de classe validateur : verification qu'une valeur
+ est prise dans une liste de valeurs.
+ Susceptible de remplacer l attribut "into" dans les catalogues
+ """
+
+ def __init__(self, into=()):
+ if not isSequence(into):
+ into = (into,)
+ self.into = into
+ self.cata_info = ""
+
+ def info(self):
+ return "valeur dans %s" % self.into
+
+ def convertItem(self, valeur):
+ if valeur in self.into:
+ return valeur
+ raise ValError(
+ tr("%s contient des valeurs hors des choix possibles: %s ")
+ % (valeur, self.into)
+ )
+
+ def verifItem(self, valeur):
+ if valeur not in self.into:
+ return 0
+ return 1
+
+ def hasInto(self):
+ return 1
+
+ def getInto(self, liste_courante=None, into_courant=None):
+ if into_courant is None:
+ liste_choix = list(self.into)
+ else:
+ liste_choix = []
+ for e in into_courant:
+ if e in self.into:
+ liste_choix.append(e)
+ return liste_choix
+
+ def infoErreurItem(self):
+ return tr("La valeur n'est pas dans la liste des choix possibles")
+
+
+def ImpairVal(valeur):
+ """
+ Exemple de validateur
+ Cette fonction est un validateur. Elle verifie que la valeur passee
+ est bien un nombre impair.
+ """
+ if isSequence(valeur):
+ for val in valeur:
+ if val % 2 != 1:
+ return 0
+ return 1
+ else:
+ if valeur % 2 != 1:
+ return 0
+ return 1
+
+
+ImpairVal.info = "valeur impaire"
+
+
+class F1Val(Valid):
+
+ """
+ Exemple de validateur
+ Cette classe est un validateur de dictionnaire (mot cle facteur ?). Elle verifie
+ que la somme des cles A et B vaut une valeur donnee
+ en parametre du validateur
+ """
+
+ def __init__(self, somme=10):
+ self.somme = somme
+ self.cata_info = ""
+
+ def info(self):
+ return tr("valeur %s pour la somme des cles A et B ") % self.somme
+
+ def verif(self, valeur):
+ if isSequence(valeur):
+ for val in valeur:
+ if not "A" in val:
+ return 0
+ if not "B" in val:
+ return 0
+ if val["A"] + val["B"] != self.somme:
+ return 0
+ return 1
+ else:
+ if not "A" in valeur:
+ return 0
+ if not "B" in valeur:
+ return 0
+ if valeur["A"] + valeur["B"] != self.somme:
+ return 0
+ return 1
+
+
+class FunctionVal(Valid):
+
+ """
+ Exemple de validateur
+ Cette classe est un validateur qui est initialise avec une fonction
+ """
+
+ def __init__(self, function):
+ self.function = function
+
+ def info(self):
+ return self.function.info
+
+ def infoErreurItem(self):
+ return self.function.info
+
+ def verif(self, valeur):
+ return self.function(valeur)
+
+ def verifItem(self, valeur):
+ return self.function(valeur)
+
+ def convert(self, valeur):
+ return valeur
+
+
+# MC ca ne devrait plus servir !
+# PN : commenter le 22.11.19
+# CoercableFuncs = {int: int,
+# int: int,
+# float: float,
+# complex: complex,
+# str: six.text_type}
+
+
+class TypeVal(ListVal):
+
+ """
+ Exemple de validateur
+ Cette classe est un validateur qui controle qu'une valeur
+ est bien du type Python attendu.
+ Pour une liste on verifie que tous les elements sont du bon type.
+ Semblable a InstanceVal mais ici on fait le test par tentative de conversion
+ alors qu'avec InstanceVal on ne teste que si isinstance est vrai.
+ """
+
+ def __init__(self, aType):
+ # Si aType n'est pas un type, on le retrouve a l'aide de la fonction type
+ # type(1) == int;type(0.2)==float;etc.
+ if type(aType) != type:
+ aType = type(aType)
+ self.aType = aType
+ try:
+ self.coerce = CoercableFuncs[aType]
+ except:
+ self.coerce = self.identity
+
+ def info(self):
+ return tr("valeur de %s") % self.aType
+
+ def identity(self, value):
+ if type(value) == self.aType:
+ return value
+ raise ValError
+
+ def convertItem(self, valeur):
+ return self.coerce(valeur)
+
+ def verifItem(self, valeur):
+ try:
+ self.coerce(valeur)
+ except:
+ return 0
+ return 1
+
+
+class InstanceVal(ListVal):
+
+ """
+ Exemple de validateur
+ Cette classe est un validateur qui controle qu'une valeur est
+ bien une instance (au sens Python) d'une classe
+ Pour une liste on verifie chaque element de la liste
+ """
+
+ def __init__(self, aClass):
+ # Si aClass est une classe on la memorise dans self.aClass
+ # sinon c'est une instance dont on memorise la classe
+ # if type(aClass) == types.InstanceType:
+ if type(aClass) == object:
+ # instance ancienne mode
+ aClass = aClass.__class__
+ elif type(aClass) == type:
+ # classe ancienne mode
+ aClass = aClass
+ elif type(aClass) == type:
+ # classe nouvelle mode
+ aClass = aClass
+ elif isinstance(aClass, object):
+ # instance nouvelle mode
+ aClass = type(aClass)
+ else:
+ raise ValError(tr("type non supporté"))
+
+ self.aClass = aClass
+
+ def info(self):
+ return tr("valeur d'instance de %s") % self.aClass.__name__
+
+ def verifItem(self, valeur):
+ if not isinstance(valeur, self.aClass):
+ return 0
+ return 1
+
+
+class VerifTypeTuple(ListVal):
+ def __init__(self, typeDesTuples):
+ self.typeDesTuples = typeDesTuples
+ Valid.__init__(self)
+ self.cata_info = ""
+
+ def info(self):
+ return tr(": verifie les \ntypes dans un tuple")
+
+ def infoErreurListe(self):
+ return tr("Les types entres ne sont pas permis")
+
+ def default(self, valeur):
+ return valeur
+
+ def isList(self):
+ return 1
+
+ def convertItem(self, valeur):
+ if len(valeur) != len(self.typeDesTuples):
+ raise ValError(
+ tr("%s devrait etre de type %s ") % (valeur, self.typeDesTuples)
+ )
+ for i in range(len(valeur)):
+ ok = self.verifType(valeur[i], self.typeDesTuples[i])
+ if ok != 1:
+ raise ValError(
+ tr("%s devrait etre de type %s ") % (valeur, self.typeDesTuples)
+ )
+ return valeur
+
+ def verifItem(self, valeur):
+ try:
+ if len(valeur) != len(self.typeDesTuples):
+ return 0
+ for i in range(len(valeur)):
+ ok = self.verifType(valeur[i], self.typeDesTuples[i])
+ if ok != 1:
+ return 0
+ except:
+ return 0
+ return 1
+
+ def verifType(self, valeur, type_permis):
+ if type_permis == "R":
+ if type(valeur) in (int, float, int):
+ return 1
+ elif type_permis == "I":
+ if type(valeur) in (int, int):
+ return 1
+ elif type_permis == "C":
+ if self.isComplexe(valeur):
+ return 1
+ elif type_permis == "TXM":
+ if type(valeur) == bytes or type(valeur) == str:
+ return 1
+ elif isinstance(valeur, type_permis):
+ return 1
+ return 0
+
+ def verif(self, valeur):
+ if type(valeur) in (list, tuple):
+ liste = list(valeur)
+ for val in liste:
+ if self.verifItem(val) != 1:
+ return 0
+ return 1
+
+
+class VerifExiste(ListVal):
+
+ """
+ fonctionne avec into
+ Met une liste à jour selon les mot clefs existant
+ exemple si into = ("A","B","C")
+ si au niveau N du JDC les objets "A" et "C" existe
+ alors la liste des into deviendra ( "A","C")
+
+ niveauVerif est le niveau du JDC dans lequel va s effectuer la verification
+ niveauVerif est defini par rapport au Noeud :
+ exemple niveauVerif = 1 : on verifie les freres
+ niveauVerif = 2 : on verifie les oncles..
+ """
+
+ def __init__(self, niveauVerif):
+ ListVal.__init__(self)
+ self.niveauVerif = niveauVerif
+ self.MCSimp = None
+ self.listeDesFreres = ()
+ self.fonctions = ("verifieListe", "set_MCSimp")
+
+ def isList(self):
+ return 1
+
+ def verifieListe(self, liste):
+ self.set_MCSimp(self.MCSimp)
+ for item in liste:
+ if not (item in self.listeDesFreres):
+ return 0
+ return 1
+
+ def verifItem(self, valeur):
+ self.set_MCSimp(self.MCSimp)
+ if valeur in self.listeDesFreres:
+ return 1
+ return 0
+
+ def set_MCSimp(self, MCSimp):
+ self.MCSimp = MCSimp
+ k = self.niveauVerif
+ mc = MCSimp
+ while k != 0:
+ parent = mc.parent
+ mc = parent
+ k = k - 1
+ # on met la liste à jour
+ parent.forceRecalcul = self.niveauVerif
+ self.listeDesFreres = parent.listeMcPresents()
+
+ def convertItem(self, valeur):
+ if valeur in self.listeDesFreres:
+ return valeur
+ raise ValError(tr("%s n'est pas dans %s") % (valeur, self.listeDesFreres))
+
+
+class RegExpVal(ListVal):
+
+ """
+ Vérifie qu'une chaîne de caractère corresponde à l'expression régulière 'pattern'
+ """
+
+ errormsg = 'La chaîne "%(value)s" ne correspond pas au motif "%(pattern)s"'
+
+ def __init__(self, pattern):
+ self.pattern = pattern
+ self.compiled_regexp = re.compile(pattern)
+
+ def info(self):
+ return (
+ tr("Une chaîne correspondant au motif ")
+ + str(self.pattern)
+ + tr(" est attendue")
+ )
+
+ def infoErreurItem(self):
+ return (
+ tr("Une chaîne correspondant au motif ")
+ + str(self.pattern)
+ + tr(" est attendue")
+ )
+
+ def verifItem(self, valeur):
+ if self.compiled_regexp.match(valeur):
+ return 1
+ else:
+ return (0, self.errormsg % {"value": valeur, "pattern": self.pattern})
+
+ def convertItem(self, valeur):
+ if self.compiled_regexp.match(valeur):
+ return valeur
+ else:
+ raise ValError(self.errormsg % {"value": valeur, "pattern": self.pattern})
+
+
+class FileExtVal(RegExpVal):
+
+ """
+ Vérifie qu'une chaîne de caractère soit un nom de fichier valide avec l'extension 'ext'
+ """
+
+ def __init__(self, ext):
+ self.ext = ext
+ self.errormsg = '"%%(value)s" n\'est pas un nom de fichier %(ext)s valide' % {
+ "ext": ext
+ }
+ # PNPN Modif pour Adao
+ RegExpVal.__init__(self, "^\S+\.%s$" % self.ext)
+
+ def info(self):
+ return 'Un nom de fichier se terminant par ".%s" est attendu.' % self.ext
+
+ def infoErreurItem(self):
+ return 'Un nom de fichier se terminant par ".%s" est attendu.' % self.ext
+
+
+class CreeMotClef(object):
+ def __init__(self, MotClef):
+ self.MotClef = MotClef
+ self.MCSimp = None
+
+ def convert(self, lval):
+ try:
+ valeur = lval[0]
+ except:
+ return lval
+
+ parent = self.MCSimp.parent
+ if hasattr(parent, "inhibeValidator") and parent.inhibeValidator:
+ return lval
+
+ if parent.getChild(self.MotClef) == None:
+ longueur = 0
+ else:
+ longueur = len(parent.getChild(self.MotClef))
+
+ pos = parent.getIndexChild(self.MCSimp.nom) + 1
+ while longueur < valeur:
+ parent.inhibeValidator = 1
+ parent.addEntite(self.MotClef, pos)
+ pos = pos + 1
+ parent.inhibeValidator = 0
+ longueur = len(parent.getChild(self.MotClef))
+
+ if longueur > valeur:
+ parent.inhibeValide = 1
+ parentObj = parent.getChild(self.MotClef)
+ obj = parent.getChild(self.MotClef)[-1]
+ parentObj.suppEntite(obj)
+ longueur = len(parent.getChild(self.MotClef))
+ parent.inhibeValide = 0
+ return lval
+
+ def info(self):
+ return "Cree le bon nombre de Mot %s" % self.MotClef
+
+ def verifItem(self, valeur):
+ return 1
+
+ def set_MCSimp(self, MCSimp):
+ # print "dans set_MCSimp"
+ self.MCSimp = MCSimp
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+from collections import UserDict
+
+
+class _F(UserDict):
+
+ """
+ Cette classe a un comportement semblable à un
+ dictionnaire Python et permet de donner
+ la valeur d'un mot-clé facteur avec pour les sous
+ mots-clés la syntaxe motcle=valeur
+ """
+
+ def __init__(self, *pos, **args):
+ if len(pos) != 0:
+ raise SyntaxError(
+ "Valeur invalide pour '_F('. "
+ "On attend cette syntaxe : _F(MOTCLE=valeur, ...)"
+ )
+ self.data = args
+
+ def supprime(self):
+ self.data = {}
+
+ def __cmp__(self, dict):
+ print("processing _F.py ________________________ Attention cmp deprecated")
+ from past.builtins import cmp
+
+ if type(dict) == type(self.data):
+ return cmp(self.data, dict)
+ elif hasattr(dict, "data"):
+ return cmp(self.data, dict.data)
+ else:
+ return cmp(self.data, dict)
+
+ def __iter__(self):
+ return iter(self.data)
+
+ def copy(self):
+ import copy
+
+ c = copy.copy(self)
+ c.data = self.data.copy()
+ return c
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+"""
+ Ce module contient des fonctions utilitaires pour tester les types
+"""
+
+# use isinstance() instead of type() because objects returned from numpy arrays
+# inherit from python scalars but are numpy.float64 or numpy.int32...
+
+
+def isInt(obj):
+ return isinstance(obj, int) or type(obj) is int
+
+
+def isFloat(obj):
+ return isinstance(obj, float)
+
+
+def isComplex(obj):
+ return isinstance(obj, complex)
+
+
+from decimal import Decimal
+
+
+def isFloat_or_int(obj):
+ return isFloat(obj) or isInt(obj) or isinstance(obj, Decimal)
+
+
+def isNumber(obj):
+ return isFloat_or_int(obj) or isComplex(obj)
+
+
+def isStr(obj):
+ import six
+
+ return isinstance(obj, (str, six.text_type))
+
+
+def isList(obj):
+ return type(obj) is list
+
+
+def isTuple(obj):
+ return type(obj) is tuple
+
+
+def isArray(obj):
+ """a numpy array ?"""
+ import numpy as NP
+ _np_arr = NP.ndarray
+ return type(obj) is _np_arr
+
+
+def isSequence(obj):
+ """a sequence (allow iteration, not a string) ?"""
+ return isList(obj) or isTuple(obj) or isArray(obj)
+
+
+def isASSD(obj):
+ from .P_ASSD import ASSD
+
+ return isinstance(obj, ASSD)
+
+
+def forceList(obj):
+ """Retourne `obj` si c'est une liste ou un tuple,
+ sinon retourne [obj,] (en tant que list).
+ """
+ if not isSequence(obj):
+ obj = [
+ obj,
+ ]
+ return list(obj)
+
+
+def forceTuple(obj):
+ """Return `obj` as a tuple."""
+ return tuple(forceList(obj))
+
+
+# backward compatibility
+from warnings import warn
+
+
+def isEnum(obj):
+ """same as isSequence"""
+ warn("'isEnum' is deprecated, use 'isSequence'", DeprecationWarning, stacklevel=2)
+ return isSequence(obj)
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module contient des fonctions utilitaires
+"""
+
+# Modules Python
+
+
+from builtins import str
+from builtins import object
+import sys
+
+# Modules EFICAS
+from Accas.processing.P_Exception import AsException
+from Accas.processing.P_types import isInt, isFloat, isComplex, isStr, isSequence, isASSD
+from Accas.processing.strfunc import getEncoding
+
+SEP = "_"
+
+try:
+ cur_frame = sys._getframe
+except:
+ print("pb avec la version de python pour cur_frame = sys._getframe")
+
+
+def calleeWhere(niveau=4):
+ """
+ recupere la position de l appel
+ """
+ frame = sys._getframe(niveau)
+ if frame == None:
+ return 0, "inconnu", 0, {}
+ try:
+ # Python 2.7 compile function does not accept unicode filename, so we encode it
+ # with the current locale encoding in order to have a correct traceback.
+ # Here, we convert it back to unicode.
+ import six
+
+ filename = six.text_type(frame.f_code.co_filename, getEncoding())
+ return frame.fLineNo, filename, frame.f_code.co_firstlineno, frame.f_locals
+ except:
+ return 0, "inconnu", 0, {}
+
+
+def AsType(a):
+ """
+ Retourne le type d'un concept (a) à partir
+ des caractéristiques de l'objet Python
+ """
+ if isSequence(a):
+ return AsType(a[0])
+ if isASSD(a):
+ return type(a)
+ if isFloat(a):
+ return "R"
+ if isInt(a):
+ return "I"
+ if isStr(a):
+ return "TXM"
+ if a == None:
+ return None
+ raise AsException("type inconnu: %r %s" % (a, type(a)))
+
+
+def prbanner(s):
+ print(("*" * (len(s) + 10)))
+ print(("*" * 5 + s + "*" * 5))
+ print(("*" * (len(s) + 10)))
+
+
+def repr_float(valeur):
+ """
+ Cette fonction représente le réel valeur comme une chaine de caractères
+ sous forme mantisse exposant si nécessaire cad si le nombre contient plus de
+ 5 caractères
+ NB : valeur est un réel au format Python ou une chaine de caractères représentant un réel
+ """
+ if type(valeur) == str:
+ valeur = eval(valeur)
+ if valeur == 0.0:
+ return "0.0"
+ if abs(valeur) > 1.0:
+ if abs(valeur) < 10000.0:
+ return repr(valeur)
+ else:
+ if abs(valeur) > 0.01:
+ return repr(valeur)
+ t = repr(valeur)
+ if t.find("e") != -1 or t.find("E") != -1:
+ # le réel est déjà sous forme mantisse exposant !
+ # --> on remplace e par E
+ t = t.replace("e", "E")
+ # --> on doit encore vérifier que la mantisse contient bien un '.'
+ if t.find(".") != -1:
+ return t
+ else:
+ # -->il faut rajouter le point avant le E
+ t = t.replace("E", ".E")
+ return t
+ s = ""
+ neg = 0
+ if t[0] == "-":
+ s = s + t[0]
+ t = t[1:]
+ cpt = 0
+ if t[0].atof() == 0.0:
+ # réel plus petit que 1
+ neg = 1
+ t = t[2:]
+ cpt = 1
+ while t[0].atof() == 0.0:
+ cpt = cpt + 1
+ t = t[1:]
+ s = s + t[0] + "."
+ for c in t[1:]:
+ s = s + c
+ else:
+ # réel plus grand que 1
+ s = s + t[0] + "."
+ if t[1:].atof() == 0.0:
+ l = t[1:].split(".")
+ cpt = len(l[0])
+ else:
+ r = 0
+ pt = 0
+ for c in t[1:]:
+ r = r + 1
+ if c != ".":
+ if pt != 1:
+ cpt = cpt + 1
+ s = s + c
+ else:
+ pt = 1
+ if r + 1 == len(t) or t[r + 1 :].atof() == 0.0:
+ break
+ s = s + "E" + neg * "-" + repr(cpt)
+ return s
+
+
+def importObject(uri):
+ """Load and return a python object (class, function...).
+ Its `uri` looks like "mainpkg.subpkg.module.object", this means
+ that "mainpkg.subpkg.module" is imported and "object" is
+ the object to return.
+ """
+ path = uri.split(".")
+ modname = ".".join(path[:-1])
+ if len(modname) == 0:
+ raise ImportError("invalid uri: %s" % uri)
+ mod = object = "?"
+ objname = path[-1]
+ try:
+ __import__(modname)
+ mod = sys.modules[modname]
+ except ImportError as err:
+ raise ImportError("can not import module : %s (%s)" % (modname, str(err)))
+ try:
+ object = getattr(mod, objname)
+ except AttributeError as err:
+ raise AttributeError(
+ "object (%s) not found in module '%s'. "
+ "Module content is: %s" % (objname, modname, tuple(dir(mod)))
+ )
+ return object
+
+
+class Singleton(object):
+
+ """Singleton implementation in python."""
+
+ # add _singleton_id attribute to the class to be independant of import
+ # path used
+ __inst = {}
+
+ def __new__(cls, *args, **kargs):
+ cls_id = getattr(cls, "_singleton_id", cls)
+ if Singleton.__inst.get(cls_id) is None:
+ Singleton.__inst[cls_id] = object.__new__(cls)
+ return Singleton.__inst[cls_id]
+
+
+class Enum(object):
+
+ """
+ This class emulates a C-like enum for python. It is initialized with a list
+ of strings to be used as the enum symbolic keys. The enum values are automatically
+ generated as sequencing integer starting at 0.
+ """
+
+ def __init__(self, *keys):
+ """Constructor"""
+ self._dict_keys = {}
+ for inum, key in enumerate(keys):
+ setattr(self, key, 2**inum)
+ self._dict_keys[2**inum] = key
+
+ def exists(self, value):
+ """Tell if value is in the enumeration"""
+ return self.getId(value) is not None
+
+ def getId(self, value):
+ """Return the key associated to the given value"""
+ return self._dict_keys.get(value, None)
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce package fournit les classes de base d'EFICAS.
+ Ces classes permettent d'effectuer les operations basiques :
+
+ - la creation
+ - la verification des definitions
+ - la gestion d'objets de type OBJECT a partir d'une definition de type ENTITE
+"""
+# Avant toutes choses, on met le module context dans le global de l'interpreteur (__builtin__)
+# sous le nom CONTEXT afin d'avoir acces aux fonctions
+# getCurrentStep, setCurrentStep et unsetCurrentStep de n'importe ou
+
+
+from Accas.processing import context
+
+import builtins
+builtins.CONTEXT = context
+
+# Only the first MAXSIZE objects will be checked
+# This is used for the number of MCFACT, the number of MCSIMP and the number of
+# values in a MCSIMP.
+
+MAXSIZE = 500
+MAXSIZE_MSGCHK = " <I> Only the first {0} occurrences (total: {1}) have been checked."
+MAXSIZE_MSGKEEP = " <I> Only the first {0} occurrences (total: {1}) have been printed."
--- /dev/null
+mv N_ASSD.py P_ASSD.py
+mv N_BLOC.py P_BLOC.py
+mv N_CONVERT.py P_CONVERT.py
+mv N_CO.py P_CO.py
+mv N_CR.py P_CR.py
+mv N_ENTITE.py P_ENTITE.py
+mv N_ETAPE.py P_ETAPE.py
+mv N_Exception.py P_Exception.py
+mv N_FACT.py P_FACT.py
+mv N_FONCTION.py P_FONCTION.py
+mv N_FORM_ETAPE.py P_FORM_ETAPE.py
+mv N_FORM.py P_FORM.py
+mv N__F.py P__F.py
+mv N_GEOM.py P_GEOM.py
+mv N_JDC_CATA.py P_JDC_CATA.py
+mv N_JDC.py P_JDC.py
+mv N_LASSD.py P_LASSD.py
+mv N_MACRO_ETAPE.py P_MACRO_ETAPE.py
+mv N_MACRO.py P_MACRO.py
+mv N_MCBLOC.py P_MCBLOC.py
+mv N_MCCOMPO.py P_MCCOMPO.py
+mv N_MCFACT.py P_MCFACT.py
+mv N_MCLIST.py P_MCLIST.py
+mv N_MCSIMP.py P_MCSIMP.py
+mv N_OBJECT.py P_OBJECT.py
+mv N_OPER.py P_OPER.py
+mv N_OPS.py P_OPS.py
+mv N_PROC_ETAPE.py P_PROC_ETAPE.py
+mv N_PROC.py P_PROC.py
+mv N_REGLE.py P_REGLE.py
+mv N_SENSIBILITE.py P_SENSIBILITE.py
+mv N_SIMP.py P_SIMP.py
+mv N_TUPLE.py P_TUPLE.py
+mv N_types.py P_types.py
+mv N_UserASSDMultiple.py P_UserASSDMultiple.py
+mv N_UserASSD.py P_UserASSD.py
+mv N_utils.py P_utils.py
+mv N_VALIDATOR.py P_VALIDATOR.py
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+_root = None
+_cata = None
+_jdc = None
+debug = 0
+
+# Le "current step" est l'etape courante.
+# Une macro se declare etape courante dans sa methode Build avant de construire
+# ses etapes filles ou dans BuildExec avant de les executer.
+# Les etapes simples le font aussi : dans Execute et BuildExec.
+# (Build ne fait rien pour une etape)
+
+
+def setCurrentStep(step):
+ """
+ Fonction qui permet de changer la valeur de l'etape courante
+ """
+ global _root
+ if _root:
+ raise Exception("Impossible d'affecter _root. Il devrait valoir None")
+ _root = step
+
+
+def getCurrentStep():
+ """
+ Fonction qui permet d'obtenir la valeur de l'etape courante
+ """
+ return _root
+
+
+def unsetCurrentStep():
+ """
+ Fonction qui permet de remettre a None l'etape courante
+ """
+ global _root
+ _root = None
+
+
+def setCurrentCata(cata):
+ """
+ Fonction qui permet de changer l'objet catalogue courant
+ """
+ global _cata
+ if _cata:
+ raise Exception("Impossible d'affecter _cata. Il devrait valoir None")
+ _cata = cata
+
+
+def getCurrentCata():
+ """
+ Fonction qui retourne l'objet catalogue courant
+ """
+ return _cata
+
+
+def unsetCurrentCata():
+ """
+ Fonction qui permet de remettre a None le catalogue courant
+ """
+ global _cata
+ _cata = None
+
+
+def getCurrentJdC():
+ """
+ Fonction qui retourne l'objet JDC courant
+ """
+ return _jdc
+
+
+def setCurrentJdC(jdc):
+ """
+ Fonction qui permet de changer l'objet JDC courant
+ """
+ global _jdc
+ if _jdc:
+ raise Exception("Impossible d'affecter _jdc. Il devrait valoir None")
+ _jdc = jdc
+
+
+def unsetCurrentJdC():
+ """
+ Fonction qui permet de remettre a None le JDC courant
+ """
+ global _jdc
+ _jdc = None
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+
+"""
+ Ce module sert à nommer les concepts produits par les commandes.
+ Le nom du concept est obtenu en appelant la fonction getNomConceptResultat
+ du module avec le nom de la commande en argument.
+
+ Cette fonction parcourt le source dans lequel la commande se trouve, parse le
+ fichier et retrouve le nom du concept qui se trouve à gauche du signe = précédant
+ le nom de la commande.
+
+ Cette fonction utilise la fonction cur_frame du module P_utils qui retourne la frame
+ d'exécution Python située 2 niveaux au-dessus. C'est à partir de cette frame que
+ l'on retrouve le fichier source et le numéro de ligne où se trouve l'appel à la commande.
+
+"""
+
+# Modules Python
+import re
+import linecache
+import sys
+from functools import partial
+
+# Modules EFICAS
+from Accas.processing import P_utils
+from Accas.processing.strfunc import getEncoding
+
+regex1 = "=?\s*%s\s*\("
+# commentaire standard precede d'un nombre quelconque de blancs (pas
+# multiligne)
+pattern_comment = re.compile(r"^\s*#.*")
+
+
+def _getNomConceptResultat(ope, level=2):
+ """
+ Cette fonction recherche dans la pile des appels, l'appel à la commande
+ qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)).
+ On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne
+ dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename).
+ A partir de là, on récupère la ligne de source avec linecache.getline
+ et on vérifie que cette ligne correspond véritablement à l'appel.
+
+ En effet, lorsque les commandes tiennent sur plusieurs lignes, on retrouve
+ la dernière ligne. Il faut donc remonter dans le source jusqu'à la première
+ ligne.
+
+ Enfin la fonction evalnom forme un nom acceptable lorsque le concept est un
+ élément d'une liste, par exemple.
+
+ """
+ f = P_utils.cur_frame(level)
+ lineno = f.f_lineno # XXX Too bad if -O is used
+ # lineno = f_lineno(f) # Ne marche pas toujours
+ co = f.f_code
+ if sys.version_info >= (3, 0):
+ filename = co.co_filename
+ else:
+ import six
+
+ filename = six.text_type(co.co_filename, getEncoding())
+ name = co.co_name
+ # pattern pour identifier le debut de la commande
+ pattern_oper = re.compile(regex1 % ope)
+
+ list = []
+ while lineno > 0:
+ line = linecache.getline(filename, lineno)
+ lineno = lineno - 1
+ if pattern_comment.match(line):
+ continue
+ list.append(line)
+ if pattern_oper.search(line):
+ l = pattern_oper.split(line)
+ list.reverse()
+ # On suppose que le concept resultat a bien ete
+ # isole en tete de la ligne de source
+ m = evalnom(l[0].strip(), f.f_locals)
+ # print "NOMS ",m
+ if m != []:
+ return m[-1]
+ else:
+ return ""
+ # print "appel inconnu"
+ return ""
+
+
+def evalnom(text, d):
+ """
+ Retourne un nom pour le concept resultat identifie par text
+ Pour obtenir ce nom il y a plusieurs possibilites :
+ 1. text est un identificateur python c'est le nom du concept
+ 2. text est un element d'une liste on construit le nom en
+ evaluant la partie indice dans le contexte de l'appelant d
+ """
+ l = re.split("([\[\]]+)", text)
+ if l[-1] == "":
+ l = l[:-1]
+ lll = []
+ i = 0
+ while i < len(l):
+ s = l[i]
+ ll = re.split("[ ,]+", s)
+ if ll[0] == "":
+ ll = ll[1:]
+ if len(ll) == 1:
+ id0 = ll[0]
+ else:
+ lll = lll + ll[0:-1]
+ id0 = ll[-1]
+ if i + 1 < len(l) and l[i + 1] == "[": # le nom est suivi d un subscript
+ sub = l[i + 2]
+ nom = id0 + "_" + str(eval(sub, d))
+ i = i + 4
+ else:
+ nom = id0
+ i = i + 1
+ lll.append(nom)
+ return lll
+
+
+def f_lineno(f):
+ """
+ Calcule le numero de ligne courant
+ Devrait marcher meme avec -O
+ Semble ne pas marcher en présence de tuples longs
+ """
+ c = f.f_code
+ if not hasattr(c, "co_lnotab"):
+ return f.f_lineno
+ tab = c.co_lnotab
+ line = c.co_firstlineno
+ stopat = f.f_lasti
+ addr = 0
+ for i in range(0, len(tab), 2):
+ addr = addr + ord(tab[i])
+ if addr > stopat:
+ break
+ line = line + ord(tab[i + 1])
+ return line
+
+
+class NamingSystem(P_utils.Singleton):
+
+ """Cette classe définit un système de nommage dynamique des concepts."""
+
+ _singleton_id = "nommage.NamingSystem"
+
+ def __init__(self):
+ """Initialisation"""
+ self.native = _getNomConceptResultat
+ self.useGlobalNaming()
+
+ def useNamingFunction(self, function):
+ """Utilise une fonction particulière de nommage."""
+ self.naming_func = function
+
+ def useGlobalNaming(self):
+ """Utilise la fonction native de nommage."""
+ self.naming_func = partial(self.native, level=3)
+
+ def __call__(self, *args):
+ """Appel à la fonction de nommage."""
+ return self.naming_func(*args)
+
+
+getNomConceptResultat = NamingSystem()
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+"""Module rassemblant des fonctions utilitaires de manipulations
+de chaines de caractères
+"""
+
+
+import locale
+import six
+
+_encoding = None
+
+
+def getEncoding():
+ """Return local encoding"""
+ global _encoding
+ if _encoding is None:
+ try:
+ _encoding = locale.getpreferredencoding() or "ascii"
+ except locale.Error:
+ _encoding = "ascii"
+ return _encoding
+
+
+def toUnicode(string):
+ """Try to convert string into a unicode string."""
+ if type(string) is six.text_type:
+ return string
+ elif type(string) is dict:
+ new = {}
+ for k, v in list(string.items()):
+ new[k] = toUnicode(v)
+ return new
+ elif type(string) is list:
+ return [toUnicode(elt) for elt in string]
+ elif type(string) is tuple:
+ return tuple(toUnicode(list(string)))
+ elif type(string) is not str:
+ return string
+ assert type(string) is str, "unsupported object: %s" % string
+ for encoding in ("utf-8", "iso-8859-15", "cp1252"):
+ try:
+ s = six.text_type(string, encoding)
+ return s
+ except UnicodeDecodeError:
+ pass
+ return six.text_type(string, "utf-8", "replace")
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+# Installation de tous les fichiers Python du repertoire et des sous-repertoires (sauf CVS)
+install ( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ DESTINATION ${CMAKE_INSTALL_PREFIX}
+ FILES_MATCHING PATTERN *.py
+ PATTERN CVS EXCLUDE
+ )
+
+
+### Local Variables:
+### mode: cmake
+### End:
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+from builtins import object
+
+
+class AU_MOINS_UN(object):
+
+ """
+ La regle AU_MOINS_UN verifie que l'on trouve au moins un des mots-cles
+ de la regle parmi les arguments d'un OBJECT.
+
+ Ces arguments sont transmis a la regle pour Accas.validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
+ """
+
+ def verif(self, args):
+ """
+ La methode verif verifie que l'on trouve au moins un des mos-cles
+ de la liste self.mcs parmi les elements de args
+
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ""
+ count = 0
+ args = self.listeToDico(args)
+ for mc in self.mcs:
+ if mc in args:
+ count = count + 1
+ if count == 0:
+ text = "- Il faut au moins un mot-cle parmi : " + repr(self.mcs) + "\n"
+ return text, 0
+ return text, 1
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+from builtins import object
+
+class AU_PLUS_UN(object):
+
+ """
+ La regle verifie que l'on trouve 1 (au plus) des mots-cles
+ de la regle parmi les arguments d'un OBJECT.
+
+ Ces arguments sont transmis a la regle pour Accas.validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
+ """
+
+ def verif(self, args):
+ """
+ La methode verif verifie que l'on trouve 1 (au plus) des mos-cles
+ de la liste self.mcs parmi les elements de args
+
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ""
+ count = 0
+ args = self.listeToDico(args)
+ for mc in self.mcs:
+ count = count + args.get(mc, 0)
+ if count > 1:
+ text = (
+ "- Il ne faut qu'un mot-cle (au plus) parmi : " + repr(self.mcs) + "\n"
+ )
+ return text, 0
+ return text, 1
+
+ def listeToDico(self, args):
+ if type(args) is dict:
+ return args
+ elif type(args) in (list, tuple):
+ dico = {}
+ for arg in args:
+ dico[arg] = dico.get(arg, 0) + 1
+ return dico
+ else:
+ raise Exception("Erreur ce n'est ni un dictionnaire ni une liste %s" % args)
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+from builtins import str
+from builtins import object
+
+
+class A_CLASSER(object):
+
+ """
+ La regle A_CLASSER verifie que ...
+
+ """
+
+ def __init__(self, *args):
+ if len(args) > 2:
+ print("Erreur a la creation de la regle A_CLASSER(%s)" % str(args))
+ return
+ self.args = args
+ if type(args[0]) == tuple:
+ self.args0 = args[0]
+ elif type(args[0]) == str:
+ self.args0 = (args[0],)
+ else:
+ print(
+ "Le premier argument de : %s doit etre un tuple ou une chaine"
+ % str(args)
+ )
+ if type(args[1]) == tuple:
+ self.args1 = args[1]
+ elif type(args[1]) == str:
+ self.args1 = (args[1],)
+ else:
+ print(
+ "Le deuxieme argument de : %s doit etre un tuple ou une chaine"
+ % str(args)
+ )
+ # creation de la liste des mcs
+ liste = []
+ liste.extend(self.args0)
+ liste.extend(self.args1)
+ self.mcs = liste
+ self.initCouplesPermis()
+
+ def initCouplesPermis(self):
+ """Cree la liste des couples permis parmi les self.args, cad pour chaque element
+ de self.args0 cree tous les couples possibles avec un element de self.args1"""
+ liste = []
+ for arg0 in self.args0:
+ for arg1 in self.args1:
+ liste.append((arg0, arg1))
+ self.liste_couples = liste
+
+ def verif(self, args):
+ """
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # creation de la liste des couples presents dans le fichier de
+ # commandes
+ l_couples = []
+ couple = []
+ text = ""
+ test = 1
+ for nom in args:
+ if nom in self.mcs:
+ couple.append(nom)
+ if len(couple) == 2:
+ l_couples.append(tuple(couple))
+ couple = [
+ nom,
+ ]
+ if len(couple) > 0:
+ l_couples.append(tuple(couple))
+ # l_couples peut etre vide si l'on n'a pas reussi a trouver au moins un
+ # element de self.mcs
+ if len(l_couples) == 0:
+ message = (
+ "- Il faut qu'au moins un objet de la liste : %s soit suivi d'au moins un objet de la liste %s : "
+ % (self.args0, self.args1)
+ )
+ return message, 0
+ # A ce stade, on a trouve des couples : il faut verifier qu'ils sont
+ # tous licites
+ num = 0
+ for couple in l_couples:
+ num = num + 1
+ if len(couple) == 1:
+ # on a un 'faux' couple
+ if couple[0] not in self.args1:
+ text = (
+ text
+ + "- L'objet : %s doit etre suivi d'un objet de la liste : %r\n"
+ % (couple[0], self.args1)
+ )
+ test = 0
+ else:
+ if num > 1:
+ # ce n'est pas le seul couple --> licite
+ break
+ else:
+ text = (
+ text
+ + "- L'objet : %s doit etre precede d'un objet de la liste : %r\n"
+ % (couple[0], self.args0)
+ )
+ test = 0
+ elif couple not in self.liste_couples:
+ text = text + "- L'objet : %s ne peut etre suivi de : %s\n" % (
+ couple[0],
+ couple[1],
+ )
+ test = 0
+ return text, test
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+from builtins import object
+
+class ENSEMBLE(object):
+
+ """
+ La regle verifie que si un mot-cle de self.mcs est present
+ parmi les elements de args tous les autres doivent etre presents.
+
+ Ces arguments sont transmis a la regle pour Accas.validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
+ """
+
+ def verif(self, args):
+ """
+ La methode verif effectue la verification specifique a la regle.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents, il doit etre egal a la liste
+ # figurant dans la regle
+ text = ""
+ test = 1
+ args = self.listeToDico(args)
+ pivot = None
+ for mc in self.mcs:
+ if mc in args:
+ pivot = mc
+ break
+ if pivot:
+ for mc in self.mcs:
+ if mc != pivot:
+ if not mc in args:
+ text = (
+ text
+ + "- "
+ + pivot
+ + " etant present, "
+ + mc
+ + " doit etre present"
+ + "\n"
+ )
+ test = 0
+ return text, test
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient la classe mixin ETAPE qui porte les methodes
+ necessaires pour realiser la Accas.validation d'un objet de type ETAPE
+ derive de OBJECT.
+
+ Une classe mixin porte principalement des traitements et est
+ utilisee par heritage multiple pour composer les traitements.
+"""
+
+# Modules Python
+import types
+import sys
+import traceback
+import re
+
+# Modules EFICAS
+from . import V_MCCOMPO
+from Accas.processing import MAXSIZE, MAXSIZE_MSGCHK
+from Accas.processing.P_Exception import AsException
+from Accas.processing.P_utils import AsType
+from Accas.extensions.eficas_translation import tr
+
+
+class ETAPE(V_MCCOMPO.MCCOMPO):
+
+ """ """
+
+ def validChild(self):
+ """Cette methode teste la validite des mots cles de l'etape"""
+ for child in self.mcListe:
+ if not child.isValid():
+ return 0
+ return 1
+
+ def validRegles(self, cr):
+ """Cette methode teste la validite des regles de l'etape"""
+ text_erreurs, test_regles = self.verifRegles()
+ if not test_regles:
+ if cr == "oui":
+ self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs)
+ return 0
+ return 1
+
+ def validSdnom(self, cr):
+ """Cette methode teste la validite du nom du concept produit par l'etape"""
+ valid = 1
+ if self.sd.nom != None:
+ if self.sd.nom.find("sansnom") != -1:
+ # la SD est 'sansnom' : --> erreur
+ if cr == "oui":
+ self.cr.fatal(("object must have a name"))
+ valid = 0
+ elif re.search("^SD_[0-9]*$", self.sd.nom):
+ # la SD est 'SD_' cad son nom = son id donc pas de nom donne
+ # par utilisateur : --> erreur
+ if cr == "oui":
+ self.cr.fatal(("invalid name ('SD_' is a reserved keyword)"))
+ valid = 0
+ return valid
+
+ def getValid(self):
+ if hasattr(self, "valid"):
+ return self.valid
+ else:
+ self.valid = None
+ return None
+
+ def setValid(self, valid):
+ old_valid = self.getValid()
+ self.valid = valid
+ self.state = "unchanged"
+ if not old_valid or old_valid != self.valid:
+ self.initModifUp()
+
+ def isValid(self, sd="oui", cr="non"):
+ """
+ Methode pour verifier la validite de l'objet ETAPE. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
+ de sd et de cr.
+
+ Si cr vaut oui elle cree en plus un compte-rendu.
+
+ Cette methode a plusieurs fonctions :
+
+ - mettre a jour l'etat de self (update)
+
+ - retourner un indicateur de validite 0=non, 1=oui
+
+ - produire un compte-rendu : self.cr
+
+ """
+ # if CONTEXT.debug:
+ # if 1 :
+ # print(("ETAPE.isValid ", self.nom, self.state))
+ # import traceback
+ # traceback.print_stack()
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ valid = self.validChild()
+ valid = valid * self.validRegles(cr)
+ if cr == "oui":
+ if not hasattr(self, "cr"):
+ from Accas.processing.P_CR import CR
+
+ self.cr = CR()
+ else:
+ self.cr.purge()
+ if self.reste_val != {}:
+ if cr == "oui":
+ self.cr.fatal(
+ "unknown keywords : %s" % ",".join(list(self.reste_val.keys()))
+ )
+ valid = 0
+
+ if sd == "non":
+ # Dans ce cas, on ne teste qu'une validite partielle (sans tests sur le concept produit)
+ # Consequence : on ne change pas l'etat ni l'attribut valid, on retourne simplement
+ # l'indicateur de validite valid
+ return valid
+
+ if self.definition.reentrant == "n" and self.reuse:
+ # Il ne peut y avoir de concept reutilise avec un OPER non
+ # reentrant
+ if cr == "oui":
+ self.cr.fatal("Operateur non reentrant : ne pas utiliser reuse")
+ valid = 0
+
+ if self.sd == None:
+ # Le concept produit n'existe pas => erreur
+ if cr == "oui":
+ self.cr.fatal(("Concept is not defined"))
+ valid = 0
+ else:
+ valid = valid * self.validSdnom(cr)
+
+ if valid:
+ valid = self.updateSdprod(cr)
+
+ self.setValid(valid)
+
+ return self.valid
+
+ def updateSdprod(self, cr="non"):
+ """
+ Cette methode met a jour le concept produit en fonction des conditions initiales :
+
+ 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None)
+
+ 2. Le concept retourne n existait pas (self.sd == None)
+
+ 3. Le concept retourne existait. On change alors son type ou on le supprime
+
+ En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1
+ """
+ sd_prod = self.definition.sd_prod
+ if type(sd_prod) == types.FunctionType: # Type de concept retourne calcule
+ d = self.creeDictValeurs(self.mcListe)
+ try:
+ sd_prod = sd_prod(*(), **d)
+ except:
+ # Erreur pendant le calcul du type retourne
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.sd = None
+ if cr == "oui":
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ self.cr.fatal(
+ "unable to affect type to concept\n %s" % " ".join(l[2:])
+ )
+ return 0
+ # on teste maintenant si la SD est reutilisee ou s'il faut la
+ # creer
+ valid = 1
+ if self.reuse:
+ if AsType(self.reuse) != sd_prod:
+ if cr == "oui":
+ self.cr.fatal(
+ ("Type de concept reutilise incompatible avec type produit")
+ )
+ valid = 0
+ if self.sdnom != "":
+ if self.sdnom[0] != "_" and self.reuse.nom != self.sdnom:
+ # Le nom de la variable de retour (self.sdnom) doit etre le
+ # meme que celui du concept reutilise (self.reuse.nom)
+ if cr == "oui":
+ self.cr.fatal(
+ "Concept reutilise : le nom de la variable de retour devrait etre %s et non %s"
+ % (self.reuse.nom, self.sdnom)
+ )
+ valid = 0
+ if valid:
+ self.sd = self.reuse
+ else:
+ if sd_prod == None: # Pas de concept retourne
+ # Que faut il faire de l eventuel ancien sd ?
+ self.sd = None
+ else:
+ if self.sd:
+ # Un sd existe deja, on change son type
+ if CONTEXT.debug:
+ print(("changement de type:", self.sd, sd_prod))
+ if self.sd.__class__ != sd_prod:
+ self.sd.changeType(sd_prod)
+ else:
+ # Le sd n existait pas , on ne le cree pas
+ if cr == "oui":
+ self.cr.fatal("Concept retourne non defini")
+ valid = 0
+ if self.definition.reentrant == "o":
+ if cr == "oui":
+ self.cr.fatal(
+ (
+ "Commande obligatoirement reentrante : specifier reuse=concept"
+ )
+ )
+ valid = 0
+ return valid
+
+ def report(self):
+ """
+ Methode pour generation d un rapport de validite
+ """
+ self.cr = self.CR(
+ debut="Command : "
+ + tr(self.nom)
+ + " line : "
+ + repr(self.appel[0])
+ + " file : "
+ + repr(self.appel[1]),
+ fin="End Command : " + tr(self.nom),
+ )
+ self.state = "modified"
+ try:
+ self.isValid(cr="oui")
+ except AsException as e:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.cr.fatal(
+ "Command : %s line : %r file : %r %s"
+ % (tr(self.nom), self.appel[0], self.appel[1], e)
+ )
+ i = 0
+ for child in self.mcListe:
+ i += 1
+ if i > MAXSIZE:
+ print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mcListe)))
+ break
+ self.cr.add(child.report())
+ return self.cr
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+from builtins import object
+
+
+class EXCLUS(object):
+
+ """
+ La regle verifie qu'un seul mot-cle de self.mcs est present
+ parmi les elements de args.
+
+ Ces arguments sont transmis a la regle pour Accas.validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
+ """
+
+ def verif(self, args):
+ """
+ La methode verif effectue la verification specifique a la regle.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ""
+ count = 0
+ args = self.listeToDico(args)
+ for mc in self.mcs:
+ if mc in args:
+ count = count + 1
+ if count > 1:
+ text = "- Il ne faut qu un mot cle parmi : " + repr(self.mcs) + "\n"
+ return text, 0
+ return text, 1
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient la classe mixin JDC qui porte les methodes
+ necessaires pour realiser la Accas.validation d'un objet de type JDC
+ derive de OBJECT.
+
+ Une classe mixin porte principalement des traitements et est
+ utilisee par heritage multiple pour composer les traitements.
+"""
+
+# Modules EFICAS
+from . import V_MCCOMPO
+from Accas.processing.P_Exception import AsException
+from Accas.processing.P_utils import AsType
+
+
+class JDC(V_MCCOMPO.MCCOMPO):
+
+ """ """
+
+ def report(self):
+ """
+ Methode pour generation d un rapport de validite
+ """
+ self.cr.purge()
+ # self.cr.debut = "DEBUT CR Accas.validation : " + self.nom
+ # self.cr.fin = "FIN CR Accas.validation :" + self.nom
+ self.cr.debut = "BEGIN Accas.validation report : " + self.nom
+ self.cr.fin = "END Accas.validation report :" + self.nom
+ for e in self.etapes:
+ if e.isActif():
+ self.cr.add(e.report())
+ self.state = "modified"
+ self.isValid(cr="oui")
+ return self.cr
+
+ def isValid(self, cr="non"):
+ """
+ Methode booleenne qui retourne 0 si le JDC est invalide, 1 sinon
+ """
+ # FR : on prend en compte l'etat du JDC ('unchanged','modified','undetermined')
+ # afin d'accelerer le test de validite du JDC
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ valid = 1
+ texte, test = self.verifRegles()
+ if test == 0:
+ if cr == "oui":
+ if texte != "" and (" ".strip(texte) == ""):
+ self.cr.fatal(texte)
+ else:
+ self.cr.fatal(" ".strip(texte))
+ valid = 0
+ if valid:
+ for e in self.etapes:
+ if not e.isActif():
+ continue
+ if not e.isValid():
+ valid = 0
+ break
+ self.state = "unchanged"
+ self.valid = valid
+ return self.valid
+
+ def getValid(self, cr="non"):
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ return self.isValid()
+
+ def verifRegles(self):
+ """
+ Effectue la verification de validite des regles du jeu de commandes
+ """
+ noms_etapes = [etape.nom for etape in self.etapes]
+ texte_global = ""
+ test_global = 1
+ for regle in self.regles:
+ texte, test = regle.verif(noms_etapes)
+ texte_global = texte_global + texte
+ test_global = test_global * test
+ return texte_global, test_global
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient la classe mixin MACRO_ETAPE qui porte les methodes
+ necessaires pour realiser la Accas.validation d'un objet de type MACRO_ETAPE
+ derive de OBJECT.
+
+ Une classe mixin porte principalement des traitements et est
+ utilisee par heritage multiple pour composer les traitements.
+"""
+
+# Modules Python
+import types
+import sys
+import traceback
+
+# Modules EFICAS
+from . import V_MCCOMPO
+from . import V_ETAPE
+from Accas.processing.P_Exception import AsException
+from Accas.processing.P_utils import AsType
+
+
+class MACRO_ETAPE(V_ETAPE.ETAPE):
+
+ """ """
+
+ def isValid(self, sd="oui", cr="non"):
+ """
+ Methode pour verifier la validite de l'objet ETAPE. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
+ de sd et de cr.
+
+ Si cr vaut oui elle cree en plus un compte-rendu.
+
+ Cette methode a plusieurs fonctions :
+
+ - mettre a jour l'etat de self (update)
+
+ - retourner un indicateur de validite 0=non, 1=oui
+
+ - produire un compte-rendu : self.cr
+
+ """
+ if CONTEXT.debug:
+ print(("ETAPE.isValid ", self.nom))
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ valid = 1
+ # On marque les concepts CO pour verification ulterieure de leur
+ # bonne utilisation
+ l = self.getAllCo()
+ # On verifie que les concepts CO sont bien passes par typeSDProd
+ for c in l:
+ # if c.etape is self.parent:
+ if c.isTypCO() != 2:
+ # le concept est propriete de l'etape parent
+ # Il n'a pas ete transforme par typeSDProd
+ # Cette situation est interdite
+ # Pb: La macro-commande a passe le concept a une commande
+ # (macro ?) mal definie
+ if cr == "oui":
+ self.cr.fatal(
+ "Macro-commande mal definie : le concept n'a pas ete type par un appel a typeSDProd pour %s"
+ % c.nom
+ )
+ valid = 0
+
+ valid = valid * self.validChild()
+ valid = valid * self.validRegles(cr)
+
+ if self.reste_val != {}:
+ if cr == "oui":
+ self.cr.fatal(
+ "unknown keyword : %s" % ",".join(list(self.reste_val.keys()))
+ )
+ valid = 0
+
+ if sd == "non":
+ # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'etat de self
+ # on retourne simplement l'indicateur valid
+ return valid
+
+ if self.sd != None:
+ valid = valid * self.validSdnom(cr)
+
+ if self.definition.reentrant == "n" and self.reuse:
+ # Il ne peut y avoir de concept reutilise avec une MACRO non
+ # reentrante
+ if cr == "oui":
+ self.cr.fatal(
+ "Macro-commande non reentrante : ne pas utiliser reuse"
+ )
+ valid = 0
+
+ if valid:
+ valid = self.updateSdprod(cr)
+
+ # Si la macro comprend des etapes internes, on teste leur validite
+ for e in self.etapes:
+ if not e.isValid():
+ valid = 0
+ break
+
+ self.setValid(valid)
+
+ return self.valid
+
+ def updateSdprod(self, cr="non"):
+ """
+ Cette methode met a jour le concept produit en fonction des conditions initiales :
+
+ 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None)
+
+ 2. Le concept retourne n existait pas (self.sd == None)
+
+ 3. Le concept retourne existait. On change alors son type ou on le supprime
+
+ En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1
+ """
+ sd_prod = self.definition.sd_prod
+ # On memorise le type retourne dans l attribut typret
+ self.typret = None
+ if type(sd_prod) == types.FunctionType:
+ # Type de concept retourne calcule
+ d = self.creeDictValeurs(self.mcListe)
+ try:
+ # la sd_prod d'une macro a l'objet lui meme en premier argument
+ # contrairement a une ETAPE ou PROC_ETAPE
+ # Comme sd_prod peut invoquer la methode typeSDProd qui ajoute
+ # les concepts produits dans self.sdprods, il faut le mettre a
+ # zero
+ self.sdprods = []
+ sd_prod = sd_prod(*(self,), **d)
+ except:
+ # Erreur pendant le calcul du type retourne
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.sd = None
+ if cr == "oui":
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ self.cr.fatal(
+ "Impossible d affecter un type au resultat\n%s"
+ % " ".join(l[2:])
+ )
+ return 0
+ # on teste maintenant si la SD est reutilisee ou s'il faut la
+ # creer
+ valid = 1
+ if self.reuse:
+ # Un concept reutilise a ete specifie
+ if AsType(self.reuse) != sd_prod:
+ if cr == "oui":
+ self.cr.fatal(
+ "Type de concept reutilise incompatible avec type produit"
+ )
+ valid = 0
+ if self.sdnom != "":
+ if self.sdnom[0] != "_" and self.reuse.nom != self.sdnom:
+ # Le nom de la variable de retour (self.sdnom) doit etre le
+ # meme que celui du concept reutilise (self.reuse.nom)
+ if cr == "oui":
+ self.cr.fatal(
+ "Concept reutilise : le nom de la variable de retour devrait etre %s et non %s"
+ % (self.reuse.nom, self.sdnom)
+ )
+ valid = 0
+ if valid:
+ self.sd = self.reuse
+ else:
+ # Cas d'un concept non reutilise
+ if sd_prod == None: # Pas de concept retourne
+ # Que faut il faire de l eventuel ancien sd ?
+ self.sd = None
+ else:
+ if self.sd:
+ # Un sd existe deja, on change son type
+ if CONTEXT.debug:
+ print(("changement de type:", self.sd, sd_prod))
+ if self.sd.__class__ != sd_prod:
+ self.sd.changeType(sd_prod)
+ self.typret = sd_prod
+ else:
+ # Le sd n existait pas , on ne le cree pas
+ self.typret = sd_prod
+ if cr == "oui":
+ self.cr.fatal("Concept retourne non defini")
+ valid = 0
+ if self.definition.reentrant == "o":
+ if cr == "oui":
+ self.cr.fatal(
+ "Commande obligatoirement reentrante : specifier reuse=concept"
+ )
+ valid = 0
+ return valid
+
+ def report(self):
+ """
+ Methode pour la generation d un rapport de Accas.validation
+ """
+ V_ETAPE.ETAPE.report(self)
+ for e in self.etapes:
+ self.cr.add(e.report())
+ return self.cr
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient la classe mixin MCBLOC qui porte les methodes
+ necessaires pour realiser la Accas.validation d'un objet de type MCBLOC
+ derive de OBJECT.
+
+ Une classe mixin porte principalement des traitements et est
+ utilisee par heritage multiple pour composer les traitements.
+"""
+
+# Modules EFICAS
+from . import V_MCCOMPO
+
+
+class MCBLOC(V_MCCOMPO.MCCOMPO):
+
+ """
+ Cette classe a un attribut de classe :
+
+ - txt_nat qui sert pour les comptes-rendus lies a cette classe
+ """
+
+ txt_nat = "Bloc :"
+
+ def isValid(self, sd="oui", cr="non"):
+ """
+ Methode pour verifier la validite du MCBLOC. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
+ de sd et de cr.
+
+ Si cr vaut oui elle cree en plus un compte-rendu
+ sd est present pour compatibilite de l'interface mais ne sert pas
+ """
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ valid = 1
+ if hasattr(self, "valid"):
+ old_valid = self.valid
+ else:
+ old_valid = None
+ for child in self.mcListe:
+ if not child.isValid():
+ valid = 0
+ break
+ # Apres avoir verifie la validite de tous les sous-objets, on verifie
+ # la validite des regles
+ text_erreurs, test_regles = self.verifRegles()
+ if not test_regles:
+ if cr == "oui":
+ self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs)
+ valid = 0
+ self.valid = valid
+ self.state = "unchanged"
+ if not old_valid or old_valid != self.valid:
+ self.initModifUp()
+ return self.valid
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient la classe de base MCCOMPO qui sert a factoriser
+ les traitements des objets composites de type OBJECT
+"""
+
+# Modules Python
+
+import os
+import traceback
+
+# Modules EFICAS
+from Accas.processing import MAXSIZE, MAXSIZE_MSGCHK
+from Accas.processing import P_CR
+from Accas.processing.P_Exception import AsException
+
+
+class MCCOMPO(object):
+
+ """
+ L'attribut mcListe a ete cree par une classe derivee de la
+ classe MCCOMPO de processing
+ """
+
+ CR = P_CR.CR
+
+ def __init__(self):
+ self.state = "undetermined"
+ # defini dans les classes derivees
+ self.txt_nat = ""
+
+ def initModifUp(self):
+ """
+ Propage l'etat modifie au parent s'il existe et n'est pas l'objet
+ lui-meme
+ """
+ if self.parent and self.parent != self:
+ self.parent.state = "modified"
+
+ def report(self):
+ """
+ Genere le rapport de Accas.validation de self
+ """
+ self.cr = self.CR()
+ self.cr.debut = self.txt_nat + self.nom
+ self.cr.fin = "END " + self.txt_nat + self.nom
+ i = 0
+ for child in self.mcListe:
+ i += 1
+ if i > MAXSIZE:
+ print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mcListe)))
+ break
+ self.cr.add(child.report())
+ self.state = "modified"
+ try:
+ self.isValid(cr="oui")
+ except AsException as e:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.cr.fatal(" ".join((self.txt_nat, self.nom, str(e))))
+ return self.cr
+
+ def verifRegles(self):
+ """
+ A partir du dictionnaire des mots-cles presents, verifie si les regles
+ de self sont valides ou non.
+
+ Retourne une chaine et un booleen :
+
+ - texte = la chaine contient le message d'erreur de la (les) regle(s) violee(s) ('' si aucune)
+
+ - testglob = booleen 1 si toutes les regles OK, 0 sinon
+ """
+ # On verifie les regles avec les defauts affectes
+ dictionnaire = self.dictMcPresents(restreint="non")
+ texte = [""]
+ testglob = 1
+ for r in self.definition.regles:
+ erreurs, test = r.verif(dictionnaire)
+ testglob = testglob * test
+ if erreurs != "":
+ texte.append(str(erreurs))
+ texte = os.linesep.join(texte)
+ return texte, testglob
+
+ def dictMcPresents(self, restreint="non"):
+ """
+ Retourne le dictionnaire {mocle : objet} construit a partir de self.mcListe
+ Si restreint == 'non' : on ajoute tous les mots-cles simples du catalogue qui ont
+ une valeur par defaut
+ Si restreint == 'oui' : on ne prend que les mots-cles effectivement entres par
+ l'utilisateur (cas de la verification des regles)
+ """
+ dico = {}
+ # on ajoute les couples {nom mot-cle:objet mot-cle} effectivement
+ # presents
+ for v in self.mcListe:
+ if v == None:
+ continue
+ k = v.nom
+ dico[k] = v
+ if restreint == "oui":
+ return dico
+ # Si restreint != 'oui',
+ # on ajoute les couples {nom mot-cle:objet mot-cle} des mots-cles simples
+ # possibles pour peu qu'ils aient une valeur par defaut
+ for k, v in list(self.definition.entites.items()):
+ if v.label != "SIMP":
+ continue
+ if not v.defaut:
+ continue
+ if not k in dico:
+ dico[k] = v(nom=k, val=None, parent=self)
+ # on ajoute l'objet detenteur de regles pour des Accas.validations plus
+ # sophistiquees (a manipuler avec precaution)
+ dico["self"] = self
+ return dico
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient la classe mixin MCFACT qui porte les methodes
+ necessaires pour realiser la Accas.validation d'un objet de type MCFACT
+ derive de OBJECT.
+
+ Une classe mixin porte principalement des traitements et est
+ utilisee par heritage multiple pour composer les traitements.
+"""
+# Modules EFICAS
+from . import V_MCCOMPO
+
+
+class MCFACT(V_MCCOMPO.MCCOMPO):
+
+ """
+ Cette classe a un attribut de classe :
+
+ - txt_nat qui sert pour les comptes-rendus lies a cette classe
+ """
+
+ txt_nat = "Mot cle Facteur :"
+
+ def isValid(self, sd="oui", cr="non"):
+ """
+ Methode pour verifier la validite du MCFACT. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
+ de sd et de cr.
+
+ Si cr vaut oui elle cree en plus un compte-rendu
+ sd est present pour compatibilite de l'interface mais ne sert pas
+ """
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ valid = 1
+ if hasattr(self, "valid"):
+ old_valid = self.valid
+ else:
+ old_valid = None
+ for child in self.mcListe:
+ if not child.isValid():
+ valid = 0
+ break
+ # Apres avoir verifie la validite de tous les sous-objets, on verifie
+ # la validite des regles
+ text_erreurs, test_regles = self.verifRegles()
+ if not test_regles:
+ if cr == "oui":
+ self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs)
+ valid = 0
+ #
+ # On verifie les validateurs s'il y en a
+ #
+ if self.definition.validators and not self.definition.validators.verif(
+ self.valeur
+ ):
+ if cr == "oui":
+ self.cr.fatal(
+ "Keyword : %s should have %s"
+ % (self.nom, self.definition.validators.info())
+ )
+ valid = 0
+ # fin des validateurs
+ #
+ if self.reste_val != {}:
+ if cr == "oui":
+ self.cr.fatal(
+ "unknow keyword : %s" % ",".join(list(self.reste_val.keys()))
+ )
+ valid = 0
+ self.valid = valid
+ self.state = "unchanged"
+ if not old_valid or old_valid != self.valid:
+ self.initModifUp()
+ return self.valid
+ def getValid(self):
+ if hasattr(self, "valid"):
+ return self.valid
+ else:
+ self.valid = None
+ return None
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient la classe mixin MCList qui porte les methodes
+ necessaires pour realiser la Accas.validation d'un objet de type MCList
+ derive de OBJECT.
+
+ Une classe mixin porte principalement des traitements et est
+ utilisee par heritage multiple pour composer les traitements.
+"""
+# Modules Python
+from builtins import object
+import traceback
+
+# Modules EFICAS
+from Accas.extensions.eficas_translation import tr
+from Accas.processing import MAXSIZE, MAXSIZE_MSGCHK
+from Accas.processing import P_CR
+from Accas.processing.P_Exception import AsException
+
+
+class MCList(object):
+
+ """
+ Cette classe a deux attributs de classe :
+
+ - CR qui sert a construire l'objet compte-rendu
+
+ - txt_nat qui sert pour les comptes-rendus lies a cette classe
+ """
+
+ CR = P_CR.CR
+ txt_nat = "Mot cle Facteur Multiple :"
+
+ def isValid(self, cr="non"):
+ """
+ Methode pour verifier la validite du MCList. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
+ de cr.
+
+ Si cr vaut oui elle cree en plus un compte-rendu.
+
+ On n'utilise pas d'attribut pour stocker l'etat et on ne remonte pas
+ le changement d'etat au parent (pourquoi ??)
+ MCLIST est une liste de MCFACT. Les MCFACT ont le meme parent
+ que le MCLIST qui les contient. Il n'est donc pas necessaire de
+ remonter le changement d'etat au parent. C'est deja fait
+ par les MCFACT.
+ """
+ if len(self.data) == 0:
+ return 0
+
+ valid = 1
+ definition = self.data[0].definition
+ # Verification du nombre des mots cles facteurs
+ if definition.min is not None and len(self.data) < definition.min:
+ valid = 0
+ if cr == "oui":
+ self.cr.fatal(
+ "Nombre de mots cles facteurs insuffisant minimum : %s"
+ % definition.min
+ )
+
+ if definition.max is not None and len(self.data) > definition.max:
+ valid = 0
+ if cr == "oui":
+ self.cr.fatal(
+ "Nombre de mots cles facteurs trop grand maximum : %s"
+ % definition.max
+ )
+ num = 0
+ for i in self.data:
+ num = num + 1
+ if not i.isValid():
+ valid = 0
+ if cr == "oui" and len(self) > 1:
+ self.cr.fatal(
+ "L'occurrence numero %d du mot-cle facteur : %s n'est pas valide"
+ % (num, self.nom)
+ )
+ return valid
+
+ def report(self):
+ """
+ Genere le rapport de Accas.validation de self
+ """
+ if len(self) > 1:
+ # Mot cle facteur multiple
+ self.cr = self.CR(
+ debut="Mot-cle facteur multiple : " + tr(self.nom),
+ fin="Fin Mot-cle facteur multiple : " + tr(self.nom),
+ )
+ j = 0
+ for i in self.data:
+ j += 1
+ if j > MAXSIZE:
+ print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.data)))
+ break
+ self.cr.add(i.report())
+ elif len(self) == 1:
+ # Mot cle facteur non multiple
+ self.cr = self.data[0].report()
+ else:
+ self.cr = self.CR(
+ debut="Mot-cle facteur : " + tr(self.nom),
+ fin="Fin Mot-cle facteur : " + tr(self.nom),
+ )
+
+ try:
+ self.isValid(cr="oui")
+ except AsException as e:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.cr.fatal(" %s Mot-cle facteur multiple : %s" % (self.nom, e))
+ return self.cr
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+"""
+ Ce module contient la classe mixin MCSIMP qui porte les methodes
+ necessaires pour realiser la Accas.validation d'un objet de type MCSIMP
+ derive de OBJECT.
+
+ Une classe mixin porte principalement des traitements et est
+ utilisee par heritage multiple pour composer les traitements.
+"""
+# Modules Python
+from builtins import str
+from builtins import object
+
+# Modules EFICAS
+from Accas.processing import P_CR
+from Accas.processing.P_Exception import AsException
+from Accas.processing.P_VALIDATOR import ValError, TypeProtocol, CardProtocol, IntoProtocol
+from Accas.processing.P_VALIDATOR import listProto
+from Accas.extensions.eficas_translation import tr
+
+
+class MCSIMP(object):
+
+ """
+ COMMENTAIRE CCAR:
+ Cette classe est quasiment identique a la classe originale d'EFICAS
+ a part quelques changements cosmetiques et des chagements pour la
+ faire fonctionner de facon plus autonome par rapport a l'environnement
+ EFICAS
+
+ A mon avis, il faudrait aller plus loin et reduire les dependances
+ amont au strict necessaire.
+
+ - Est il indispensable de faire l'evaluation de la valeur dans le contexte
+ du jdc dans cette classe.
+ oui surtout pour les filtres et les validateurs
+
+ - Ne pourrait on pas doter les objets en presence des methodes suffisantes
+ pour eviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
+ d'ailleurs modifie la classe pour eviter l'import de GEOM
+ """
+
+ CR = P_CR.CR
+
+ def __init__(self):
+ self.state = "undetermined"
+ self.typeProto = TypeProtocol("type", typ=self.definition.type)
+ self.intoProto = IntoProtocol(
+ "into",
+ into=self.definition.into,
+ val_min=self.definition.val_min,
+ val_max=self.definition.val_max,
+ )
+ self.cardProto = CardProtocol(
+ "card", min=self.definition.min, max=self.definition.max
+ )
+
+ def getValid(self):
+ if hasattr(self, "valid"):
+ return self.valid
+ else:
+ self.valid = None
+ return None
+
+ def setValid(self, valid):
+ old_valid = self.getValid()
+ self.valid = valid
+ self.state = "unchanged"
+ if not old_valid or old_valid != self.valid:
+ self.initModifUp()
+
+ def isValid(self, cr="non"):
+ """
+ Cette methode retourne un indicateur de validite de l'objet de type MCSIMP
+
+ - 0 si l'objet est invalide
+ - 1 si l'objet est valide
+
+ Le parametre cr permet de parametrer le traitement. Si cr == 'oui'
+ la methode construit egalement un comte-rendu de Accas.validation
+ dans self.cr qui doit avoir ete cree prealablement.
+ """
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ valid = 1
+ v = self.valeur
+ # verification presence
+ if self.isOblig() and (v == None or v == ""):
+ if cr == "oui":
+ self.cr.fatal("Mandatory keyword : %s has no value" % tr(self.nom))
+ valid = 0
+
+ lval = listProto.adapt(v)
+ # Ajout PN
+ # Pour tenir compte des Tuples
+ if hasattr(self.definition.type[0], "ntuple"):
+ try:
+ if (not (type(lval[0]) is tuple)) and (not (type(lval[0]) is list)):
+ lval = (lval,)
+ except:
+ pass
+ if lval is None:
+ valid = 0
+ if cr == "oui":
+ self.cr.fatal("None is not a valid value")
+ else:
+ # type,into ...
+ # typeProto=TypeProtocol("type",typ=self.definition.type)
+ # intoProto=IntoProtocol("into",into=self.definition.into,val_min=self.definition.val_min,val_max=self.definition.val_max)
+ # cardProto=CardProtocol("card",min=self.definition.min,max=self.definition.max)
+ # typeProto=self.definition.typeProto
+ # intoProto=self.definition.intoProto
+ # cardProto=self.definition.cardProto
+ typeProto = self.typeProto
+ intoProto = self.intoProto
+ cardProto = self.cardProto
+ if self.definition.filtre != None:
+ listePossibles = self.getUserAssdPossible()
+ self.intoProto = IntoProtocol(
+ "into",
+ into=listePossibles,
+ val_min=self.definition.val_min,
+ val_max=self.definition.val_max,
+ )
+ intoProto = self.intoProto
+ if cr == "oui":
+ # un cr est demande : on collecte tous les types d'erreur
+ try:
+ for val in lval:
+ typeProto.adapt(val)
+ except ValError as e:
+ valid = 0
+ self.cr.fatal(str(e))
+ try:
+ for val in lval:
+ intoProto.adapt(val)
+ except ValError as e:
+ valid = 0
+ self.cr.fatal(str(e))
+ try:
+ cardProto.adapt(lval)
+ except ValError as e:
+ valid = 0
+ self.cr.fatal(str(e))
+ #
+ # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
+ #
+ if valid and self.definition.validators:
+ try:
+ self.definition.validators.convert(lval)
+ except ValError as e:
+ self.cr.fatal(
+ "invalid keyword %s : %s\nCriteria : %s"
+ % (
+ tr(self.nom),
+ str(e),
+ self.definition.validators.info(),
+ )
+ )
+ valid = 0
+ else:
+ # si pas de cr demande, on sort a la toute premiere erreur
+ try:
+ for val in lval:
+ typeProto.adapt(val)
+ intoProto.adapt(val)
+ cardProto.adapt(lval)
+ if self.definition.validators:
+ if hasattr(self.definition.validators, "set_MCSimp"):
+ self.definition.validators.set_MCSimp(self)
+ self.definition.validators.convert(lval)
+ except ValError as e:
+ valid = 0
+
+ self.setValid(valid)
+ return self.valid
+
+ def isOblig(self):
+ """indique si le mot-cle est obligatoire"""
+ return self.definition.statut == "o"
+
+ def initModifUp(self):
+ """
+ Propage l'etat modifie au parent s'il existe et n'est l'objet
+ lui-meme
+ """
+ if self.parent and self.parent != self:
+ self.parent.state = "modified"
+
+ def report(self):
+ """genere le rapport de Accas.validation de self"""
+ self.cr = self.CR()
+ self.cr.debut = "Simple Keyword : " + tr(self.nom)
+ self.cr.fin = "End Simple Keyword: " + tr(self.nom)
+ self.state = "modified"
+ try:
+ self.isValid(cr="oui")
+ except AsException as e:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.cr.fatal("Simple Keyword : %s %s" % (tr(self.nom), e))
+ return self.cr
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+from builtins import object
+
+
+class MEME_NOMBRE(object):
+
+ """
+ La regle MEME_NOMBRE verifie que l'on trouve au moins un des mots-cles
+ de la regle parmi les arguments d'un OBJECT.
+
+ Ces arguments sont transmis a la regle pour Accas.validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
+ """
+
+ def verif(self, args):
+ """
+ La methode verif verifie que l'on trouve au moins un des mos-cles
+ de la liste self.mcs parmi les elements de args
+
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ""
+ args = self.listeToDico(args)
+ size = -1
+
+ for mc in self.mcs:
+ if mc not in args:
+ text = "Une cle dans la regle n'existe pas %s" % mc
+ return text, 0
+
+ val = args[mc].valeur
+ len_val = 0
+ if not isinstance(val, type([])):
+ len_val = 1
+ else:
+ len_val = len(val)
+
+ if size == -1:
+ size = len_val
+ elif size != len_val:
+ text = "Pas la même longeur"
+ return text, 0
+ return text, 1
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+from builtins import object
+
+
+class PRESENT_ABSENT(object):
+
+ """
+ La regle verifie que si le premier mot-cle de self.mcs est present
+ parmi les elements de args les autres mots cles de self.mcs
+ doivent etre absents
+
+ Ces arguments sont transmis a la regle pour Accas.validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
+ """
+
+ def verif(self, args):
+ """
+ La methode verif effectue la verification specifique a la regle.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # on verifie que si le premier de la liste est present,
+ # les autres sont absents
+ text = ""
+ test = 1
+ args = self.listeToDico(args)
+ mc0 = self.mcs[0]
+ if mc0 in args:
+ for mc in self.mcs[1 : len(self.mcs)]:
+ if mc in args:
+ text = (
+ text
+ + "- Le mot cle "
+ + repr(mc0)
+ + " etant present, il faut que : "
+ + mc
+ + " soit absent"
+ + "\n"
+ )
+ test = 0
+ return text, test
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+from builtins import object
+
+
+class PRESENT_PRESENT(object):
+
+ """
+ La regle verifie que si le premier mot-cle de self.mcs est present
+ parmi les elements de args les autres doivent l'etre aussi
+
+ Ces arguments sont transmis a la regle pour Accas.validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
+ """
+
+ def verif(self, args):
+ """
+ La methode verif effectue la verification specifique a la regle.
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # on verifie que si le premier de la liste est present,
+ # les autres le sont aussi
+ mc0 = self.mcs[0]
+ text = ""
+ test = 1
+ args = self.listeToDico(args)
+ if mc0 in args:
+ for mc in self.mcs[1 : len(self.mcs)]:
+ if not mc in args:
+ text = (
+ text
+ + "- Le mot cle "
+ + repr(mc0)
+ + " etant present, il faut que : "
+ + mc
+ + " soit present"
+ + "\n"
+ )
+ test = 0
+ return text, test
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+"""
+ Ce module contient la classe mixin PROC_ETAPE qui porte les methodes
+ necessaires pour realiser la Accas.validation d'un objet de type PROC_ETAPE
+ derive de OBJECT.
+
+ Une classe mixin porte principalement des traitements et est
+ utilisee par heritage multiple pour composer les traitements.
+"""
+# Modules EFICAS
+from . import V_ETAPE
+from Accas.processing.P_Exception import AsException
+from Accas.processing.P_utils import AsType
+from Accas.extensions.eficas_translation import tr
+
+
+class PROC_ETAPE(V_ETAPE.ETAPE):
+
+ """
+ On reutilise les methodes report,verifRegles
+ de ETAPE par heritage.
+ """
+
+ def isValid(self, sd="oui", cr="non"):
+ """
+ Methode pour verifier la validite de l'objet PROC_ETAPE. Cette methode
+ peut etre appelee selon plusieurs modes en fonction de la valeur
+ de sd et de cr (sd n'est pas utilise).
+
+ Si cr vaut oui elle cree en plus un compte-rendu.
+
+ Cette methode a plusieurs fonctions :
+
+ - retourner un indicateur de validite 0=non, 1=oui
+
+ - produire un compte-rendu : self.cr
+
+ - propager l'eventuel changement d'etat au parent
+ """
+ if CONTEXT.debug:
+ print(("ETAPE.isValid ", self.nom))
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ valid = self.validChild()
+ valid = valid * self.validRegles(cr)
+ if self.reste_val != {}:
+ if not hasattr(self, "cr"):
+ from Accas.processing.P_CR import CR
+
+ self.cr = CR()
+ if cr == "oui":
+ self.cr.fatal(
+ tr("unknown keywords : %s")
+ % ",".join(list(self.reste_val.keys()))
+ )
+ valid = 0
+ self.setValid(valid)
+ return self.valid
--- /dev/null
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 2007-2024 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+from builtins import object
+
+
+class UN_PARMI(object):
+
+ """
+ La regle verifie que l'on trouve un des mots-cles
+ de la regle parmi les arguments d'un OBJECT.
+
+ Ces arguments sont transmis a la regle pour Accas.validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
+ """
+
+ def verif(self, args):
+ """
+ La methode verif verifie que l'on trouve un des mos-cles
+ de la liste self.mcs parmi les elements de args
+
+ args peut etre un dictionnaire ou une liste. Les elements de args
+ sont soit les elements de la liste soit les cles du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ""
+ count = 0
+ args = self.listeToDico(args)
+ for mc in self.mcs:
+ if mc in args:
+ count = count + 1
+ if count != 1:
+ text = "- Il faut un et un seul mot-cle parmi : " + repr(self.mcs) + "\n"
+ return text, 0
+ return text, 1
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce package contient la fonctionnalité de Accas.validation des objets de type OBJECT.
+ Cette fonctionnalité est implémentée sous la forme de classes de type MIXIN qui
+ doivent etre combinées aux classes de bases de Noyau par héritage multiple dans
+ un troisième package, en général, Accas.
+"""
--- /dev/null
+# coding: utf-8 -*-
+#
+
+from Accas import *
+class MYOPER(ASSD) : pass
+
+JdC = JDC_CATA(code='Test1',)
+MonOper=OPER(nom="MonOper", sd_prod=MYOPER,
+ param1 = SIMP(statut='o',typ='R'),
+)
+MonProc = PROC(nom='MonProc',
+ param1 = SIMP(statut='o',typ='R'),
+)
+MonProc2 = PROC(nom='MonProc2',
+ param1 = SIMP(statut='o',typ='R'),
+ param11 = SIMP(statut='f',typ='R'),
+ param12= SIMP(statut='o',typ='R',into=[1,2,3,4,9],),
+ b1 = BLOC (condition = 'param1 == 2',
+ param1_inBloc = SIMP(statut='o',typ='R', defaut = 2),
+ B11 = BLOC (condition = 'param1_inBloc == 2',
+ param1_inBlocDeBloc = SIMP(statut='o',typ='R', defaut=3),
+ B111 = BLOC (condition = 'param1_inBlocDeBloc == 2',
+ paramDernier = SIMP(statut='o',typ='R', defaut=2),
+ paramFacultatifDsB111 = SIMP(typ='R',statut='f'),
+ paramFacultatifDefaut = SIMP(typ='R',statut='f',defaut=3)
+ ),
+ ),
+ param2_inBloc = SIMP(statut='o',typ='R'),
+ ),
+ Fact1 = FACT (statut ='o', max=4,
+ paramInFact1 = SIMP(statut='o',typ='R',max=1),
+ ),
+ Fact2 = FACT (statut ='f',
+ param3InFact2 = SIMP(statut='o',typ='R'),
+ paramFacultatif = SIMP(statut='f',typ='R'),
+ ),
+ Fact3 = FACT (statut ='f',
+ param1InFact3 = SIMP(statut='f',typ='R'),
+ paramFacultatif = SIMP(statut='f',typ='R'),
+ ),
+)
+
--- /dev/null
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+code="Essai"
+import sys, os
+if os.path.dirname(os.path.abspath(__file__)) not in sys.path :
+ sys.path.insert(0,os.path.dirname(os.path.abspath(__file__)))
--- /dev/null
+# -*- coding: utf-8 -*-
+# maConfiguration MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 2007-2021 EDF R&D
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+import os,sys
+# repIni sert a localiser le fichier editeur.ini
+# Obligatoire
+repIni=os.path.dirname(os.path.abspath(__file__))
+INSTALLDIR=os.path.join(repIni,'..')
+sys.path[:0]=[INSTALLDIR]
+
+
+# lang indique la langue utilisee pour les chaines d'aide : fr ou ang
+lang='ang'
+
+# Codage des strings qui accepte les accents (en remplacement de 'ascii')
+encoding='iso-8859-1'
+code = 'Essai'
+
+#
+catalogues=(
+ ('Essai','Essai',os.path.join(repIni,'cata_essai.py'),'python','python'),
+)
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module sert a lancer EFICAS configure pour MAP
+"""
+# Modules Python
+# Modules Eficas
+import prefs
+name='prefs_'+prefs.code
+#__import__(name)
+
+import os, sys
+sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..','..'))
+
+from Editeur import eficas_go
+print (prefs.code)
+eficas_go.lanceEficas(code=prefs.code, GUIPath='QT5')
import traceback
import codecs,types
-from Extensions.i18n import tr
+from Accas.extensions.eficas_translation import tr
def substractList(liste1,liste2):
"""
# import du chargeur de composants
from Editeur.comploader import makeObjecttreeitem
-from Ihm import CONNECTOR
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
+from Accas.accessor import CONNECTOR
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
from reprlib import Repr
import re, os
-from Extensions.i18n import tr
+from Accas.extensions.eficas_translation import tr
l_noms_commandes = ["OPER", "PROC", "MACRO", "FORM"]
l_noms_composes = ["FACT", "BLOC", "NUPL", "FORM"]
from builtins import object
import re, os
-from Extensions.i18n import tr
+from Accas.extensions.eficas_translation import tr
class catalogueInitial(object):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Module de chargement des composants et de mapping des objets du noyau
+ Module de chargement des composants et de mapping des objets du processing
Accas vers les items d'EFICAS
- composants : dictionnaire de stockage des relations entre types
- d'objet du noyau et types d'item
+ d'objet du processing et types d'item
- chargerComposants() : fonction de chargement des composants. Retourne
le dictionnaire composants.
- gettreeitem(object) -> type d'item : fonction qui retourne un type
- d'item correspondant au type de l'objet noyau fourni.
+ d'item correspondant au type de l'objet processing fourni.
- makeObjecttreeitem(appliEficas,labeltext, object, setFunction=None) -> item : fonction qui retourne un item
- correspondant a l'objet noyau fourni.
+ correspondant a l'objet processing fourni.
"""
import os, glob, types
print("cata file is needed")
return None
- from Noyau.N_OBJECT import activeSurcharge
+ from Accas.processing.P_OBJECT import activeSurcharge
activeSurcharge()
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'../InterfaceQT4'))
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'../UiQT4'))
-from Extensions.i18n import tr
+from Accas.extensions.eficas_translation import tr
from string import split,strip,lowercase,uppercase
import re,string
import Accas
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'../InterfaceQT4'))
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'../UiQT4'))
-from Extensions.i18n import tr
+from Accas.extensions.eficas_translation import tr
from string import split,strip,lowercase,uppercase
import re,string
import Accas
except :
pass
import generator
-from Extensions.i18n import tr
+from Accas.extensions.eficas_translation import tr
class TroisDPilote(object):
print ("Le generateur n'a pas ete trouve")
print ("Erreur ! Erreur!")
return ""
- from Extensions.param2 import originalMath
+ from Accas.extensions.param2 import originalMath
originalMath.toOriginal()
self.appliEficas.envoievisu(texte)
originalMath.toSurcharge()
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'../InterfaceQT4'))
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'../UiQT4'))
-from Extensions.i18n import tr
+from Accas.extensions.eficas_translation import tr
from string import split,strip,lowercase,uppercase
import re,string
import os, traceback
import re
-from Extensions.i18n import tr
+from Accas.extensions.eficas_translation import tr
# Les valeurs decodees par optparse sont mises dans un objet dictionnaire-like.
# On l'utilise comme environnement de session.
from copy import deepcopy, copy
import traceback
-# CONTEXT est accessible (__init__.py de Noyau)
+# CONTEXT est accessible (__init__.py de processing)
# import raw.efficas as efficas
sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), "..")))
continue
if monModule.__name__[0:5] == "numpy":
continue
- if monModule.__name__[0:5] == "Noyau":
+ if monModule.__name__[0:5] == "processing":
continue
if monModule.__name__[0:5] == "Accas":
continue
continue
if monModule.__name__[0:10] == "Validation":
continue
- if monModule.__name__[0:10] == "Extensions":
+ if monModule.__name__[0:10] == "extensions":
continue
if monModule.__name__[0:12] == "InterfaceQT":
continue
except:
pass
-from Accas import A_ASSD
-from Extensions.parametre import PARAMETRE
+from Accas.extensions.parametre import PARAMETRE
class X_OBJECT:
self.perePyxb.objPyxb.orderedContent(),
)
+ from Accas import A_ASSD
if inspect.isclass(newVal) and issubclass(newVal, A_ASSD):
newVal = newVal.nom
def analyseFromXML(self, debug=False):
if debug:
- print("je suis ds analyseFromXML -- > appel ds analyseXML de I_JDC.py")
+ print("je suis ds analyseFromXML -- > appel ds analyseXML de A_JDC.py")
if self.procedure == "":
return
self.objPyxb = self.cata.modeleMetier.CreateFromDocument(self.procedure)
+++ /dev/null
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-# Installation de tous les fichiers Python du repertoire et des sous-repertoires (sauf CVS)
-install ( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
- DESTINATION ${CMAKE_INSTALL_PREFIX}
- FILES_MATCHING PATTERN *.py
- PATTERN CVS EXCLUDE
- )
-
-
-### Local Variables:
-### mode: cmake
-### End:
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-"""
-
-"""
-from builtins import object
-
-
-class ASSD(object):
-
- """
- Classe de base pour definir des types de structures de donnees ASTER
- equivalent d un concept ASTER
- Doit_on garder tout ce qui concerne jeveux ? les concepts ?
- """
-
- idracine = "SD"
-
- def __init__(self, etape=None, sd=None, reg="oui"):
- """
- reg est un parametre qui vaut oui ou non :
- - si oui (défaut) : on enregistre la SD aupres du JDC
- - si non : on ne l'enregistre pas
- """
- self.etape = etape
- self.sd = sd
- self.nom = None
- if etape:
- self.parent = etape.parent
- else:
- self.parent = CONTEXT.getCurrentStep()
- if self.parent:
- self.jdc = self.parent.getJdcRoot()
- else:
- self.jdc = None
-
- if not self.parent:
- self.id = None
- elif reg == "oui":
- self.id = self.parent.regSD(self)
- else:
- self.id = self.parent.o_register(self)
- # permet de savoir si le concept a été calculé (1) ou non (0)
- self.executed = 0
- if self.parent:
- self.order = self.parent.icmd
- else:
- self.order = 0
- # attributs pour le Catalogue de Structure de Données
- # "self.cata_sdj" est un attribut de classe
- self.ptr_class_sdj = None
- self.ptr_sdj = None
- # construit en tant que CO('...')
- # 0 : assd normal, 1 : type CO, 2 : type CO typé
- self._as_co = 0
-
- def _getSdj(self):
- """Retourne le catalogue de SD associé au concept."""
- if self.ptr_sdj is None:
- cata_sdj = getattr(self, "cata_sdj", None)
- assert cata_sdj, (
- "The attribute 'cata_sdj' must be defined in the class %s"
- % self.__class__.__name__
- )
- assert self.nom, "The attribute 'nom' has not been filled!"
- if self.ptr_class_sdj is None:
- self.ptr_class_sdj = importObject(cata_sdj)
- self.ptr_sdj = self.ptr_class_sdj(nomj=self.nom)
- return self.ptr_sdj
-
- def _del_sdj(self):
- """Suppression du catalogue de SD."""
- if self.ptr_sdj is not None:
- self.ptr_sdj.supprime(True)
- self.ptr_sdj = None
- self.ptr_class_sdj = None
-
- sdj = property(_getSdj, None, _del_sdj)
-
- def __getitem__(self, key):
- text_error = "ASSD.__getitem__ est déprécié car la référence a l'objet ETAPE parent sera supprimée."
- from warnings import warn
-
- warn(text_error, DeprecationWarning, stacklevel=2)
- return self.etape[key]
-
- def setName(self, nom):
- """Positionne le nom de self"""
- self.nom = nom
-
- def isTypCO(self):
- """Permet de savoir si l'ASSD est issu d'un type CO.
- Retourne:
- 0 : ce n'est pas un type CO
- 1 : c'est un type CO, non encore typé
- 2 : c'est un type CO retypé
- """
- return self._as_co
-
- def changeType(self, new_type):
- """Type connu a posteriori (type CO)."""
- self.__class__ = new_type
- assert self._as_co != 0, "it should only be called on CO object."
- self._as_co = 2
-
- def getName(self):
- """
- Retourne le nom de self, éventuellement en le demandant au JDC
- """
- if not self.nom:
- try:
- self.nom = self.parent.getName(self) or self.id
- except:
- self.nom = ""
-
- if self.nom == "sansnom" or self.nom == "":
- self.nom = self.id
- return self.nom
-
- def supprime(self, force=False):
- """
- Cassage des boucles de références pour destruction du JDC.
- 'force' est utilisée pour faire des suppressions complémentaires
- (voir les formules dans N_FONCTION).
- """
- self.supprimeSd()
- self.etape = None
- self.sd = None
- self.jdc = None
- self.parent = None
-
- def supprimeSd(self):
- """Supprime la partie du catalogue de SD."""
- # 'del self.sdj' appellerait la méthode '_getSdj()'...
- self._del_sdj()
-
- def accept(self, visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitASSD(self)
-
- def __getstate__(self):
- """
- Cette methode permet de pickler les objets ASSD
- Ceci est possible car on coupe les liens avec les objets
- parent, etape et jdc qui conduiraient a pickler de nombreux
- objets inutiles ou non picklables.
- En sortie, l'objet n'est plus tout a fait le même !
- """
- d = self.__dict__.copy()
- for key in ("parent", "etape", "jdc"):
- if key in d:
- del d[key]
- for key in list(d.keys()):
- if key in ("_as_co",):
- continue
- if key[0] == "_":
- del d[key]
- return d
-
- def accessible(self):
- """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD."""
- if CONTEXT.debug:
- print(("| accessible ?", self.nom))
- is_accessible = CONTEXT.getCurrentStep().sdAccessible()
- if CONTEXT.debug:
- print((" `- is_accessible =", repr(is_accessible)))
- return is_accessible
-
- def filter_context(self, context):
- """Filtre le contexte fourni pour retirer (en gros) ce qui vient du catalogue."""
- from .N_ENTITE import ENTITE
- import types
-
- ctxt = {}
- for key, value in list(context.items()):
- if type(value) is type:
- continue
- if type(value) is types.ModuleType and value.__name__.startswith("Accas"):
- continue
- if issubclass(type(value), type):
- continue
- if isinstance(value, ENTITE):
- continue
- ctxt[key] = value
- return ctxt
-
- def parLot(self):
- """Conserver uniquement pour la compatibilite avec le catalogue v9 dans eficas."""
- # XXX eficas
- if not hasattr(self, "jdc") or self.jdc == None:
- val = None
- else:
- val = self.jdc.parLot
- return val == "OUI"
-
- def getEficasAttribut(self, attribut):
- # print ('getEficasAttribut : ', self, attribut)
- valeur = self.etape.getMocle(attribut)
- try:
- valeur = self.etape.getMocle(attribut)
- except:
- valeur = None
- # print (valeur)
- return valeur
-
- def getEficasListOfAttributs(self, listeAttributs):
- from .N_MCLIST import MCList
-
- # print ('getEficasListOfAttributs pour', self,listeAttributs)
- aTraiter = (self.etape,)
- while len(listeAttributs) > 0:
- attribut = listeAttributs.pop(0)
- nvListe = []
- for mc in aTraiter:
- try:
- resultat = mc.getMocle(attribut)
- if isinstance(resultat, MCList):
- for rmc in resultat:
- nvListe.append(rmc)
- else:
- nvListe.append(resultat)
- except:
- pass
- aTraiter = nvListe
- # print ('fin getEficasListOfAttributs ', nvListe)
- return nvListe
-
- def ajouteUnPere(self, pere):
- # ne fait rien mais est appeler pour tous les types de ASSD
- pass
-
-
-class assd(ASSD):
- def __convert__(cls, valeur):
- # On accepte les vraies ASSD et les objets 'entier' et 'reel'
- # qui font tout pour se faire passer pour de vrais entiers/réels.
- if isinstance(valeur, ASSD) or type(valeur) in (int, float):
- return valeur
- raise ValueError(_("On attend un objet concept."))
-
- __convert__ = classmethod(__convert__)
-
-
-class not_checked(ASSD):
- def __convert__(cls, valeur):
- return valeur
-
- __convert__ = classmethod(__convert__)
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-"""
- Ce module contient la classe de definition BLOC
- qui permet de spécifier les caractéristiques des blocs de mots clés
-"""
-
-
-import types
-import sys
-import traceback
-
-from . import N_ENTITE
-from . import N_MCBLOC
-from .N_Exception import AsException
-from .N_types import forceList
-
-
-class BLOC(N_ENTITE.ENTITE):
-
- """
- Classe pour definir un bloc de mots-cles
-
- Cette classe a deux attributs de classe :
-
- - class_instance qui indique la classe qui devra etre utilisée
- pour créer l'objet qui servira à controler la conformité d'un
- bloc de mots-clés avec sa définition
- - label qui indique la nature de l'objet de définition (ici, BLOC)
-
- """
-
- class_instance = N_MCBLOC.MCBLOC
- label = "BLOC"
-
- def __init__(
- self,
- fr="",
- docu="",
- regles=(),
- statut="f",
- condition=None,
- ang="",
- nomXML=None,
- exclusif=False,
- **args
- ):
- """
- Un bloc est caractérisé par les attributs suivants :
-
- - fr : chaine de caractere commentaire pour aide en ligne (en francais)
- - regles : liste d'objets de type REGLE pour vérifier la cohérence des sous-objets
- - statut : obligatoire ('o') ou facultatif ('f')
- - condition : chaine de caractère evaluable par l'interpreteur Python
- - exclusif : ne s active pas en meme temps que ses blocs freres
- - entites : dictionnaire contenant les sous-objets de self (mots-clés).
- La clé du dictionnaire est le nom du mot-clé et la valeur l'objet de
- définition correspondant. Cet attribut est initialisé avec l'argument
- args de la méthode __init__
-
- """
- # Initialisation des attributs
- self.fr = fr
- self.ang = ang
- self.docu = docu
- self.fenetreIhm = None
- self.exclusif = exclusif
- if type(regles) == tuple:
- self.regles = regles
- else:
- self.regles = (regles,)
- self.statut = statut
- self.condition = condition
- self.nomXML = nomXML
- self.entites = args
- self.affecter_parente()
- self.txtNomComplet = ""
- self.possedeDejaUnMCFactorise = False
-
- def __call__(self, val, nom, parent=None, dicoPyxbDeConstruction=None):
- """
- Construit un objet MCBLOC a partir de sa definition (self)
- de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
- """
- return self.class_instance(
- nom=nom,
- definition=self,
- val=val,
- parent=parent,
- dicoPyxbDeConstruction=dicoPyxbDeConstruction,
- )
-
- def verifCata(self):
- """
- Cette méthode vérifie si les attributs de définition sont valides.
- Les éventuels messages d'erreur sont écrits dans l'objet compte-rendu (self.cr).
- """
- self.checkFr()
- self.checkDocu()
- self.checkRegles()
- self.checkStatut(into=("f", "o"))
- self.checkCondition()
- self.verifCataRegles()
-
- def verifPresence(self, dict, globs):
- """
- Cette méthode vérifie si le dictionnaire passé en argument (dict)
- est susceptible de contenir un bloc de mots-clés conforme à la
- définition qu'il porte.
- Si la réponse est oui, la méthode retourne 1
- Si la réponse est non, la méthode retourne 0
-
- Le dictionnaire dict a pour clés les noms des mots-clés et pour valeurs
- les valeurs des mots-clés
- """
- # On recopie le dictionnaire pour protéger l'original
- dico = blocUtils()
- dico.update(dict)
- if self.condition != None:
- try:
- # if 1 :
- test = eval(self.condition, globs, dico)
- return test
- # try:
- # 1
- except NameError:
- # erreur 'normale' : un mot-clé n'est pas présent et on veut
- # l'évaluer dans la condition
- if CONTEXT.debug:
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- print(
- (
- "WARNING : Erreur a l'evaluation de la condition "
- + "".join(l)
- )
- )
- return 0
- except SyntaxError:
- # le texte de la condition n'est pas du Python correct -->
- # faute de catalogue
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- raise AsException(
- "Catalogue entite : ",
- self.nom,
- ", de pere : ",
- self.pere.nom,
- "\n",
- "Erreur dans la condition : ",
- self.condition,
- "".join(l),
- )
- except:
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- raise AsException(
- "Catalogue entite : ",
- self.nom,
- ", de pere : ",
- self.pere.nom,
- "\n",
- "Erreur dans la condition : ",
- self.condition,
- "".join(l),
- )
- else:
- return 0
-
- def longueurDsArbre(self):
- longueur = 0
- for mc in self.mcListe:
- longueur = longueur + mc.longueurDsArbre()
- return longueur
-
-
-def blocUtils():
- """Définit un ensemble de fonctions utilisables pour écrire les
- conditions de BLOC."""
-
- def au_moins_un(mcsimp, valeurs):
- """Valide si la (ou une) valeur de 'mcsimp' est au moins une fois dans
- la ou les 'valeurs'. Similaire à la règle AU_MOINS_UN, 'mcsimp' peut
- contenir plusieurs valeurs."""
- test = set(forceList(mcsimp))
- valeurs = set(forceList(valeurs))
- return not test.isdisjoint(valeurs)
-
- def aucun(mcsimp, valeurs):
- """Valide si aucune des valeurs de 'mcsimp' n'est dans 'valeurs'."""
- return not au_moins_un(mcsimp, valeurs)
-
- def getEficasAttribut(nomUserASSD, nomAttr):
- if nomUserASSD == None:
- return None
- return nomUserASSD.getEficasAttribut(nomAttr)
-
- def getEficasListOfAttributs(nomASSD, listeAttributs):
- if nomASSD == None:
- return ()
- return nomASSD.getEficasListOfAttributs(listeAttributs)
-
- return locals()
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-from .N_ASSD import ASSD
-from .N_Exception import AsException
-from . import N_utils
-
-
-class CO(ASSD):
- def __init__(self, nom):
- ASSD.__init__(self, etape=None, sd=None, reg="oui")
- self._as_co = 1
- #
- # On demande le nommage du concept
- #
- if self.parent:
- try:
- self.parent.nommerSDProd(self, nom)
- except AsException as e:
- appel = N_utils.calleeWhere(niveau=2)
- raise AsException(
- "Concept CO, fichier: ", appel[1], " ligne : ", appel[0], "\n", e
- )
- else:
- self.nom = nom
-
- def __convert__(cls, valeur):
- if valeur.isTypCO():
- return valeur
- raise ValError("Pas un concept CO")
-
- __convert__ = classmethod(__convert__)
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-"""
- Module de conversion des valeurs saisies par l'utilisateur après vérification.
-"""
-from builtins import object
-from .N_types import isInt, isFloat, isSequence
-
-
-def hasIntValue(real):
- """Est-ce que 'real' a une valeur entière ?"""
- return abs(int(real) - real) < 1.0e-12
-
-
-class Conversion(object):
-
- """Conversion de type."""
-
- def __init__(self, name, typeACreer):
- self.name = name
- self.typeACreer = typeACreer
-
- def convert(self, obj):
- """Filtre liste"""
- in_as_seq = isSequence(obj)
- if not in_as_seq:
- obj = (obj,)
-
- result = []
- for o in obj:
- result.append(self.function(o))
-
- if not in_as_seq:
- return result[0]
- else:
- # ne marche pas avec MACR_RECAL qui attend une liste et non un
- # tuple
- return tuple(result)
-
- def function(self, o):
- raise NotImplementedError("cette classe doit être dérivée")
-
-
-class TypeConversion(Conversion):
-
- """Conversion de typeACreer"""
-
- def __init__(self, typeACreer):
- Conversion.__init__(self, "type", typeACreer)
-
-
-class IntConversion(TypeConversion):
-
- """Conversion en entier"""
-
- def __init__(self):
- TypeConversion.__init__(self, "I")
-
- def function(self, o):
- if isFloat(o) and hasIntValue(o):
- o = int(o)
- return o
-
-
-class FloatConversion(TypeConversion):
-
- """Conversion de type"""
-
- def __init__(self):
- TypeConversion.__init__(self, "R")
-
- def function(self, o):
- if isFloat(o):
- o = float(o)
- return o
-
-
-class UserASSDConversion(TypeConversion):
- def __init__(self, classUser):
- TypeConversion.__init__(self, classUser)
-
- def function(self, o):
- # print ('je convertis : ', o, 'en ', self.typeACreer )
- # import traceback
- # traceback.print_stack()
- if o == None:
- return None
- # print ('je cree UserASSDConversion', o, ' ', self.typeACreer)
- nouvelObj = self.typeACreer(o)
- return nouvelObj
-
-
-class UserASSDMultipleConversion(TypeConversion):
- def __init__(self, classUser):
- TypeConversion.__init__(self, classUser)
-
- def function(self, o):
- if o == None:
- return None
- # print ('je cree dans UserASSDMultipleConversion', o, ' ', self.typeACreer)
- nouvelObj = self.typeACreer(o)
- return nouvelObj
-
-
-_convertI = IntConversion()
-_convertR = FloatConversion()
-
-
-def ConversionFactory(name, typ):
- if name == "type":
- if "I" in typ:
- return _convertI
- elif "R" in typ:
- return _convertR
- if name == "UserASSD":
- # print(typ)
- return UserASSDConversion(typ)
- if name == "UserASSDMultiple":
- return UserASSDMultipleConversion(typ)
- return None
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-""" Ce module contient la classe compte-rendu de validation
-"""
-from builtins import str
-from builtins import object
-
-
-class CR(object):
-
- """
- Classe servant a la construction et a l'affichage des objets Comptes-rendus
- """
-
- def __init__(self, verbeux="non", debut="", fin="", dec=" "):
- """
- Attributs
- - verbeux
- - debut
- - fin
- - dec
- """
- self.verbeux = verbeux
- self.debut = debut
- self.fin = fin
- self.dec = dec
- self.crok = []
- self.crwarn = []
- self.crfatal = []
- self.crexception = []
- self.subcr = []
-
- def ok(self, comment):
- """Ajoute un commentaire OK a la liste crok"""
- self.crok.append(comment)
-
- def warn(self, comment):
- """Ajoute un commentaire Warning a la liste crwarn"""
- self.crwarn.append(comment)
-
- def fatal(self, comment, *args):
- """Ajoute un commentaire Erreur Fatale a la liste crfatal a formater"""
- self.crfatal.append(comment)
- self.crfatal.append(str(*args))
-
- def exception(self, comment):
- """Ajoute un commentaire Exception a la liste crexception"""
- self.crexception.append(comment)
-
- def add(self, cr):
- """Ajoute un objet CR a la liste subcr :il s'agit de l'objet CR d'un fils de self"""
- self.subcr.append(cr)
-
- def estvide(self):
- """
- Retourne 1 si self ne contient aucun message grave (fatal ou exception)
- et aucun CR qui en contienne, 0 sinon
- """
- if self.crexception:
- return 0
- if self.crfatal:
- return 0
- for s in self.subcr:
- if not s.estvide():
- return 0
- return 1
-
- def purge(self):
- """
- Purge complètement le CR sauf les exceptions
- """
- self.debut = ""
- self.fin = ""
- self.dec = " "
- self.crok = []
- self.crwarn = []
- self.crfatal = []
- self.subcr = []
-
- def beautifieMessages(self):
- """
- Beautifie les messages stockés dans crok,crfatal,crexception et crwarn
- """
- l = []
- for mess in self.crok:
- l.append(mess + "\n")
- self.crok_belle = l
- l = []
- for mess in self.crwarn:
- l.append(encadreMessage(mess, "*"))
- self.crwarn_belle = l
- l = []
- for mess in self.crfatal:
- l.append(encadreMessage(mess, "!"))
- self.crfatal_belle = l
- l = []
- for mess in self.crexception:
- l.append(encadreMessage(mess, "!"))
- self.crexception_belle = l
-
- def indent(self, s):
- """
- Insère en tete de chaque ligne du texte s la chaine self.dec
- """
- l = s.split("\n")
- a = "\n" + self.dec
- return self.dec + a.join(l)[:-3]
-
- def __unicode__(self):
- """
- Retourne une chaine de caractères décorée et représentative de self
- """
- s = ""
- self.beautifieMessages()
- s = s + "".join(self.crok_belle)
- s = s + "".join(self.crwarn_belle)
- s = s + "".join(self.crfatal_belle)
- s = s + "".join(self.crexception_belle)
- for subcr in self.subcr:
- if self.verbeux == "oui":
- s = s + six.text_type(subcr) + "\n"
- else:
- if not subcr.estvide():
- s = s + six.text_type(subcr)
- if s != "":
- s = self.debut + "\n" + self.indent(s) + self.fin + "\n"
- else:
- s = self.debut + "\n" + self.fin + "\n"
- return s
-
- def __str__(self):
- """Return the report representation"""
- txt = self.__unicode__()
- return txt
-
- def report(self, decalage=2):
- """
- Retourne une chaine de caractères non encadrée mais représentative de self
- """
- s = ""
- # on stocke dans s les messages de premier niveau
- for mess in self.crok:
- s = s + decalage * self.dec + mess + self.dec + "\n"
- for mess in self.crwarn:
- s = s + decalage * self.dec + mess + self.dec + "\n"
- for mess in self.crfatal:
- s = s + decalage * self.dec + mess + self.dec + "\n"
- for mess in self.crexception:
- s = s + decalage * self.dec + mess + self.dec + "\n"
- # on récupère les messages des sous comptes-rendus ...
- for subcr in self.subcr:
- if not subcr.estvide():
- s = s + subcr.report(decalage=decalage + 1)
- # on rajoute les flags de début et de fin ... (si self n'est pas vide)
- if not self.estvide():
- s = (
- (decalage - 1) * self.dec
- + self.debut
- + "\n"
- + s
- + (decalage - 1) * self.dec
- + self.fin
- + "\n"
- )
- return s
-
- def getMessFatal(self):
- """
- Retourne une chaine de caractères contenant les messages de
- la liste crfatal (du dernier au premier)
- """
- self.crfatal.reverse()
- s = ""
- for elem in self.crfatal:
- s = s + elem
- self.crfatal.reverse()
- return s
-
- def getMessException(self):
- """
- Retourne une chaine de caractères contenant les messages
- de la liste crexception (du dernier au premier)
- """
- self.crexception.reverse()
- s = ""
- for elem in self.crexception:
- s = s + elem
- self.crexception.reverse()
- return s
-
-
-separateurs = (" ", ",", "/")
-
-
-def split(ligne, cesure):
- ligne = ligne.rstrip()
- if len(ligne) <= cesure:
- return ligne
- else:
- coupure = cesure
- while ligne[coupure] not in separateurs and coupure > 0:
- coupure = coupure - 1
- if coupure == 0:
- # Il faut augmenter la cesure
- coupure = cesure
- while ligne[coupure] not in separateurs and coupure < len(ligne) - 1:
- coupure = coupure + 1
- if coupure == len(ligne) - 1:
- return ligne
- else:
- return ligne[: coupure + 1] + "\n" + split(ligne[coupure + 1 :], cesure)
-
-
-def justifyText(texte="", cesure=50):
- if not isinstance(texte, str):
- texte = "".join(texte)
- texte = texte.strip()
- liste_lignes = texte.split("\n")
- l = [split(l, cesure) for l in liste_lignes]
- texte_justifie = "\n".join(l)
- return texte_justifie
-
-
-def encadreMessage(texte, motif):
- """
- Retourne la chaine de caractères texte entourée d'un cadre formés
- d'éléments 'motif'
- """
- texte = justifyText(texte, cesure=80)
- if texte.strip() == "":
- return ""
- lignes = texte.split("\n")
- longueur = 0
- for ligne in lignes:
- ligne = ligne.rstrip()
- if len(ligne) > longueur:
- longueur = len(ligne)
- longueur = longueur + 4
- txt = motif * longueur + "\n"
- for ligne in lignes:
- if ligne == "":
- continue
- txt = (
- txt
- + motif
- + " "
- + ligne
- + " " * (longueur - len(motif + ligne) - 2)
- + motif
- + "\n"
- )
- txt = txt + motif * longueur + "\n"
- return txt
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-"""
- Ce module contient la classe ENTITE qui est la classe de base
- de toutes les classes de definition d'EFICAS.
-"""
-from builtins import str
-from builtins import object
-from . import N_CR
-from . import N_OPS
-from . import N_VALIDATOR
-
-import six
-
-stringTypes = (str, six.text_type)
-
-
-class ENTITE(object):
-
- """
- Classe de base pour tous les objets de definition : mots cles et commandes
- Cette classe ne contient que des methodes utilitaires
- Elle ne peut être instanciee et doit d abord être specialisee
- """
-
- CR = N_CR.CR
- factories = {"validator": N_VALIDATOR.validatorFactory}
-
- def __init__(self, validators=None):
- """
- Initialise les deux attributs regles et entites d'une classe dérivée
- à : pas de règles et pas de sous-entités.
-
- L'attribut regles doit contenir la liste des regles qui s'appliquent
- sur ses sous-entités
-
- L'attribut entités doit contenir le dictionnaires des sous-entités
- (clé = nom, valeur=objet)
- Les attributs utiles pour la projection xsd sont aussi initialises
- init non appele pour bloc
- """
- self.regles = ()
- self.entites = {}
- if validators:
- self.validators = self.factories["validator"](validators)
- else:
- self.validators = validators
- # self.doitSenregistrerComme = None
- self.txtNomComplet = ""
- self.redefinit = False
- self.dejaPrepareDump = False
- self.possedeDejaUnMCFactorise = False
-
- def affecter_parente(self):
- """
- Cette methode a pour fonction de donner un nom et un pere aux
- sous entités qui n'ont aucun moyen pour atteindre leur parent
- directement
- Il s'agit principalement des mots cles
- """
- for k, v in list(self.entites.items()):
- # print( k,v)
- v.pere = self
- v.nom = k
-
- def verifCata(self):
- """
- Cette methode sert à valider les attributs de l'objet de définition
- """
- raise NotImplementedError(
- "La méthode verifCata de la classe %s doit être implémentée"
- % self.__class__.__name__
- )
-
- def __call__(self):
- """
- Cette methode doit retourner un objet dérivé de la classe OBJECT
- """
-
- raise NotImplementedError(
- "La méthode __call__ de la classe %s doit être implémentée"
- % self.__class__.__name__
- )
-
- def report(self):
- """
- Cette méthode construit pour tous les objets dérivés de ENTITE un
- rapport de validation de la définition portée par cet objet
- """
- self.cr = self.CR()
- self.verifCata()
- for k, v in list(self.entites.items()):
- try:
- cr = v.report()
- cr.debut = "Début " + v.__class__.__name__ + " : " + k
- cr.fin = "Fin " + v.__class__.__name__ + " : " + k
- self.cr.add(cr)
- except:
- self.cr.fatal("Impossible d'obtenir le rapport de %s %s" % (k, repr(v)))
- print(("Impossible d'obtenir le rapport de %s %s" % (k, repr(v))))
- print(("père =", self))
- return self.cr
-
- def verifCataRegles(self):
- """
- Cette méthode vérifie pour tous les objets dérivés de ENTITE que
- les objets REGLES associés ne portent que sur des sous-entités
- existantes
- """
- for regle in self.regles:
- l = []
- for mc in regle.mcs:
- if not mc in self.entites:
- l.append(mc)
- if l != []:
- txt = str(regle)
- self.cr.fatal(
- _("Argument(s) non permis : %r pour la règle : %s"), l, txt
- )
-
- def checkDefinition(self, parent):
- """Verifie la definition d'un objet composite (commande, fact, bloc)."""
- args = self.entites.copy()
- mcs = set()
- for nom, val in list(args.items()):
- if val.label == "SIMP":
- mcs.add(nom)
- # XXX
- # if val.max != 1 and val.type == 'TXM':
- # print "#CMD", parent, nom
- elif val.label == "FACT":
- val.checkDefinition(parent)
- # CALC_SPEC !
- # assert self.label != 'FACT', \
- #'Commande %s : Mot-clef facteur present sous un mot-clef facteur : interdit !' \
- # % parent
- else:
- continue
- del args[nom]
- # seuls les blocs peuvent entrer en conflit avec les mcs du plus haut
- # niveau
- for nom, val in list(args.items()):
- if val.label == "BLOC":
- mcbloc = val.checkDefinition(parent)
- # XXX
- assert mcs.isdisjoint(
- mcbloc
- ), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" % (
- parent,
- tuple(mcs.intersection(mcbloc)),
- )
- return mcs
-
- def checkOp(self, valmin=-9999, valmax=9999):
- """Vérifie l'attribut op."""
- if self.op is not None and (
- type(self.op) is not int or self.op < valmin or self.op > valmax
- ):
- self.cr.fatal(
- _("L'attribut 'op' doit être un entier " "compris entre %d et %d : %r"),
- valmin,
- valmax,
- self.op,
- )
-
- def checkProc(self):
- """Vérifie l'attribut proc."""
- if self.proc is not None and not isinstance(self.proc, N_OPS.OPS):
- self.cr.fatal(
- _("L'attribut op doit être une instance d'OPS : %r"), self.proc
- )
-
- def checkRegles(self):
- """Vérifie l'attribut regles."""
- if type(self.regles) is not tuple:
- self.cr.fatal(_("L'attribut 'regles' doit être un tuple : %r"), self.regles)
-
- def checkFr(self):
- """Vérifie l'attribut fr."""
- if type(self.fr) not in stringTypes:
- self.cr.fatal(
- _("L'attribut 'fr' doit être une chaine de caractères : %r"), self.fr
- )
-
- def checkDocu(self):
- """Vérifie l'attribut docu."""
- if type(self.docu) not in stringTypes:
- self.cr.fatal(
- _("L'attribut 'docu' doit être une chaine de caractères : %r"),
- self.docu,
- )
-
- def checkNom(self):
- """Vérifie l'attribut proc."""
- if type(self.nom) is not str:
- self.cr.fatal(
- _("L'attribut 'nom' doit être une chaine de caractères : %r"), self.nom
- )
-
- def checkReentrant(self):
- """Vérifie l'attribut reentrant."""
- if self.reentrant not in ("o", "n", "f"):
- self.cr.fatal(
- _("L'attribut 'reentrant' doit valoir 'o','n' ou 'f' : %r"),
- self.reentrant,
- )
-
- def checkStatut(self, into=("o", "f", "c", "d")):
- """Vérifie l'attribut statut."""
- if self.statut not in into:
- self.cr.fatal(
- _("L'attribut 'statut' doit être parmi %s : %r"), into, self.statut
- )
-
- def checkCondition(self):
- """Vérifie l'attribut condition."""
- if self.condition != None:
- if type(self.condition) is not str:
- self.cr.fatal(
- _("L'attribut 'condition' doit être une chaine de caractères : %r"),
- self.condition,
- )
- else:
- self.cr.fatal(_("La condition ne doit pas valoir None !"))
-
- def checkMinMax(self):
- """Vérifie les attributs min/max."""
- if type(self.min) != int:
- if self.min != "**" and self.min != float("-inf"):
- self.cr.fatal(_("L'attribut 'min' doit être un entier : %r"), self.min)
- if type(self.max) != int:
- if self.max != "**" and self.max != float("inf"):
- self.cr.fatal(_("L'attribut 'max' doit être un entier : %r"), self.max)
- if self.min > self.max:
- self.cr.fatal(
- _("Nombres d'occurrence min et max invalides : %r %r"),
- self.min,
- self.max,
- )
-
- def checkValidators(self):
- """Vérifie les validateurs supplémentaires"""
- if self.validators and not self.validators.verifCata():
- self.cr.fatal(
- _("Un des validateurs est incorrect. Raison : %s"),
- self.validators.cata_info,
- )
-
- def checkHomo(self):
- """Vérifie l'attribut homo."""
- if self.homo != 0 and self.homo != 1:
- self.cr.fatal(_("L'attribut 'homo' doit valoir 0 ou 1 : %r"), self.homo)
-
- def checkInto(self):
- """Vérifie l'attribut into."""
- if self.into != None:
- if (type(self.into) not in (list, tuple)) and (
- type(self.into) != types.FunctionType
- ):
- self.cr.fatal(_("L'attribut 'into' doit être un tuple : %r"), self.into)
-
- def checkPosition(self):
- """Vérifie l'attribut position."""
- if self.position not in (
- "local",
- "global",
- "global_jdc",
- "inGetAttribut",
- "reCalculeEtape",
- ):
- self.cr.fatal(
- _(
- "L'attribut 'position' doit valoir 'local', 'global' ,'global_jdc', 'inGetAttribut', 'reCalculeEtape' "
- "ou 'global_jdc' : %r"
- ),
- self.position,
- )
-
- def nomComplet(self):
- if self.txtNomComplet != "":
- return self.txtNomComplet
- qui = self
- while hasattr(qui, "pere"):
- self.txtNomComplet += "_" + qui.nom
- qui = qui.pere
- self.txtNomComplet += "_" + qui.nom
- return self.txtNomComplet
-
- def geneaCompleteSousFormeDeListe(self):
- geneaCompleteSousFormeDeListe = []
- qui = self
- while hasattr(qui, "pere"):
- geneaCompleteSousFormeDeListe.append(qui)
- qui = qui.pere
- geneaCompleteSousFormeDeListe.append(qui)
- return geneaCompleteSousFormeDeListe
-
- def addDefinitionMC(self, listeMCAvant, **args):
- ouChercher = self
- for mot in listeMCAvant:
- try:
- ouChercher = ouChercher.entites[mot]
- except:
- print("impossible de trouver : ", mot, " ", listeMCAvant)
- (nomMC, defMC) = args.items()[0]
- defMC.pere = ouChercher
- defMC.pere.propageRedefinit()
- defMC.nom = nomMC
- cata = CONTEXT.getCurrentCata()
- # print (cata)
- ouChercher.entites[nomMC] = defMC
-
- def changeDefinitionMC(self, listeMCAvant, **args):
- ouChercher = self
- for mot in listeMCAvant:
- try:
- ouChercher = ouChercher.entites[mot]
- except:
- print("impossible de trouver : ", mot, " ", listeMCAvant)
- monSIMP = ouChercher
- for nomAttributDef, valeurAttributDef in args.items():
- if hasattr(monSIMP, nomAttributDef):
- setattr(monSIMP, nomAttributDef, valeurAttributDef)
- else:
- print("pb avec ", nomAttributdef, valeurAttributMC)
- monSIMP.propageRedefinit()
-
- def propageRedefinit(self):
- # a reflechir
- self.redefinit = True
- # PNPN il faut remonter a l etape
-
- def makeObjetPourVerifSignature(self, *args, **kwargs):
- etape = self.class_instance(oper=self, args=kwargs)
- etape.MCBuild()
- return etape
-
- def dumpStringDataBase(self, dPrimaryKey, dElementsRecursifs, dictKey, inBloc):
- # ne fonctionne que
- # on admet que si un FACT a une primaryKey, elle existe dans celui-ci
- # ou que il s agit d un motclef frere/oncle place avant
- # derivee pour N_SIMP et N_FACT
- debug = True
- if debug:
- print("****** traitement de ", self.nom)
- if debug:
- print(
- "dElementsRecursifs",
- dElementsRecursifs,
- )
- if debug:
- print(
- "dPrimaryKey",
- dPrimaryKey,
- )
- texte = ""
- texteDesFactTables = ""
- if debug:
- print("dictKey", dictKey)
- if (self.label == "OPER") or (self.label == "PROC"):
- for mc in dPrimaryKey.values():
- dictKey[mc] = None
- texte = "CREATE TABLE IF NOT EXISTS {} (\n".format(self.nom)
- for mc in self.entites.values():
- if mc.label == "SIMP":
- texteMC = mc.dumpStringDataBase(inBloc)
- texte += texteMC
- if mc.nom in dictKey:
- dictKey[mc.nom] = (texteMC, self.nom)
- elif mc.label == "FACT":
- if mc.nom in dElementsRecursifs:
- texte += mc.dumpStringDataBase(
- dPrimaryKey, dElementsRecursifs, dictKey, inBloc
- )
- else:
- texteDesFactTables += mc.dumpStringDataBase(
- dPrimaryKey, dElementsRecursifs, dictKey, inBloc
- )
- else:
- texte += mc.dumpStringDataBase(
- dPrimaryKey, dElementsRecursifs, dictKey, inBloc
- )
- if self.label == "BLOC":
- for mc in self.entites.values():
- texte += m.dumpStringDataBase(
- dPrimaryKey, dElementsRecursifs, inBloc, dictKey
- )
- # on enleve la derniere ','
- texte = texte[0:-3]
- texte += "\n"
- if (self.label == "OPER") or (self.label == "PROC"):
- if self.nom in dPrimaryKey:
- texte += "\tPRIMARY KEY ({}), \n".format(dPrimaryKey[self.nom])
- texte += ");\n"
- texte += texteDesFactTables
- return texte
-
- def dumpGitStringFormat(self):
- texte = ""
- if self.label == "SIMP":
- texte += "<ns1:{}>".format(self.nom)
- texte += "%{}".format(self.fr)
- texte += "</ns1:{}>".format(self.nom)
- else:
- if self.label == "FACT":
- texte += "<ns1:{}>".format(self.nom)
- for c in self.entites.values():
- texte += c.dumpGitStringFormat()
- if self.label == "FACT":
- texte += "</ns1:{}>".format(self.nom)
- return texte
-
- def dumpStructure(self, decal=0):
- if self.label == "SIMP":
- texte = decal * " " + self.nom + " \n"
- return texte
- texte = decal * " " + self.nom
- if self.label == "BLOC":
- texte += " " + self.condition
- if self.label == "OPER":
- texte + " " + str(self.sd_prod) + "\n"
- texte += " \n"
- for c in self.entites.values():
- texte += c.dumpStructure(decal + 1)
- texte += decal * " " + "fin pour " + self.nom + " \n"
- return texte
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-"""
- Ce module contient la classe ETAPE qui sert a verifier et a executer
- une commande
-"""
-
-# Modules Python
-
-
-try:
- from builtins import str
-except:
- pass
-import types
-import sys
-import os
-import linecache
-import traceback
-from copy import copy
-
-# Modules EFICAS
-from . import N_MCCOMPO
-from .N_Exception import AsException
-from . import N_utils
-from .N_utils import AsType
-from .N_ASSD import ASSD
-
-
-class ETAPE(N_MCCOMPO.MCCOMPO):
-
- """
- Cette classe herite de MCCOMPO car ETAPE est un OBJECT composite
-
- """
-
- nature = "OPERATEUR"
-
- # L'attribut de classe codex est utilise pour rattacher le module de calcul eventuel (voir Build)
- # On le met a None pour indiquer qu'il n'y a pas de module de calcul
- # rattache
- codex = None
-
- def __init__(self, oper=None, reuse=None, args={}, niveau=4):
- """
- Attributs :
- - definition : objet portant les attributs de definition d'une etape de type operateur. Il
- est initialise par l'argument oper.
- - reuse : indique le concept d'entree reutilise. Il se trouvera donc en sortie
- si les conditions d'execution de l'operateur l'autorise
- - valeur : arguments d'entree de type mot-cle=valeur. Initialise avec l'argument args.
- - objPyxbDeConstruction
- """
- # faut il le faire ds MC_Build ?
- # traitement de Pyxb si Pyxb
- self.dicoPyxbDeConstruction = args.get("dicoPyxbDeConstruction", None)
- if self.dicoPyxbDeConstruction:
- del args["dicoPyxbDeConstruction"]
- self.objPyxbDeConstruction = self.dicoPyxbDeConstruction["objEnPyxb"]
- else:
- self.objPyxbDeConstruction = None
- self.definition = oper
- self.reuse = reuse
- self.valeur = args
- self.nettoiargs()
- self.parent = CONTEXT.getCurrentStep()
- self.etape = self
- self.nom = oper.nom
- self.idracine = oper.label
- self.appel = N_utils.calleeWhere(niveau)
- self.mc_globaux = {}
- self.doitEtreRecalculee = False
- self.sd = None
- self.actif = 1
- self.makeRegister()
- self.icmd = None
- self.userASSDCrees = []
-
- def makeRegister(self):
- """
- Initialise les attributs jdc, id, niveau et realise les
- enregistrements necessaires
- surcharge dans Ihm
- """
- # print ('makeRegister de ETAPE')
- if self.parent:
- self.jdc = self.parent.getJdcRoot()
- self.id = self.parent.register(self)
- self.niveau = None
- else:
- self.jdc = self.parent = None
- self.id = None
- self.niveau = None
-
- def nettoiargs(self):
- """
- Cette methode a pour fonction de retirer tous les arguments egaux a None
- de la liste des arguments. Ils sont supposes non presents et donc retires.
- """
- for k in list(self.valeur.keys()):
- if self.valeur[k] == None:
- del self.valeur[k]
-
- def MCBuild(self):
- """
- Demande la construction des sous-objets et les stocke dans l'attribut
- mcListe.
- """
- self.mcListe = self.buildMc()
-
- def buildSd(self, nom):
- """
- Construit le concept produit de l'operateur. Deux cas
- peuvent se presenter :
-
- - le parent n'est pas defini. Dans ce cas, l'etape prend en charge la creation
- et le nommage du concept.
-
- - le parent est defini. Dans ce cas, l'etape demande au parent la creation et
- le nommage du concept.
-
- """
- self.sdnom = nom
- try:
- if self.parent:
- sd = self.parent.createSdprod(self, nom)
- if type(self.definition.op_init) == types.FunctionType:
- self.definition.op_init(*(self, self.parent.g_context))
- else:
- sd = self.getSdProd()
- # On n'utilise pas self.definition.op_init car self.parent
- # n'existe pas
- if sd != None and self.reuse == None:
- # On ne nomme le concept que dans le cas de non reutilisation
- # d un concept
- sd.setName(nom)
- except AsException as e:
- raise AsException(
- "Etape ",
- self.nom,
- "ligne : ",
- self.appel[0],
- "fichier : ",
- self.appel[1],
- e,
- )
- except EOFError:
- raise
- except:
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- raise AsException(
- "Etape ",
- self.nom,
- "ligne : ",
- self.appel[0],
- "fichier : ",
- self.appel[1] + "\n",
- "".join(l),
- )
-
- self.Execute()
- return sd
-
- def Execute(self):
- """
- Cette methode est un point d'entree prevu pour realiser une execution immediatement
- apres avoir construit les mots cles et le concept produit.
- Par defaut, elle ne fait rien. Elle doit etre surchargee dans une autre partie du programme.
- """
- return
-
- def getSdProd(self):
- """
- Retourne le concept resultat de l'etape
- Deux cas :
- - cas 1 : sd_prod de oper n'est pas une fonction
- il s'agit d'une sous classe de ASSD
- on construit le sd a partir de cette classe
- et on le retourne
- - cas 2 : il s'agit d'une fonction
- on l'evalue avec les mots-cles de l'etape (mcListe)
- on construit le sd a partir de la classe obtenue
- et on le retourne
- """
- if type(self.definition.sd_prod) == types.FunctionType:
- d = self.creeDictValeurs(self.mcListe)
- try:
- sd_prod = self.definition.sd_prod(*(), **d)
- except EOFError:
- raise
- except Exception as exc:
- if CONTEXT.debug:
- traceback.print_exc()
- raise AsException(
- "impossible d affecter un type au resultat:", str(exc)
- )
- else:
- sd_prod = self.definition.sd_prod
- # on teste maintenant si la SD est reutilisee ou s'il faut la creer
- if self.definition.reentrant != "n" and self.reuse:
- # Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale.
- # Elle sera traitee ulterieurement.
- self.sd = self.reuse
- else:
- self.sd = sd_prod(etape=self)
- # Si l'operateur est obligatoirement reentrant et reuse n'a pas ete specifie, c'est une erreur.
- # On ne fait rien ici. L'erreur sera traiter par la suite.
- # precaution
- if self.sd is not None and not isinstance(self.sd, ASSD):
- raise AsException(
- """
-Impossible de typer le resultat !
-Causes possibles :
- Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,
- soit il y a une "," a la fin d'une commande precedente.
- Developpeur : La fonction "sd_prod" retourne un type invalide."""
- )
- return self.sd
-
- def getType_produit(self):
- try:
- return self.getType_produit_brut()
- except:
- return None
-
- def getType_produit_brut(self):
- """
- Retourne le type du concept resultat de l'etape
- Deux cas :
- - cas 1 : sd_prod de oper n'est pas une fonction
- il s'agit d'une sous classe de ASSD
- on retourne le nom de la classe
- - cas 2 : il s'agit d'une fonction
- on l'evalue avec les mots-cles de l'etape (mcListe)
- et on retourne son resultat
- """
- if type(self.definition.sd_prod) == types.FunctionType:
- d = self.creeDictValeurs(self.mcListe)
- sd_prod = self.definition.sd_prod(*(), **d)
- else:
- sd_prod = self.definition.sd_prod
- return sd_prod
-
- def getEtape(self):
- """
- Retourne l'etape a laquelle appartient self
- Un objet de la categorie etape doit retourner self pour indiquer que
- l'etape a ete trouvee
- """
- return self
-
- def supprime(self):
- """
- Methode qui supprime toutes les references arrières afin que l'objet puisse
- etre correctement detruit par le garbage collector
- """
- N_MCCOMPO.MCCOMPO.supprime(self)
- self.jdc = None
- self.appel = None
- for name in dir(self):
- if name.startswith("_cache_"):
- setattr(self, name, None)
- if self.sd:
- self.sd.supprime()
-
- def __del__(self):
- pass
-
- def getCreated_sd(self):
- """Retourne la liste des sd reellement produites par l'etape.
- Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans
- cette liste."""
- if not self.reuse and self.sd:
- return [
- self.sd,
- ]
- return []
-
- def isActif(self):
- """
- Indique si l'etape est active (1) ou inactive (0)
- """
- return self.actif
-
- def setCurrentStep(self):
- """
- Methode utilisee pour que l etape self se declare etape
- courante. Utilise par les macros
- """
- cs = CONTEXT.getCurrentStep()
- if self.parent != cs:
- raise AsException(
- "L'etape courante",
- cs.nom,
- cs,
- "devrait etre le parent de",
- self.nom,
- self,
- )
- else:
- CONTEXT.unsetCurrentStep()
- CONTEXT.setCurrentStep(self)
-
- def resetCurrentStep(self):
- """
- Methode utilisee par l'etape self qui remet son etape parent comme
- etape courante
- """
- cs = CONTEXT.getCurrentStep()
- if self != cs:
- raise AsException(
- "L'etape courante", cs.nom, cs, "devrait etre", self.nom, self
- )
- else:
- CONTEXT.unsetCurrentStep()
- CONTEXT.setCurrentStep(self.parent)
-
- def issubstep(self, etape):
- """
- Cette methode retourne un entier indiquant si etape est une
- sous etape de self ou non
- 1 = oui
- 0 = non
- Une etape simple n'a pas de sous etape
- """
- return 0
-
- def getFile(self, unite=None, fic_origine="", fname=None):
- """
- Retourne le nom du fichier correspondant a un numero d'unite
- logique (entier) ainsi que le source contenu dans le fichier
- """
- if self.jdc:
- return self.jdc.getFile(unite=unite, fic_origine=fic_origine, fname=fname)
- else:
- if unite != None:
- if os.path.exists("fort." + str(unite)):
- fname = "fort." + str(unite)
- if fname == None:
- raise AsException(
- "Impossible de trouver le fichier correspondant"
- " a l unite %s" % unite
- )
- if not os.path.exists(fname):
- raise AsException("%s n'est pas un fichier existant" % unite)
- fproc = open(fname, "r")
- text = fproc.read()
- fproc.close()
- text = text.replace("\r\n", "\n")
- linecache.cache[fname] = 0, 0, text.split("\n"), fname
- return fname, text
-
- def accept(self, visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitETAPE(self)
-
- def updateContext(self, d):
- """
- Cette methode doit updater le contexte fournit par
- l'appelant en argument (d) en fonction de sa definition
- """
- if type(self.definition.op_init) == types.FunctionType:
- self.definition.op_init(*(self, d))
- if self.sd:
- d[self.sd.nom] = self.sd
-
- def copy(self):
- """Methode qui retourne une copie de self non enregistree auprès du JDC
- et sans sd
- """
- etape = copy(self)
- etape.sd = None
- etape.state = "modified"
- etape.reuse = None
- etape.sdnom = None
- etape.etape = etape
- etape.mcListe = []
- for objet in self.mcListe:
- new_obj = objet.copy()
- new_obj.reparent(etape)
- etape.mcListe.append(new_obj)
- return etape
-
- def copyReuse(self, old_etape):
- """Methode qui copie le reuse d'une autre etape."""
- if hasattr(old_etape, "reuse"):
- self.reuse = old_etape.reuse
-
- def copySdnom(self, old_etape):
- """Methode qui copie le sdnom d'une autre etape."""
- if hasattr(old_etape, "sdnom"):
- self.sdnom = old_etape.sdnom
-
- def reparent(self, parent):
- """
- Cette methode sert a reinitialiser la parente de l'objet
- """
- self.parent = parent
- self.jdc = parent.getJdcRoot()
- self.etape = self
- for mocle in self.mcListe:
- mocle.reparent(self)
- if self.sd and self.reuse == None:
- self.sd.jdc = self.jdc
-
- def getCmd(self, nomcmd):
- """
- Methode pour recuperer la definition d'une commande
- donnee par son nom dans les catalogues declares
- au niveau du jdc
- Appele par un ops d'une macro en Python
- """
- return self.jdc.getCmd(nomcmd)
-
- def copyIntern(self, etape):
- """
- Methode permettant lors du processus de recopie de copier
- les elements internes d'une etape dans une autre
- """
- return
-
- def fullCopy(self, parent=None):
- """
- Methode permettant d'effectuer une copie complète
- d'une etape (y compris concept produit, elements internes)
- Si l'argument parent est fourni, la nouvelle etape
- aura cet objet comme parent.
- """
- new_etape = self.copy()
- new_etape.copyReuse(self)
- new_etape.copySdnom(self)
- if parent:
- new_etape.reparent(parent)
- if self.sd:
- new_sd = self.sd.__class__(etape=new_etape)
- new_etape.sd = new_sd
- if self.reuse == None:
- new_etape.parent.nommerSDProd(new_sd, self.sd.nom)
- else:
- new_sd.setName(self.sd.nom)
- new_etape.copyIntern(self)
- return new_etape
-
- def resetJdc(self, new_jdc):
- """
- Reinitialise le nommage du concept de l'etape lors d'un changement de jdc
- """
- if self.sd and self.reuse == None:
- self.parent.nommerSDProd(self.sd, self.sd.nom)
-
- def isInclude(self):
- """Permet savoir si on a affaire a la commande INCLUDE
- car le comportement de ces macros est particulier.
- """
- return self.nom.startswith("INCLUDE")
-
- def sdAccessible(self):
- """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'etape."""
- if CONTEXT.debug:
- print(("`- ETAPE sdAccessible :", self.nom))
- return self.parent.sdAccessible()
-
- def getConcept(self, nomsd):
- """
- Methode pour recuperer un concept a partir de son nom
- """
- # pourrait etre appelee par une commande fortran faisant appel a des fonctions python
- # on passe la main au parent
- return self.parent.getConcept(nomsd)
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-"""
- Ce module contient la classe AsException
-"""
-# Modules EFICAS
-
-from .strfunc import getEncoding, toUnicode
-import six
-
-
-class AsException(Exception):
- def __unicode__(self):
- args = []
- for x in self.args:
- ustr = toUnicode(x)
- if type(ustr) is not six.text_type:
- ustr = six.text_type(repr(x))
- args.append(ustr)
- return " ".join(args)
-
- def __str__(self):
- return six.text_type(self).encode(getEncoding())
-
-
-class InterruptParsingError(Exception):
-
- """Exception used to interrupt the parsing of the command file
- without raising an error (see N_JDC.execCompile for usage)"""
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-""" Ce module contient la classe de definition FACT
- qui permet de spécifier les caractéristiques des mots clés facteurs
-"""
-import types
-
-from . import N_ENTITE
-from . import N_MCFACT
-from . import N_MCLIST
-from .N__F import _F
-from .N_types import isSequence
-
-from . import N_OBJECT
-
-
-class FACT(N_ENTITE.ENTITE):
-
- """
- Classe pour definir un mot cle facteur
-
- Cette classe a trois attributs de classe
-
- - class_instance qui indique la classe qui devra etre utilisée
- pour créer l'objet qui servira à controler la conformité d'un
- mot-clé facteur avec sa définition
-
- - list_instance
-
- - label qui indique la nature de l'objet de définition (ici, FACT)
- """
-
- class_instance = N_MCFACT.MCFACT
- list_instance = N_MCLIST.MCList
- label = "FACT"
-
- def __init__(
- self,
- fr="",
- docu="",
- regles=(),
- statut="f",
- defaut=None,
- ang="",
- fenetreIhm=None,
- min=0,
- max=1,
- validators=None,
- nomXML=None,
- **args
- ):
- """
- Un mot-clé facteur est caractérisé par les attributs suivants :
-
- - fr :
- - statut :
- - defaut :
- - regles
- - min
- - max
- - position
- - docu
- - fenetreIhm
- """
- N_ENTITE.ENTITE.__init__(self, validators)
- # Initialisation des attributs
- self.fr = fr
- self.ang = ang
- self.docu = docu
- if type(regles) == tuple:
- self.regles = regles
- else:
- self.regles = (regles,)
- self.statut = statut
- self.defaut = defaut
- self.min = min
- self.max = max
- if self.max == "**":
- self.max = float("inf")
- if self.min == "**":
- self.min = float("-inf")
- self.entites = args
- self.position = None
- self.affecter_parente()
- self.fenetreIhm = fenetreIhm
- self.nomXML = nomXML
-
- def __call__(self, val, nom, parent, dicoPyxbDeConstruction=None):
- """
- Construit la structure de donnee pour un mot cle facteur a partir
- de sa definition (self) de sa valeur (val), de son nom (nom) et de
- son parent dans l arboresence (parent)
-
- Suivant le type de la valeur on retournera soit un objet de type
- MCFACT soit une liste de type MCLIST.
-
- La creation d un mot cle facteur depend de son statut
- - Si statut ='o' il est obligatoire
- - Si statut == 'd' il est facultatif mais ses sous mots cles avec
- defaut sont visibles
- - Si statut == 'f' il est facultatif et ses sous mots avec defaut ne
- sont pas visibles
- - Si statut == 'c' il est cache ???
- - Si defaut != None, on utilise cette valeur pour calculer la valeur
- par defaut du mot cle facteur
- """
- if val is None:
- if self.defaut == None:
- val = {}
- elif type(self.defaut) == tuple:
- val = self.defaut
- # Est ce utile ? Le défaut pourrait etre uniquement un dict
- elif type(self.defaut) == dict or isinstance(self.defaut, _F):
- val = self.defaut
- else:
- # On ne devrait jamais passer par la
- print("On ne devrait jamais passer par la")
- return None
- elif isSequence(val) and len(val) == 0 and self.statut == "o":
- # On est dans le cas où le mcfact est présent mais est une liste/tuple
- # vide. Il est obligatoire donc on l'initialise. Les règles, mots-clés
- # obligatoires diront si un mcfact vide est accepté.
- val = {}
-
- # On cree toujours une liste de mcfact
- l = self.list_instance()
- l.init(nom=nom, parent=parent)
- if type(val) in (tuple, list, self.list_instance):
- indice = 0
- for v in val:
- if type(v) == dict or isinstance(v, _F):
- if dicoPyxbDeConstruction:
- objet = self.class_instance(
- nom=nom,
- definition=self,
- val=v,
- parent=parent,
- dicoPyxbDeConstruction=dicoPyxbDeConstruction[indice],
- )
- else:
- objet = self.class_instance(
- nom=nom,
- definition=self,
- val=v,
- parent=parent,
- dicoPyxbDeConstruction=None,
- )
- indice = indice + 1
- l.append(objet)
- elif isinstance(v, self.class_instance):
- # if faut gerer ici --> on passe la avec une liste de concept ?
- # PNPN --> si pyxb
- l.append(v)
- else:
- l.append(N_OBJECT.ErrorObj(self, v, parent, nom))
- elif type(val) == dict or isinstance(val, _F):
- if dicoPyxbDeConstruction:
- objet = self.class_instance(
- nom=nom,
- definition=self,
- val=val,
- parent=parent,
- dicoPyxbDeConstruction=dicoPyxbDeConstruction,
- )
- else:
- objet = self.class_instance(
- nom=nom,
- definition=self,
- val=val,
- parent=parent,
- dicoPyxbDeConstruction=None,
- )
- l.append(objet)
- elif isinstance(val, self.class_instance):
- # idem --> quand passe t on la
- l.append(val)
- else:
- l.append(N_OBJECT.ErrorObj(self, val, parent, nom))
- # pour tenir compte du validateFonction
- if l.jdc:
- l.cata = l.jdc.cata
- l.buildObjPyxb(l)
- return l
-
- def verifCata(self):
- self.checkMinMax()
- self.checkFr()
- self.checkRegles()
- self.checkStatut()
- self.checkDocu()
- self.checkValidators()
- self.verifCataRegles()
-
- def dumpStringDataBase(self, dPrimaryKey, dElementsRecursifs, dictKey, inBloc):
- # ne fonctionne que
- # on admet que si un FACT a une primaryKey, elle existe dans celui-ci
- # ou que il s agit d un motclef frere/oncle place avant
- debug = True
- if debug:
- print("****** traitement de FACT ", self.nom)
- if debug:
- print(
- "dElementsRecursifs",
- dElementsRecursifs,
- )
- if debug:
- print(
- "dPrimaryKey",
- dPrimaryKey,
- )
- if debug:
- print("dictKey", dictKey)
- texte = "CREATE TABLE IF NOT EXISTS {} (\n".format(self.nom)
- texteForeignKey = ""
- textePrimaryKey = ""
- texteDesFactTables = ""
- if self.nom in dElementsRecursifs:
- return "\t{} XML ,\n".format(self.nom)
- if self.nom in dPrimaryKey:
- if debug:
- print("FACT ", self.nom, " attend une primary key")
- if dPrimaryKey[self.nom] not in self.entites.values():
- if dictKey[dPrimaryKey[self.nom]] == None:
- texte += "PB SUR LA PRIMARY KEY DE {}\n".format(self.nom)
- elif dPrimaryKey[self.nom] not in dictKey:
- texte += "PB SUR LA PRIMARY KEY DE {}\n".format(self.nom)
- else:
- texte += dictKey[dPrimaryKey[self.nom]][0]
- textePrimaryKey = "\tPRIMARY KEY ({}), \n".format(
- dPrimaryKey[self.nom]
- )
- texteForeignKey = (
- "\tFOREIGN KEY ({}) REFERENCES {} ({}), \n".format(
- dPrimaryKey[self.nom],
- dictKey[dPrimaryKey[self.nom]][1],
- dPrimaryKey[self.nom],
- )
- )
- for mc in self.entites.values():
- if mc.label == "SIMP":
- texteMC = mc.dumpStringDataBase(inBloc)
- texte += texteMC
- if mc.nom in dictKey:
- dictKey[mc.nom] = (texteMC, self.nom)
- elif mc.label == "FACT":
- if mc.nom in dElementsRecursifs:
- texte += mc.dumpStringDataBase(
- dPrimaryKey, dElementsRecursifs, dictKey, inBloc
- )
- else:
- texteDesFactTables += mc.dumpStringDataBase(
- dPrimaryKey, dElementsRecursifs, dictKey, inBloc
- )
- else:
- texte += mc.dumpStringDataBase(
- dPrimaryKey, dElementsRecursifs, dictKey, inBloc
- )
- texte += textePrimaryKey
- texte += texteForeignKey
- texte = texte[0:-3]
- texte += "\n);\n"
- texte += texteDesFactTables
- return texte
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-# Attention : cet import permet d'avoir, en Python, le comportement
-# de la division réelle pour les entiers, et non la division entière
-# 1/2=0.5 (et non 0). Comportement par défaut dans Python 3.0.
-
-from builtins import zip
-from builtins import str
-from math import sin, cos, tan, asin, acos, atan2, atan, sinh, cosh, tanh
-from math import pi, exp, log, log10, sqrt
-from .N_ASSD import ASSD
-
-class FONCTION(ASSD):
- pass
-
-class formule(ASSD):
- def __init__(self, *args, **kwargs):
- ASSD.__init__(self, *args, **kwargs)
- self.nompar = None
- self.expression = None
- ctxt = {}
- ctxt.update(getattr(self.parent, "const_context", {}))
- ctxt.update(getattr(self.parent, "macro_const_context", {}))
- self.parent_context = self.filter_context(ctxt)
-
- def __call__(self, *val):
- """Evaluation de la formule"""
- # en POURSUITE, self.parent_context is None, on essaie de reprendre
- # const_context
- context = getattr(self, "parent_context") or getattr(
- self.parent, "const_context", {}
- )
- for param, value in zip(self.nompar, val):
- context[param] = value
- try:
- # globals() pour math.*
- res = eval(self.code, context, globals())
- except Exception as exc:
- mes = "ERREUR LORS DE L EVALUATION DE LA FORMULE %s" % self.nom
- print(mes)
- raise
- return res
-
- def setFormule(self, nom_para, texte):
- """Cette methode sert a initialiser les attributs
- nompar, expression et code qui sont utilisés
- dans l'évaluation de la formule."""
- self.nompar = nom_para
- self.expression = texte
- try:
- self.code = compile(texte, texte, "eval")
- except SyntaxError as exc:
- mes = "ERREUR LORS DE LA CREATION DE LA FORMULE %s" % self.nom
- print(mes)
- raise
-
- def __setstate__(self, state):
- """Cette methode sert a restaurer l'attribut code lors d'un unpickle."""
- self.__dict__.update(state) # update attributes
- self.setFormule(self.nompar, self.expression) # restore code attribute
-
- def __getstate__(self):
- """Pour les formules, il faut enlever l'attribut code qui n'est
- pas picklable."""
- d = ASSD.__getstate__(self)
- del d["code"]
- return d
-
- def supprime(self, force=False):
- """
- Cassage des boucles de références pour destruction du JDC.
- 'force' est utilisée pour faire des suppressions complémentaires.
-
- Pour être évaluées, les formules ont besoin du contexte des "constantes"
- (objets autres que les concepts) qui sont soit dans (jdc).const_context,
- soit dans (macro).macro_const_context.
- On le stocke dans 'parent_context'.
- Deux précautions valent mieux qu'une : on retire tous les concepts.
-
- Lors de la suppression du concept, 'supprime' est appelée par
- 'build_detruire' avec force=True afin de supprimer le "const_context"
- conservé.
- """
- if force:
- for ctxt in ("parent_context", "g_context"):
- if hasattr(self, ctxt):
- setattr(self, ctxt, None)
- ASSD.supprime(self, force)
-
- def Parametres(self):
- """Equivalent de fonction.Parametres pour pouvoir utiliser des formules
- à la place de fonctions dans certaines macro-commandes.
- """
- from SD.sd_fonction import sd_formule
- from Utilitai.Utmess import UTMESS
-
- if self.accessible():
- TypeProl = {"E": "EXCLU", "L": "LINEAIRE", "C": "CONSTANT", "I": "INTERPRE"}
- sd = sd_formule(self.getName())
- prol = sd.PROL.get()
- nova = sd.NOVA.get()
- if prol is None or nova is None:
- UTMESS("F", "SDVERI_2", valk=[objev])
- dico = {
- "INTERPOL": ["LIN", "LIN"],
- "NOM_PARA": [s.strip() for s in nova],
- "NOM_RESU": prol[3][0:16].strip(),
- "PROL_DROITE": TypeProl["E"],
- "PROL_GAUCHE": TypeProl["E"],
- }
- else:
- raise Accas.AsException("Erreur dans fonction.Parametres en PAR_LOT='OUI'")
- return dico
-
-
-class formule_c(formule):
- pass
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-from . import N_MACRO
-from . import N_FORM_ETAPE
-
-
-class FORM(N_MACRO.MACRO):
-
- """
- Cette classe sert à définir dans le catalogue des objets de type
- FORMULE pour ASTER.
- Elle surcharge la classe MACRO
- """
-
- class_instance = N_FORM_ETAPE.FORM_ETAPE
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-from . import N_MACRO_ETAPE
-
-
-class FORM_ETAPE(N_MACRO_ETAPE.MACRO_ETAPE):
-
- """
- Cette classe sert à construire l'objet ACCAS correspondant à une
- FORMULE Aster.
- Il s'agit d'un objet MACRO_ETAPE légèrement modifié
- """
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-"""
-"""
-
-from .N_ASSD import ASSD
-
-
-class GEOM(ASSD):
-
- """
- Cette classe sert à définir les types de concepts
- géométriques comme GROUP_NO, GROUP_MA,NOEUD et MAILLE
- inusitée
-
- """
-
- def __init__(self, nom, etape=None, sd=None, reg="oui"):
- """ """
- self.etape = etape
- self.sd = sd
- if etape:
- self.parent = etape.parent
- else:
- self.parent = CONTEXT.getCurrentStep()
- if self.parent:
- self.jdc = self.parent.getJdcRoot()
- else:
- self.jdc = None
-
- if not self.parent:
- self.id = None
- elif reg == "oui":
- self.id = self.parent.regSD(self)
- self.nom = nom
-
- def getName(self):
- return self.nom
-
- def __convert__(cls, valeur):
- if isinstance(valeur, str) and len(valeur.strip()) <= 8:
- return valeur.strip()
- raise ValueError(_("On attend une chaine de caractères (de longueur <= 8)."))
-
- __convert__ = classmethod(__convert__)
-
-
-class geom(GEOM):
- pass
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe JDC qui sert a interpreter un jeu de commandes
-"""
-from builtins import str
-from builtins import range
-import os
-import traceback
-import types
-import sys
-import linecache
-
-# Modules EFICAS
-from . import N_OBJECT
-from . import N_CR
-from .N_Exception import AsException, InterruptParsingError
-from .N_ASSD import ASSD
-from .strfunc import getEncoding
-
-
-class JDC(N_OBJECT.OBJECT):
-
- """
- Cette classe interprete un jeu de commandes fourni sous
- la forme d'une chaine de caractères
-
- Attributs de classe :
-
- Attributs d'instance :
-
- """
-
- nature = "JDC"
- CR = N_CR.CR
- exec_init = """
-import Accas
-from Accas import _F
-from Accas import *
-NONE = None
-"""
-
- from .N_utils import SEP
-
- def __init__(
- self,
- definition=None,
- procedure=None,
- cata=None,
- cata_ord_dico=None,
- parent=None,
- nom="SansNom",
- appliEficas=None,
- context_ini=None,
- **args
- ):
- self.procedure = procedure
- self.definition = definition
- self.cata = cata
- self._build_reserved_kw_list()
- self.cata_ordonne_dico = cata_ord_dico
- self.nom = nom
- self.appliEficas = appliEficas
- self.parent = parent
- self.context_ini = context_ini
- # On conserve les arguments supplementaires. Il est possible de passer
- # des informations globales au JDC par ce moyen. Il pourrait etre plus
- # sur de mettre en place le mecanisme des mots-cles pour verifier la
- # validite des valeurs passees.
- # Ceci reste a faire
- # On initialise avec les parametres de la definition puis on
- # update avec ceux du JDC
- self.args = self.definition.args
- self.args.update(args)
- self.nstep = 0
- self.nsd = 0
- self.parLot = "OUI"
- self.parLot_user = None
- if definition:
- self.regles = definition.regles
- self.code = definition.code
- else:
- self.regles = ()
- self.code = "CODE"
- #
- # Creation de l objet compte rendu pour collecte des erreurs
- #
- self.cr = self.CR(
- debut="CR phase d'initialisation", fin="fin CR phase d'initialisation"
- )
- # on met le jdc lui-meme dans le context global pour l'avoir sous
- # l'etiquette "jdc" dans le fichier de commandes
- self.g_context = {"jdc": self}
- CONTEXT.unsetCurrentJdC()
- CONTEXT.setCurrentJdC(self)
- # Dictionnaire pour stocker tous les concepts du JDC (acces rapide par
- # le nom)
- self.sdsDict = {}
- self.etapes = []
- self.index_etapes = {}
- self.mc_globaux = {}
- self.currentContext = {}
- self.condition_context = {}
- self.index_etape_courante = 0
- self.UserError = "UserError"
- self.alea = None
- # permet transitoirement de conserver la liste des etapes
- self.hist_etape = False
-
- def compile(self):
- """
- Cette methode compile la chaine procedure
- Si des erreurs se produisent, elles sont consignees dans le
- compte-rendu self.cr
- """
- try:
- # Python 2.7 compile function does not accept unicode filename, so we encode it
- # with the current locale encoding in order to have a correct
- # traceback
- encoded_filename = self.nom.encode(getEncoding())
- self.proc_compile = compile(self.procedure, encoded_filename, "exec")
- except SyntaxError as e:
- if CONTEXT.debug:
- traceback.print_exc()
- l = traceback.format_exception_only(SyntaxError, e)
- self.cr.exception("Compilation impossible : " + "".join(l))
- except SystemError as e:
- erreurs_connues = """
-Causes possibles :
- - offset too large : liste trop longue derrière un mot-cle.
- Solution : liste = (valeurs, ..., )
- MOT_CLE = *liste,
-"""
- l = traceback.format_exception_only(SystemError, e)
- l.append(erreurs_connues)
- self.cr.exception("Compilation impossible : " + "".join(l))
- return
-
- def setCurrentContext(self):
- # beaucoup trop simple Ne tient pas compte des imports
- # et des include
- # ne sert que pour le POC
- CONTEXT.setCurrentStep(self)
-
- def execCompile(self):
- """
- Cette methode execute le jeu de commandes compile dans le contexte
- self.g_context de l'objet JDC
- """
-
- CONTEXT.setCurrentStep(self)
- # Le module nommage utilise le module linecache pour acceder
- # au source des commandes du jeu de commandes.
- # Dans le cas d'un fichier, on accède au contenu de ce fichier
- # Dans le cas d'une chaine de caractères il faut acceder
- # aux commandes qui sont dans la chaine
- import linecache
-
- linecache.cache[self.nom] = 0, 0, self.procedure.split("\n"), self.nom
- try:
- exec(self.exec_init, self.g_context)
- for obj_cata in (self.cata,):
- if type(obj_cata) == types.ModuleType:
- init2 = "from " + obj_cata.__name__ + " import *"
- exec(init2, self.g_context)
- else:
- # ici on a un catalogue en grammaire Eficas XML
- # il faut ajouter ce qu on a construit au contexte
- for k, v in obj_cata.contexteXML.items():
- self.g_context[k] = v
- # Initialisation du contexte global pour l'evaluation des conditions de BLOC
- # On utilise une copie de l'initialisation du contexte du jdc
- self.condition_context = self.g_context.copy()
-
- # Si l'attribut context_ini n'est pas vide, on ajoute au contexte global
- # le contexte initial (--> permet d'evaluer un JDC en recuperant un contexte
- # d'un autre par exemple)
- if self.context_ini:
- self.g_context.update(self.context_ini)
- # Update du dictionnaire des concepts
- for sdnom, sd in list(self.context_ini.items()):
- if isinstance(sd, ASSD):
- self.sdsDict[sdnom] = sd
-
- # if self.appliEficas != None:
- # self.appliEficas.afficheInfos(
- # 'Interpretation du fichier de commandes en cours ...')
-
- # On sauve le contexte pour garder la memoire des constantes
- # En mode edition (EFICAS) ou lors des verifications le contexte
- # est recalcule
- # mais les constantes sont perdues
- self.const_context = self.g_context
- exec(self.proc_compile, self.g_context)
-
- CONTEXT.unsetCurrentStep()
-
- except InterruptParsingError:
- # interrupt the command file parsing used by FIN to ignore the end
- # of the file
- pass
-
- except EOFError:
- # Exception utilise pour interrompre un jeu
- # de commandes avant la fin
- # Fonctionnement normal, ne doit pas etre considere comme une
- # erreur
- CONTEXT.unsetCurrentStep()
- self.afficheFinExec()
- self.traiterFinExec("commande")
-
- except AsException as e:
- # une erreur a ete identifiee
- if CONTEXT.debug:
- traceback.print_exc()
- # l'exception a ete recuperee avant (ou, comment ?),
- # donc on cherche dans le texte
- txt = str(e)
- self.cr.exception(txt)
- CONTEXT.unsetCurrentStep()
-
- except NameError as e:
- etype, value, tb = sys.exc_info()
- l = traceback.extract_tb(tb)
- s = traceback.format_exception_only(NameError, e)
- msg = "erreur de syntaxe, %s ligne %d" % (s, l[-1][1])
- if CONTEXT.debug:
- traceback.print_exc()
- self.cr.exception(msg)
- CONTEXT.unsetCurrentStep()
-
- # except self.UserError as exc_val:
- # self.traiterUserException(exc_val)
- # CONTEXT.unsetCurrentStep()
- # self.afficheFinExec()
- # self.traiterFinExec('commande')
-
- except:
- # erreur inattendue
- # sys_exc_typ,sys_exc_value,sys_exc_frame = sys_exc.info()
- # (tuple de 3 elements)
- if CONTEXT.debug:
- traceback.print_exc()
-
- traceback.print_exc()
-
- exc_typ, exc_val, exc_fr = sys.exc_info()
- l = traceback.format_exception(exc_typ, exc_val, exc_fr)
- self.cr.exception(
- "erreur non prevue et non traitee prevenir la maintenance "
- + "\n"
- + "".join(l)
- )
- del exc_typ, exc_val, exc_fr
- CONTEXT.unsetCurrentStep()
- idx = 0
- for e in self.etapes:
- self.enregistreEtapePyxb(e, idx)
- idx = idx + 1
-
- def afficheFinExec(self):
- """
- Cette methode realise l'affichage final des statistiques de temps
- apres l'execution de toutes
- les commandes en mode commande par commande ou par lot
- Elle doit etre surchargee pour en introduire un
- """
- return
-
- def traiterFinExec(self, mode, etape=None):
- """
- Cette methode realise un traitement final apres l'execution de toutes
- les commandes en mode commande par commande ou par lot
- Par defaut il n'y a pas de traitement. Elle doit etre surchargee
- pour en introduire un
- """
- print("FIN D'EXECUTION %s %s" % s(mode, etape))
-
- def traiterUserException(self, exc_val):
- """Cette methode realise un traitement sur les exceptions utilisateur
- Par defaut il n'y a pas de traitement. La methode doit etre
- surchargee pour en introduire un.
- """
- return
-
- def register(self, etape):
- """
- Cette methode ajoute etape dans la liste des etapes : self.etapes
- et retourne un numero d'enregistrement
- """
- self.etapes.append(etape)
- self.index_etapes[etape] = len(self.etapes) - 1
- return self.gRegister(etape)
-
- def o_register(self, sd):
- """
- Retourne un identificateur pour concept
- """
- self.nsd = self.nsd + 1
- nom = sd.idracine + self.SEP + repr(self.nsd)
- return nom
-
- def gRegister(self, etape):
- """
- Retourne un identificateur pour etape
- """
- self.nstep = self.nstep + 1
- idetape = etape.idracine + self.SEP + repr(self.nstep)
- return idetape
-
- def createSdprod(self, etape, nomsd):
- """
- Cette methode doit fabriquer le concept produit retourne
- par l'etape etape et le nommer.
-
- Elle est appelee a l'initiative de l'etape
- pendant le processus de construction de cette etape :
- methode __call__ de la classe CMD (OPER ou MACRO)
-
- Ce travail est realise par le contexte superieur
- (etape.parent) car dans certains cas, le concept ne doit
- pas etre fabrique mais l'etape doit simplement utiliser
- un concept preexistant.
-
- Deux cas possibles :
- - Cas 1 : etape.reuse != None : le concept est reutilise
- - Cas 2 : l'etape appartient a une macro qui a declare un
- concept de sortie qui doit etre produit par cette
- etape.
- Dans le cas du JDC, le deuxième cas ne peut pas se produire.
- """
- sd = etape.getSdProd()
- if sd != None and (etape.definition.reentrant == "n" or etape.reuse is None):
- # ATTENTION : On ne nomme la SD que dans le cas de non reutilisation
- # d un concept. Commande non reentrante ou reuse absent.
- self.nommerSDProd(sd, nomsd)
- return sd
-
- def nommerSDProd(self, sd, sdnom, restrict="non"):
- """
- Nomme la SD apres avoir verifie que le nommage est possible : nom
- non utilise
- Si le nom est deja utilise, leve une exception
- Met le concept cree dans le concept global g_context
- """
- o = self.sdsDict.get(sdnom, None)
- if isinstance(o, ASSD):
- raise AsException("Nom de concept deja defini : %s" % sdnom)
- if sdnom in self._reserved_kw:
- raise AsException(
- "Nom de concept invalide. '%s' est un mot-cle reserve." % sdnom
- )
-
- # Ajoute a la creation (appel de regSD).
- self.sdsDict[sdnom] = sd
- sd.setName(sdnom)
-
- # En plus si restrict vaut 'non', on insere le concept dans le contexte
- # du JDC
- if restrict == "non":
- self.g_context[sdnom] = sd
-
- def regUserSD(self, sd):
- # utilisee pour creer les references
- # se contente d appeler la methode equivalente sur le jdc
- id = self.regSD(sd)
- self.nommerSDProd(sd, sd.nom)
- return id
-
- def regSD(self, sd):
- """
- Methode appelee dans l __init__ d un ASSD lors de sa creation
- pour s enregistrer
- """
- return self.o_register(sd)
-
- def deleteConceptAfterEtape(self, etape, sd):
- """
- Met a jour les etapes du JDC qui sont après etape suite a
- la disparition du concept sd
- """
- # Cette methode est definie dans le noyau mais ne sert que pendant
- # la phase de creation des etapes et des concepts. Il n'y a aucun
- # traitement particulier a realiser.
- # Dans d'autres conditions, il faut surcharger cette methode
- return
-
- def supprime(self):
- N_OBJECT.OBJECT.supprime(self)
- for etape in self.etapes:
- etape.supprime()
-
- def clean(self, netapes):
- """Nettoie les `netapes` dernières etapes de la liste des etapes."""
- if self.hist_etape:
- return
- for i in range(netapes):
- e = self.etapes.pop()
- jdc = e.jdc
- parent = e.parent
- e.supprime()
- e.parent = parent
- e.jdc = jdc
- del self.index_etapes[e]
-
- def getFile(self, unite=None, fic_origine="", fname=None):
- """
- Retourne le nom du fichier correspondant a un numero d'unite
- logique (entier) ainsi que le source contenu dans le fichier
- """
- # if self.appliEficas:
- # Si le JDC est relie a une appliEficascation maitre, on delègue la
- # recherche
- # return self.appliEficas.getFile(unite, fic_origine)
- # else:
- # if unite != None:
- # if os.path.exists("fort." + str(unite)):
- # fname = "fort." + str(unite)
- if fname == None:
- raise AsException("Impossible de trouver le fichier correspondant")
- if not os.path.exists(fname):
- raise AsException(fname + " n'est pas un fichier existant")
- fproc = open(fname, "r")
- text = fproc.read()
- fproc.close()
- text = text.replace("\r\n", "\n")
- linecache.cache[fname] = 0, 0, text.split("\n"), fname
- return fname, text
-
- def set_parLot(self, parLot, user_value=False):
- """
- Met le mode de traitement a PAR LOT
- ou a COMMANDE par COMMANDE
- en fonction de la valeur du mot cle PAR_LOT et
- du contexte : appliEficascation maitre ou pas
-
- En PAR_LOT='NON', il n'y a pas d'ambiguite.
- d'analyse et juste avant la phase d'execution.
- `user_value` : permet de stocker la valeur choisie par l'utilisateur
- pour l'interroger plus tard (par exemple dans `getContexteAvant`).
- """
- if user_value:
- self.parLot_user = parLot
- if self.appliEficas == None:
- # Pas d appliEficascation maitre
- self.parLot = parLot
- else:
- # Avec appliEficascation maitre
- self.parLot = "OUI"
-
- def accept(self, visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitJDC(self)
-
- def interact(self):
- """
- Cette methode a pour fonction d'ouvrir un interpreteur
- pour que l'utilisateur entre des commandes interactivement
- """
- CONTEXT.setCurrentStep(self)
- try:
- # Le module nommage utilise le module linecache pour acceder
- # au source des commandes du jeu de commandes.
- # Dans le cas d'un fichier, on accède au contenu de ce fichier
- # Dans le cas de la console interactive, il faut pouvoir acceder
- # aux commandes qui sont dans le buffer de la console
- import linecache
- import code
-
- console = code.InteractiveConsole(self.g_context, filename="<console>")
- linecache.cache["<console>"] = 0, 0, console.buffer, "<console>"
- banner = (
- """***********************************************
-* Interpreteur interactif %s
-***********************************************"""
- % self.code
- )
- console.interact(banner)
- finally:
- console = None
- CONTEXT.unsetCurrentStep()
-
- def getContexteAvant(self, etape):
- """
- Retourne le dictionnaire des concepts connus avant etape
- On tient compte des commandes qui modifient le contexte
- comme DETRUIRE ou les macros
- Si etape == None, on retourne le contexte en fin de JDC
- """
- # L'etape courante pour laquelle le contexte a ete calcule est
- # memorisee dans self.index_etape_courante
- # XXX on pourrait faire mieux dans le cas PAR_LOT="NON" : en
- # memorisant l'etape
- # courante pendant le processus de construction des etapes.
- # Si on insère des commandes (par ex, dans EFICAS), il faut prealablement
- # remettre ce pointeur a 0
- # self.currentContext.items() if isinstance(v, ASSD)])
- # if self.parLot_user == 'NON':
- # d = self.currentContext = self.g_context.copy()
- # if etape is None:
- # return d
- # retirer les sd produites par 'etape'
- # sd_names = [sd.nom for sd in etape.getCreated_sd()]
- # for nom in sd_names:
- # try:
- # del d[nom]
- # except KeyError:
- # from warnings import warn
- # warn(
- # "concept '%s' absent du contexte de %s" % (
- # nom, self.nom),
- # RuntimeWarning, stacklevel=2)
- # return d
- if etape:
- index_etape = self.index_etapes[etape]
- else:
- index_etape = len(self.etapes)
- if index_etape >= self.index_etape_courante:
- # On calcule le contexte en partant du contexte existant
- d = self.currentContext
- if self.index_etape_courante == 0 and self.context_ini:
- d.update(self.context_ini)
- liste_etapes = self.etapes[self.index_etape_courante : index_etape]
- else:
- d = self.currentContext = {}
- if self.context_ini:
- d.update(self.context_ini)
- liste_etapes = self.etapes
-
- for e in liste_etapes:
- if e is etape:
- break
- if e.isActif():
- e.updateContext(d)
- self.index_etape_courante = index_etape
- return d
-
- def getGlobalContexte(self):
- """Retourne "un" contexte global ;-)"""
- # N'est utilise que par INCLUDE (sauf erreur).
- # g_context est remis a {} en PAR_LOT='OUI'. const_context permet
- # de retrouver ce qui y a ete mis par execCompile.
- # Les concepts n'y sont pas en PAR_LOT='OUI'. Ils sont ajoutes
- # par getGlobalContexte de la MACRO.
- d = self.const_context.copy()
- d.update(self.g_context)
- return d
-
- def getContexteCourant(self, etape_courante=None):
- """
- Retourne le contexte tel qu'il est (ou 'sera' si on est en phase
- de construction) au moment de l'execution de l'etape courante.
- """
- if etape_courante is None:
- etape_courante = CONTEXT.getCurrentStep()
- return self.getContexteAvant(etape_courante)
-
- def getConcept(self, nomsd):
- """
- Methode pour recuperer un concept a partir de son nom
- """
- co = self.getContexteCourant().get(nomsd.strip(), None)
- if not isinstance(co, ASSD):
- co = None
- return co
-
- def getConceptByType(self, nomsd, typesd, etape):
- """
- Methode pour recuperer un concept a partir de son nom et de son type.
- Il aura comme père 'etape'.
- """
- assert issubclass(typesd, ASSD), typesd
- co = typesd(etape=etape)
- co.setName(nomsd)
- co.executed = 1
- return co
-
- def delConcept(self, nomsd):
- """
- Methode pour supprimer la reference d'un concept dans le sdsDict.
- Ne detruire pas le concept (different de supprime).
- """
- try:
- del self.sdsDict[nomsd.strip()]
- except:
- pass
-
- def getCmd(self, nomcmd):
- """
- Methode pour recuperer la definition d'une commande
- donnee par son nom dans les catalogues declares
- au niveau du jdc
- """
- for cata in (self.cata,):
- if hasattr(cata, nomcmd):
- return getattr(cata, nomcmd)
-
- def append_reset(self, etape):
- """
- Ajoute une etape provenant d'un autre jdc a la liste des etapes
- et remet a jour la parente de l'etape et des concepts
- """
- self.etapes.append(etape)
- self.index_etapes[etape] = len(self.etapes) - 1
- etape.reparent(self)
- etape.resetJdc(self)
-
- def sdAccessible(self):
- """On peut acceder aux "valeurs" (jeveux) des ASSD si le JDC est en PAR_LOT="NON"."""
- if CONTEXT.debug:
- print((" `- JDC sdAccessible : PAR_LOT =", self.parLot))
- return self.parLot == "NON"
-
- def getEtapesByName(self, name):
- listeDEtapes = []
- for e in self.etapes:
- if e.nom == name:
- listeDEtapes.append(e)
- return listeDEtapes
-
- def getEtapeByConceptName(self, conceptName):
- for e in self.etapes:
- if hasattr(e, "sdnom") and e.sdnom == conceptName:
- return e
-
- def _build_reserved_kw_list(self):
- """Construit la liste des mots-cles reserves (interdits pour le
- nommage des concepts)."""
- self._reserved_kw = set()
- # for cat in self.cata:
- cat = self.cata
- self._reserved_kw.update(
- # PN 14 2020 [kw for kw in dir(cat) if len(kw) <= 8 and kw == kw.upper()])
- [kw for kw in dir(cat)]
- )
- self._reserved_kw.difference_update(
- [
- "OPER",
- "MACRO",
- "BLOC",
- "SIMP",
- "FACT",
- "FORM",
- "GEOM",
- "MCSIMP",
- "MCFACT",
- ]
- )
-
- def prepareInsertInDB(self):
- debug = 1
- if debug:
- print("prepareInsertInDB traitement de ", self.nom)
- if hasattr(self, "dPrimaryKey"):
- dPrimaryKey = self.dPrimaryKey
- else:
- dPrimaryKey = {}
- if hasattr(self, "dElementsRecursifs"):
- dElementsRecursifs = self.dElementsRecursifs
- else:
- dElementsRecursifs = {}
- dictKey = {}
- if debug:
- print("dElementsRecursifs", dElementsRecursifs)
- if debug:
- print(
- "dPrimaryKey",
- dPrimaryKey,
- )
- for mc in dPrimaryKey.values():
- dictKey[mc] = None
- texte = ""
- for e in self.etapes:
- tc, tv, ta = e.prepareInsertInDB(dictKey, dElementsRecursifs, dPrimaryKey)
- texte += tc + tv + ta
- return texte
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe de definition JDC_CATA
- qui permet de spécifier les caractéristiques d'un JDC
-"""
-
-import types
-import traceback
-
-from . import N_ENTITE
-from . import N_JDC
-
-
-class JDC_CATA(N_ENTITE.ENTITE):
-
- """
- Classe pour definir un jeu de commandes
-
- Attributs de classe :
-
- - class_instance qui indique la classe qui devra etre utilisée
- pour créer l'objet qui servira à controler la conformité
- du jeu de commandes avec sa définition
-
- - label qui indique la nature de l'objet de définition (ici, JDC)
-
- """
-
- class_instance = N_JDC.JDC
- label = "JDC"
-
- def __init__(
- self,
- code="",
- execmodul=None,
- regles=(),
- niveaux=(),
- fichierSource=None,
- fr="",
- ang="",
- **args
- ):
- """
- on se laisse la possibilite d initier fichierSource avec autre chose que le nom du fichier
- au cas ou ... pour pouvoir changer le nom du 'sous code' implemente (cf readercata)
- """
- self.code = code
- self.fr = fr
- self.ang = ang
- self.execmodul = execmodul
- if type(regles) == tuple:
- self.regles = regles
- else:
- self.regles = (regles,)
- # Tous les arguments supplémentaires sont stockés dans l'attribut args
- # et seront passés au JDC pour initialiser ses paramètres propres
- self.args = args
- self.d_niveaux = {}
- self.lNiveaux = niveaux
- self.commandes = []
- self.fichierSource = fichierSource
- for niveau in niveaux:
- self.d_niveaux[niveau.nom] = niveau
- # On change d'objet catalogue. Il faut d'abord mettre le catalogue
- # courant à None
- CONTEXT.unsetCurrentCata()
- CONTEXT.setCurrentCata(self)
- self.fenetreIhm = None
- self.definitUserASSD = False
- self.definitUserASSDMultiple = False
- self.dictTypesXSD = {}
- self.dictTypesXSDJumeaux = {}
- self.dictTypesASSDorUserASSDCrees = {}
- self.dictTypesASSDorUserASSDUtilises = {}
- self.listeUserASSDDumpes = set()
- self.listeTypeTXMAvecBlancs = set()
-
- def __call__(
- self,
- procedure=None,
- cata=None,
- cata_ord_dico=None,
- nom="SansNom",
- parent=None,
- **args
- ):
- """
- Construit l'objet JDC a partir de sa definition (self),
- """
- return self.class_instance(
- definition=self,
- procedure=procedure,
- cata=cata,
- cata_ord_dico=cata_ord_dico,
- nom=nom,
- parent=parent,
- **args
- )
-
- def enregistre(self, commande):
- """
- Methode qui permet aux definitions de commandes de s'enregistrer aupres
- d'un JDC_CATA
- """
- self.commandes.append(commande)
-
- def verifCata(self):
- """
- Méthode de vérification des attributs de définition
- """
- self.checkRegles()
- self.verifCataRegles()
-
- def verifCataRegles(self):
- """
- Cette méthode vérifie pour tous les objets stockés dans la liste entités
- respectent les REGLES associés à self
- """
- # A FAIRE
-
- def report(self):
- """
- Methode pour produire un compte-rendu de validation d'un catalogue de commandes
- """
- self.cr = self.CR(
- debut="Compte-rendu de validation du catalogue " + self.code,
- fin="Fin Compte-rendu de validation du catalogue " + self.code,
- )
- self.verifCata()
- for commande in self.commandes:
- cr = commande.report()
- cr.debut = "Début Commande :" + commande.nom
- cr.fin = "Fin commande :" + commande.nom
- self.cr.add(cr)
- return self.cr
-
- def supprime(self):
- """
- Méthode pour supprimer les références arrières susceptibles de provoquer
- des cycles de références
- """
- for commande in self.commandes:
- commande.supprime()
-
- def getNiveau(self, nom_niveau):
- """
- Retourne l'objet de type NIVEAU de nom nom_niveau
- ou None s'il n'existe pas
- """
- return self.d_niveaux.get(nom_niveau, None)
-
- def dumpStructure(self):
- texte = ""
- for c in self.commandes:
- if not (c.label != "OPER") and not (c.label != "PROC"):
- continue
- if c.label == "OPER":
- texte += c.nom + " " + str(c.sd_prod) + "\n"
- if c.label == "PROC":
- texte += c.nom + " \n"
- texte += c.dumpStructure()
- return texte
-
- def dumpStringDataBase(self, nomDataBaseACreer):
- texte = "create database {}; \n".format(nomDataBaseACreer)
- texte += "create user admin{}; \n".format(nomDataBaseACreer)
- texte += "grant all privileges on database {} to admin{}; \n".format(
- nomDataBaseACreer, nomDataBaseACreer
- )
- texte += "********* fin de creation de la database ********* \n"
- dictPrimaryKey = {}
- dictRecursif = {}
- if hasattr(self.cata, "dPrimaryKey"):
- dPrimaryKey = self.cata.dPrimaryKey
- if hasattr(self.cata, "dElementsRecursifs"):
- dElementsRecursifs = self.cata.dElementsRecursifs
- for c in self.commandes:
- if not (c.label != "OPER") and not (c.label != "PROC"):
- continue # une macro ?
- texte += c.dumpStringDataBase(dPrimaryKey, dElementsRecursifs, {}, False)
- # print (texte)
- return texte
-
- def dumpGitStringFormat(self):
- texte = "git log --pretty=format:'"
- for c in self.commandes:
- if not (c.label != "OPER") and not (c.label != "PROC"):
- continue
- texte += "<ns1:{}>".format(c.nom)
- texte += c.dumpGitStringFormat()
- texte += "</ns1:{}>".format(c.nom)
- texte += "'"
- return texte
+++ /dev/null
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-from .N_ASSD import ASSD
-
-
-class LASSD(ASSD, list):
- pass
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-"""
- Ce module contient la classe de definition MACRO
- qui permet de spécifier les caractéristiques d'une macro-commande
-"""
-
-
-import types
-import traceback
-
-from . import N_ENTITE
-from . import N_MACRO_ETAPE
-from . import nommage
-
-
-class MACRO(N_ENTITE.ENTITE):
-
- """
- Classe pour definir une macro-commande
-
- Cette classe a trois attributs de classe
-
- - class_instance qui indique la classe qui devra etre utilisée
- pour créer l'objet qui servira à controler la conformité d'un
- macro-commande avec sa définition
-
- - label qui indique la nature de l'objet de définition (ici, MACRO)
-
- - nommage qui est un module Python qui fournit la fonctionnalité de nommage
-
- et les attributs d'instance suivants :
- - nom : son nom
- - op : le numéro d'opérateur
- - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
- une classe
- - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
- réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
- - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
- non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
- de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
- - fr : commentaire associé en francais
- - docu : clé de documentation associée
- - regles : liste des règles associées
- - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
- fonction est exécutée lors des phases d'initialisation de l'étape associée.
- - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
- rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
- Si niveau vaut None, l'opérateur est rangé au niveau global.
- - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
- des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
- est initialisé avec args, c'est à dire les arguments d'appel restants.
-
- """
-
- class_instance = N_MACRO_ETAPE.MACRO_ETAPE
- label = "MACRO"
- nommage = nommage
-
- def __init__(
- self,
- nom,
- op=None,
- sd_prod=None,
- reentrant="n",
- repetable="o",
- fr="",
- ang="",
- fenetreIhm=None,
- docu="",
- regles=(),
- op_init=None,
- niveau=None,
- fichier_ini=0,
- UIinfo=None,
- **args
- ):
- """
- Méthode d'initialisation de l'objet MACRO. Les arguments sont utilisés pour initialiser
- les attributs de meme nom
- """
- # XXX fichier_ini n'est pas utilisé pour l'instant
- self.nom = nom
- # op est obligatoire et permet de spécifier la procédure de construction de la macro
- # - Si op est un entier la construction de la macro est réalisée par une subroutine fortran opsxxx ou
- # xxx est donné par la valeur absolue de op. L'execution est egalement effectuée via cette subroutine.
- # - Si op est une fonction Python, la construction de la macro est effectuée par l'appel à cette fonction
- # Suivant le cas on garde l info dans self.op ou dans self.proc
- if type(op) == int:
- self.proc = None
- self.op = op
- else:
- self.op = None
- self.proc = op
-
- self.sd_prod = sd_prod
- self.reentrant = reentrant
- self.fr = fr
- self.ang = ang
- self.repetable = repetable
- self.docu = docu
- self.fenetreIhm = fenetreIhm
- if type(regles) == tuple:
- self.regles = regles
- else:
- self.regles = (regles,)
- self.fichier_ini = fichier_ini
- # Attribut op_init : Fonction a appeler a la construction de l
- # operateur sauf si == None
- self.op_init = op_init
- self.entites = args
- current_cata = CONTEXT.getCurrentCata()
- if niveau == None:
- self.niveau = None
- current_cata.enregistre(self)
- else:
- self.niveau = current_cata.getNiveau(niveau)
- self.niveau.enregistre(self)
- self.UIinfo = UIinfo
- self.affecter_parente()
- self.checkDefinition(self.nom)
-
- def __call__(self, reuse=None, **args):
- """
- Construit l'objet MACRO_ETAPE a partir de sa definition (self),
- puis demande la construction de ses sous-objets et du concept produit.
- """
- nomsd = self.nommage.getNomConceptResultat(self.nom)
- etape = self.class_instance(oper=self, reuse=reuse, args=args)
- etape.MCBuild()
- return etape.buildSd(nomsd)
-
- def make_objet(self, mc_list="oui"):
- """
- Cette méthode crée l'objet MACRO_ETAPE dont la définition est self sans
- créer sa sdprod.
- Normalement l'étape est enregistrée auprès de son parent.
- Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
- des objets MCxxx.
- """
- etape = self.class_instance(oper=self, reuse=None, args={})
- if mc_list == "oui":
- etape.MCBuild()
- return etape
-
- def verifCata(self):
- """
- Méthode de vérification des attributs de définition
- """
- self.checkOp(valmax=0)
- self.checkProc()
- self.checkRegles()
- self.checkFr()
- self.checkDocu()
- self.checkNom()
- self.checkReentrant()
- self.verifCataRegles()
-
- def supprime(self):
- """
- Méthode pour supprimer les références arrières susceptibles de provoquer
- des cycles de références
- """
- self.niveau = None
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe MACRO_ETAPE qui sert a verifier et a executer
- une commande
-"""
-
-# Modules Python
-from builtins import str
-import types
-import sys
-import traceback
-from warnings import warn
-
-# Modules EFICAS
-from . import N_MCCOMPO
-from . import N_ETAPE
-from .N_Exception import AsException
-from . import N_utils
-from .N_utils import AsType
-from .N_CO import CO
-from .N_ASSD import ASSD
-
-
-class MACRO_ETAPE(N_ETAPE.ETAPE):
-
- """ """
-
- nature = "COMMANDE"
- typeCO = CO
-
- def __init__(self, oper=None, reuse=None, args={}):
- """
- Attributs :
- - definition : objet portant les attributs de definition d'une etape
- de type macro-commande. Il est initialise par
- l'argument oper.
- - reuse : indique le concept d'entree reutilise. Il se trouvera donc
- en sortie si les conditions d'execution de l'operateur
- l'autorise
- - valeur : arguments d'entree de type mot-cle=valeur. Initialise
- avec l'argument args.
- """
- N_ETAPE.ETAPE.__init__(self, oper, reuse, args, niveau=5)
- self.g_context = {}
- # Contexte courant
- self.currentContext = {}
- self.macro_const_context = {}
- self.index_etape_courante = 0
- self.etapes = []
- self.index_etapes = {}
- # Dans le cas d'une macro ecrite en Python, l'attribut Outputs est un
- # dictionnaire qui contient les concepts produits de sortie
- # (nom : ASSD) declares dans la fonction sd_prod
- self.Outputs = {}
- self.sdprods = []
- self.UserError = "UserError"
- # permet de stocker le nom du dernier concept nomme dans la macro
- self.last = None
-
- def makeRegister(self):
- """
- Initialise les attributs jdc, id, niveau et realise les enregistrements
- necessaires
- """
- N_ETAPE.ETAPE.makeRegister(self)
- if self.parent:
- self.UserError = self.jdc.UserError
- else:
- self.UserError = "UserError"
-
- def buildSd(self, nom):
- """
- Construit le concept produit de l'operateur. Deux cas
- peuvent se presenter :
-
- - le parent n'est pas defini. Dans ce cas, l'etape prend en charge
- la creation et le nommage du concept.
-
- - le parent est defini. Dans ce cas, l'etape demande au parent la
- creation et le nommage du concept.
-
- """
- self.sdnom = nom
- try:
- # On positionne la macro self en tant que current_step pour que les
- # etapes creees lors de l'appel a sd_prod et a op_init aient la macro
- # comme parent
- self.setCurrentStep()
- if self.parent:
- sd = self.parent.createSdprod(self, nom)
- if type(self.definition.op_init) == types.FunctionType:
- self.definition.op_init(*(self, self.parent.g_context))
- else:
- sd = self.getSdProd()
- if sd != None and self.reuse == None:
- # On ne nomme le concept que dans le cas de non reutilisation
- # d un concept
- sd.setName(nom)
- self.resetCurrentStep()
- except AsException as e:
- self.resetCurrentStep()
- raise AsException(
- "Etape ",
- self.nom,
- "ligne : ",
- self.appel[0],
- "fichier : ",
- self.appel[1],
- e,
- )
- # except (EOFError, self.UserError):
- except EOFError:
- # Le retablissement du step courant n'est pas strictement
- # necessaire. On le fait pour des raisons de coherence
- self.resetCurrentStep()
- raise
- except:
- self.resetCurrentStep()
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- raise AsException(
- "Etape ",
- self.nom,
- "ligne : ",
- self.appel[0],
- "fichier : ",
- self.appel[1] + "\n",
- "".join(l),
- )
-
- self.Execute()
- return sd
-
- def getSdProd(self):
- """
- Retourne le concept resultat d'une macro etape
- La difference avec une etape ou une proc-etape tient a ce que
- le concept produit peut exister ou pas
-
- Si sd_prod == None le concept produit n existe pas on retourne None
-
- Deux cas :
- - cas 1 : sd_prod n'est pas une fonction
- il s'agit d'une sous classe de ASSD
- on construit le sd a partir de cette classe
- et on le retourne
- - cas 2 : sd_prod est une fonction
- on l'evalue avec les mots-cles de l'etape (mcListe)
- on construit le sd a partir de la classe obtenue
- et on le retourne
- """
- sd_prod = self.definition.sd_prod
- self.typret = None
-
- if type(self.definition.sd_prod) == types.FunctionType:
- d = self.creeDictValeurs(self.mcListe)
- try:
- # la sd_prod d'une macro a l'objet macro_etape lui meme en premier argument
- # Comme sd_prod peut invoquer la methode typeSDProd qui ajoute
- # les concepts produits dans self.sdprods, il faut le mettre a
- # zero avant de l'appeler
- self.sdprods = []
- sd_prod = sd_prod(*(self,), **d)
- # except (EOFError, self.UserError):
- except EOFError:
- raise
- except Exception as exc:
- if CONTEXT.debug:
- traceback.print_exc()
- raise AsException(
- "impossible d affecter un type au resultat:", str(exc)
- )
-
- # on teste maintenant si la SD est reutilisee ou s'il faut la creer
- if self.definition.reentrant != "n" and self.reuse:
- # Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale.
- # Elle sera traitee ulterieurement.
- self.sd = self.reuse
- else:
- if sd_prod == None:
- self.sd = None
- else:
- self.sd = sd_prod(etape=self)
- self.typret = sd_prod
- # Si la commande est obligatoirement reentrante et reuse n'a pas ete specifie, c'est une erreur.
- # On ne fait rien ici. L'erreur sera traitee par la suite.
- # precaution
- if self.sd is not None and not isinstance(self.sd, ASSD):
- raise AsException(
- """
-Impossible de typer le resultat !
-Causes possibles :
- Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,
- soit il y a une "," a la fin d'une commande precedente.
- Developpeur : La fonction "sd_prod" retourne un type invalide."""
- )
- return self.sd
-
- def getType_produit(self, force=0):
- try:
- return self.getType_produit_brut(force)
- except:
- # traceback.print_exc()
- return None
-
- def getType_produit_brut(self, force=0):
- """
- Retourne le type du concept resultat de l'etape et eventuellement type
- les concepts produits "a droite" du signe egal (en entree)
-
- Deux cas :
- - cas 1 : sd_prod de oper n'est pas une fonction
- il s'agit d'une sous classe de ASSD
- on retourne le nom de la classe
- - cas 2 : il s'agit d'une fonction
- on l'evalue avec les mots-cles de l'etape (mcListe)
- et on retourne son resultat
- """
- if not force and hasattr(self, "typret"):
- return self.typret
-
- if type(self.definition.sd_prod) == types.FunctionType:
- d = self.creeDictValeurs(self.mcListe)
- # Comme sd_prod peut invoquer la methode typeSDProd qui ajoute
- # les concepts produits dans self.sdprods, il faut le mettre a zero
- self.sdprods = []
- sd_prod = self.definition.sd_prod(*(self,), **d)
- else:
- sd_prod = self.definition.sd_prod
- return sd_prod
-
- def getContexteAvant(self, etape):
- """
- Retourne le dictionnaire des concepts connus avant etape
- pour les commandes internes a la macro
- On tient compte des commandes qui modifient le contexte
- comme DETRUIRE ou les macros
- """
- # L'etape courante pour laquelle le contexte a ete calcule est
- # memorisee dans self.index_etape_courante
- # self.currentContext.items() if isinstance(v, ASSD)])
- d = self.currentContext = self.g_context.copy()
- if etape is None:
- return d
- # retirer les sd produites par 'etape'
- sd_names = [sd.nom for sd in etape.getCreated_sd()]
- for nom in sd_names:
- try:
- del d[nom]
- except KeyError:
- pass
- # Exemple avec INCLUDE_MATERIAU appele dans une macro.
- # Les fonctions restent uniquement dans le contexte de INCLUDE_MATERIAU,
- # elles ne sont donc pas dans le contexte de la macro appelante.
- # from warnings import warn
- # warn("concept '%s' absent du contexte de %s" % (nom, self.nom),
- # RuntimeWarning, stacklevel=2)
- return d
-
- def supprime(self):
- """
- Methode qui supprime toutes les references arrières afin que
- l'objet puisse etre correctement detruit par le garbage collector
- """
- N_MCCOMPO.MCCOMPO.supprime(self)
- self.jdc = None
- self.appel = None
- if self.sd:
- self.sd.supprime()
- for concept in self.sdprods:
- concept.supprime()
- for etape in self.etapes:
- etape.supprime()
-
- def clean(self, netapes):
- """Nettoie les `netapes` dernières etapes de la liste des etapes."""
- if self.jdc.hist_etape:
- return
- for i in range(netapes):
- e = self.etapes.pop()
- jdc = e.jdc
- parent = e.parent
- e.supprime()
- e.parent = parent
- e.jdc = jdc
- del self.index_etapes[e]
-
- def typeSDProd(self, co, t):
- """
- Cette methode a pour fonction de typer le concept co avec le type t
- dans les conditions suivantes :
- 1. co est un concept produit de self
- 2. co est un concept libre : on le type et on l attribue a self
-
- Elle enregistre egalement les concepts produits (on fait l hypothese
- que la liste sdprods a ete correctement initialisee, vide probablement)
- """
- if not hasattr(co, "etape"):
- # Le concept vaut None probablement. On ignore l'appel
- return
- #
- # On cherche a discriminer les differents cas de typage d'un concept
- # produit par une macro qui est specifie dans un mot cle simple.
- # On peut passer plusieurs fois par typeSDProd ce qui explique
- # le nombre important de cas.
- #
- # Cas 1 : Le concept est libre. Il vient d'etre cree par CO(nom)
- # Cas 2 : Le concept est produit par la macro. On est deja passe par typeSDProd.
- # Cas semblable a Cas 1.
- # Cas 3 : Le concept est produit par la macro englobante (parent). On transfere
- # la propriete du concept de la macro parent a la macro courante (self)
- # en verifiant que le type est valide
- # Cas 4 : La concept est la propriete d'une etape fille. Ceci veut dire qu'on est
- # deja passe par typeSDProd et que la propriete a ete transfere a une
- # etape fille. Cas semblable a Cas 3.
- # Cas 5 : Le concept est produit par une etape externe a la macro.
- #
- if co.etape == None:
- # Cas 1 : le concept est libre
- # On l'attache a la macro et on change son type dans le type demande
- # Recherche du mot cle simple associe au concept
- mcs = self.getMcsWithCo(co)
- if len(mcs) != 1:
- raise AsException(
- """Erreur interne.
-Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)"""
- % co
- )
- mcs = mcs[0]
- if not self.typeCO in mcs.definition.type:
- raise AsException(
- """Erreur interne.
-Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)"""
- % (co, mcs.definition.type)
- )
- co.etape = self
- # affectation du bon type du concept
- co.changeType(t)
- self.sdprods.append(co)
-
- elif co.etape == self:
- # Cas 2 : le concept est produit par la macro (self)
- # On est deja passe par typeSDProd (Cas 1 ou 3).
- # XXX Peut-il etre creer par une autre macro ?
- # On verifie juste que c'est un vrai CO non deja type
- # if co.etape == co._etape:
- if co.isTypCO() == 1:
- # Le concept a ete cree par la macro (self)
- # On peut changer son type
- co.changeType(t)
- else:
- # Le concept a ete cree par une macro parente
- # Le type du concept doit etre coherent avec le type demande
- # (seulement derive)
- if not isinstance(co, t):
- raise AsException(
- """Erreur interne.
-Le type demande (%s) et le type du concept (%s) devraient etre derives"""
- % (t, co.__class__)
- )
-
- self.sdprods.append(co)
-
- elif co.etape == self.parent:
- # Cas 3 : le concept est produit par la macro parente (self.parent)
- # on transfere la propriete du concept a la macro fille
- # et on change le type du concept comme demande
- # Au prealable, on verifie que le concept existant (co) est une instance
- # possible du type demande (t)
- # Cette règle est normalement coherente avec les règles de
- # verification des mots-cles
- if not isinstance(co, t):
- raise AsException(
- """
-Impossible de changer le type du concept produit (%s) en (%s).
-Le type actuel (%s) devrait etre une classe derivee du nouveau type (%s)"""
- % (co, t, co.__class__, t)
- )
- mcs = self.getMcsWithCo(co)
- if len(mcs) != 1:
- raise AsException(
- """Erreur interne.
-Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)"""
- % co
- )
- mcs = mcs[0]
- if not self.typeCO in mcs.definition.type:
- raise AsException(
- """Erreur interne.
-Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)"""
- % (co, mcs.definition.type)
- )
- co.etape = self
- # On ne change pas le type car il respecte la condition isinstance(co,t)
- # co.__class__ = t
- self.sdprods.append(co)
-
- elif self.issubstep(co.etape):
- # Cas 4 : Le concept est propriete d'une sous etape de la macro (self).
- # On est deja passe par typeSDProd (Cas 3 ou 1).
- # Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
- # Le type du concept et t doivent etre derives.
- # Il n'y a aucune raison pour que la condition ne soit pas
- # verifiee.
- if not isinstance(co, t):
- raise AsException(
- """Erreur interne.
-Le type demande (%s) et le type du concept (%s) devraient etre derives"""
- % (t, co.__class__)
- )
- self.sdprods.append(co)
-
- else:
- # Cas 5 : le concept est produit par une autre etape
- # On ne fait rien
- return
-
- def issubstep(self, etape):
- """
- Cette methode retourne un entier indiquant si etape est une
- sous etape de la macro self ou non
- 1 = oui
- 0 = non
- """
- if etape in self.etapes:
- return 1
- for etap in self.etapes:
- if etap.issubstep(etape):
- return 1
- return 0
-
- def register(self, etape):
- """
- Enregistrement de etape dans le contexte de la macro : liste etapes
- et demande d enregistrement global aupres du JDC
- """
- self.etapes.append(etape)
- self.index_etapes[etape] = len(self.etapes) - 1
- idetape = self.jdc.gRegister(etape)
- return idetape
-
- def regSD(self, sd):
- """
- Methode appelee dans l __init__ d un ASSD a sa creation pour
- s enregistrer (reserve aux ASSD crees au sein d'une MACRO)
- """
- return self.jdc.o_register(sd)
-
- def createSdprod(self, etape, nomsd):
- """
- Cette methode doit fabriquer le concept produit retourne
- par l'etape etape et le nommer.
-
- Elle est appelee a l'initiative de l'etape
- pendant le processus de construction de cette etape : methode __call__
- de la classe CMD (OPER ou MACRO)
- Ce travail est realise par le contexte superieur (etape.parent)
- car dans certains cas, le concept ne doit pas etre fabrique mais
- l'etape doit simplement utiliser un concept preexistant.
- - Cas 1 : etape.reuse != None : le concept est reutilise
- - Cas 2 : l'etape appartient a une macro qui a declare un concept
- de sortie qui doit etre produit par cette etape.
- """
- if nomsd in self.Outputs:
- # Il s'agit d'un concept de sortie de la macro. Il ne faut pas le creer
- # Il faut quand meme appeler la fonction sd_prod si elle existe.
- # getType_produit le fait et donne le type attendu par la commande
- # pour verification ulterieure.
- sdprod = etape.getType_produit_brut()
- sd = self.Outputs[nomsd]
- # On verifie que le type du concept existant sd.__class__ est un sur type de celui attendu
- # Cette règle est normalement coherente avec les règles de
- # verification des mots-cles
- if not issubclass(sdprod, sd.__class__):
- raise AsException(
- "Le type du concept produit %s devrait etre une sur classe de %s"
- % (sd.__class__, sdprod)
- )
- # La propriete du concept est transferee a l'etape avec le type
- # attendu par l'etape
- etape.sd = sd
- sd.etape = etape
- if (
- self.reuse == sd
- and etape.reuse != sd
- and getattr(sd, "executed", 0) == 1
- ): # n'a pas ete pas detruit
- raise AsException(
- "Le concept '%s' est reentrant dans la macro-commande %s. "
- "Il devrait donc l'etre dans %s (produit sous le nom '%s')."
- % (sd.nom, self.nom, etape.nom, nomsd)
- )
- # On donne au concept le type produit par la sous commande.
- # Le principe est le suivant : apres avoir verifie que le type deduit par la sous commande
- # est bien coherent avec celui initialement affecte par la macro (voir ci dessus)
- # on affecte au concept ce type car il peut etre plus precis
- # (derive, en general)
- sd.__class__ = sdprod
- # On force egalement le nom stocke dans l'attribut sdnom : on lui donne le nom
- # du concept associe a nomsd
- etape.sdnom = sd.nom
- # pour l'ajouter au contexte de la macro
- self.g_context[sd.nom] = sd
- elif etape.definition.reentrant != "n" and etape.reuse != None:
- # On est dans le cas d'une commande avec reutilisation d'un concept existant
- # getSdProd fait le necessaire : verifications, associations, etc. mais ne cree
- # pas un nouveau concept. Il retourne le concept reutilise
- sd = etape.getSdProd()
- # Dans le cas d'un concept nomme automatiquement : _xxx, __xxx,
- # On force le nom stocke dans l'attribut sdnom de l'objet etape : on lui donne le nom
- # du concept reutilise (sd ou etape.reuse c'est pareil)
- # Ceci est indispensable pour eviter des erreurs lors des verifications des macros
- # En effet une commande avec reutilisation d'un concept verifie que le nom de
- # la variable a gauche du signe = est le meme que celui du concept reutilise.
- # Lorsqu'une telle commande apparait dans une macro, on supprime
- # cette verification.
- if etape.sdnom == "" or etape.sdnom[0] == "_":
- etape.sdnom = sd.nom
- else:
- # On est dans le cas de la creation d'un nouveau concept
- sd = etape.getSdProd()
- if sd != None:
- self.nommerSDProd(sd, nomsd)
- return sd
-
- def nommerSDProd(self, sd, sdnom, restrict="non"):
- """
- Cette methode est appelee par les etapes internes de la macro.
- La macro appelle le JDC pour valider le nommage.
- On considère que l'espace de nom est unique et gere par le JDC.
- Si le nom est deja utilise, l'appel lève une exception.
- Si restrict=='non', on insère le concept dans le contexte du parent de la macro.
- Si restrict=='oui', on insère le concept uniquement dans le contexte de la macro.
- """
- # Normalement, lorsqu'on appelle cette methode, on ne veut nommer que des concepts nouvellement crees.
- # Le filtrage sur les concepts a creer ou a ne pas creer est fait dans la methode
- # createSdprod. La seule chose a verifier apres conversion eventuelle du nom
- # est de verifier que le nom n'est pas deja attribue. Ceci est fait en delegant
- # au JDC par l'intermediaire du parent.
- if sdnom in self.Outputs:
- # Il s'agit d'un concept de sortie de la macro produit par une
- # sous commande
- sdnom = self.Outputs[sdnom].nom
- elif len(sdnom) > 0:
- if sdnom[0] in ("_", ".") and sdnom[1:].isdigit():
- # il est deja de la forme _9000012 ou .9000017
- pass
- elif sdnom[0] == "_":
- # Si le nom du concept commence par le caractère '_', on lui attribue
- # un identificateur JEVEUX construit par gcncon.
- # nom commençant par __ : il s'agit de concepts qui seront detruits
- # nom commençant par _ : il s'agit de concepts intermediaires
- # qui seront gardes
- if len(sdnom) > 1 and sdnom[1] == "_":
- sdnom = self.gcncon(".")
- else:
- sdnom = self.gcncon("_")
- elif self.nom in ("INCLUDE", "MACR_RECAL"):
- # dans le cas d'INCLUDE, on passe
- # MACR_RECAL fonctionne comme INCLUDE
- pass
- else:
- # On est dans le cas d'un nom de concept global
- # XXX a voir, creation de CO() dans CALC_ESSAI (sdls139a)
- if not sd.isTypCO():
- raise AsException(
- "Resultat non declare par la macro %s : %s" % (self.nom, sdnom)
- )
- self.last = sdnom
- if restrict == "non":
- # On demande le nommage au parent mais sans ajout du concept dans le contexte du parent
- # car on va l'ajouter dans le contexte de la macro
- self.parent.nommerSDProd(sd, sdnom, restrict="oui")
- # On ajoute dans le contexte de la macro les concepts nommes
- # Ceci est indispensable pour les CO (macro) dans un INCLUDE
- self.g_context[sdnom] = sd
- else:
- # La demande de nommage vient probablement d'une macro qui a mis
- # le concept dans son contexte. On ne traite plus que le nommage (restrict="oui")
- self.parent.nommerSDProd(sd, sdnom, restrict="oui")
-
- def deleteConceptAfterEtape(self, etape, sd):
- """
- Met a jour les etapes de la MACRO qui sont après etape suite a
- la disparition du concept sd
- """
- # Cette methode est definie dans le noyau mais ne sert que pendant la phase de creation
- # des etapes et des concepts. Il n'y a aucun traitement particulier a realiser
- # Dans d'autres conditions, il faudrait surcharger cette methode.
- return
-
- def getCreated_sd(self):
- """Retourne la liste des sd reellement produites par l'etape.
- Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans
- cette liste."""
- sdprods = self.sdprods[:]
- if not self.reuse and self.sd:
- sdprods.append(self.sd)
- return sdprods
-
- def getLastConcept(self):
- """Retourne le dernier concept produit dans la macro.
- Peut-etre utile pour acceder au contenu 'fortran' dans une
- clause 'except'."""
- return self.g_context.get(self.last, None)
-
- def accept(self, visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitMACRO_ETAPE(self)
-
- def updateContext(self, d):
- """
- Met a jour le contexte contenu dans le dictionnaire d
- Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
- Une fonction enregistree dans op_init peut egalement modifier le contexte
- """
- if type(self.definition.op_init) == types.FunctionType:
- self.definition.op_init(*(self, d))
- if self.sd != None:
- d[self.sd.nom] = self.sd
- for co in self.sdprods:
- d[co.nom] = co
-
- def makeInclude(self, unite=None, fname=None):
- """Inclut un fichier dont l'unite logique est `unite` ou de nom `fname`"""
- if unite is not None:
- warn(
- "'unite' is deprecated, please use 'fname' instead",
- DeprecationWarning,
- stacklevel=2,
- )
- fname = "fort.%s" % unite
- if not fname:
- return
- f, text = self.getFile(fic_origine=self.parent.nom, fname=fname)
- self.fichier_init = f
- if f == None:
- return
- self.makeContexte(f, text)
-
- def makePoursuite(self):
- """Inclut un fichier poursuite"""
- raise NotImplementedError("this method must be derivated (in Eficas)")
-
- def makeContexte(self, f, text):
- """
- Interprete le texte fourni (text) issu du fichier f
- dans le contexte du parent.
- Cette methode est utile pour le fonctionnement des
- INCLUDE
- """
- # on execute le texte fourni dans le contexte forme par
- # le contexte de l etape pere (global au sens Python)
- # et le contexte de l etape (local au sens Python)
- code = compile(text, f, "exec")
- d = self.g_context = self.macro_const_context
- globs = self.getGlobalContexte()
- d.update(globs)
- exec(code, globs, d)
- # pour ne pas conserver des references sur tout
- self.macro_const_context = {}
-
- def getGlobalContexte(self):
- """
- Cette methode retourne le contexte global fourni
- par le parent(self) a une etape fille (l'appelant) pour
- realiser des evaluations de texte Python (INCLUDE,...)
- """
- # Le contexte global est forme par concatenation du contexte
- # du parent de self et de celui de l'etape elle meme (self)
- # Pour les concepts, cela ne doit rien changer. Mais pour les constantes,
- # les valeurs de getContexteAvant sont moins recentes que dans
- # getGlobalContexte. On prend donc la precaution de ne pas ecraser
- # ce qui y est deja.
- d = self.parent.getGlobalContexte()
- d.update(self.g_context)
- d.update(
- [
- (k, v)
- for k, v in list(self.parent.getContexteAvant(self).items())
- if d.get(k) is None
- ]
- )
- return d
-
- def getContexteCourant(self, etape_fille_du_jdc=None):
- """
- Retourne le contexte tel qu'il est au moment de l'execution de
- l'etape courante.
- """
- ctx = {}
- # update car par ricochet on modifierait jdc.currentContext
- ctx.update(self.parent.getContexteCourant(self))
- # on peut mettre None car toujours en PAR_LOT='NON', donc la dernière
- ctx.update(self.getContexteAvant(None))
- return ctx
-
- def getConcept(self, nomsd):
- """
- Methode pour recuperer un concept a partir de son nom
- dans le contexte du jdc connu avant l'execution de la macro courante.
- """
- # chercher dans self.getContexteAvant, puis si non trouve
- # self.parent.getConcept est peut-etre plus performant
- co = self.getContexteCourant().get(nomsd.strip(), None)
- if not isinstance(co, ASSD):
- co = None
- return co
-
- def getConceptByType(self, nomsd, typesd, etape=None):
- """
- Methode pour recuperer un concept a partir de son nom et de son type.
- Il aura comme père 'etape' (ou la macro courante si etape est absente).
- """
- return self.parent.getConceptByType(nomsd, typesd, etape=etape or self)
-
- def copy(self):
- """Methode qui retourne une copie de self non enregistree auprès du JDC
- et sans sd
- On surcharge la methode de ETAPE pour exprimer que les concepts crees
- par la MACRO d'origine ne sont pas crees par la copie mais eventuellement
- seulement utilises
- """
- etape = N_ETAPE.ETAPE.copy(self)
- etape.sdprods = []
- return etape
-
- def copyIntern(self, etape):
- """Cette methode effectue la recopie des etapes internes d'une macro
- passee en argument (etape)
- """
- self.etapes = []
- self.index_etapes = {}
- for etp in etape.etapes:
- new_etp = etp.copy()
- new_etp.copyReuse(etp)
- new_etp.copySdnom(etp)
- new_etp.reparent(self)
- if etp.sd:
- new_sd = etp.sd.__class__(etape=new_etp)
- new_etp.sd = new_sd
- if etp.reuse:
- new_sd.setName(etp.sd.nom)
- else:
- self.nommerSDProd(new_sd, etp.sd.nom)
- new_etp.copyIntern(etp)
- self.etapes.append(new_etp)
- self.index_etapes[new_etp] = len(self.etapes) - 1
-
- def resetJdc(self, new_jdc):
- """
- Reinitialise l'etape avec un nouveau jdc parent new_jdc
- """
- if self.sd and self.reuse == None:
- self.parent.nommerSDProd(self.sd, self.sd.nom)
- for concept in self.sdprods:
- self.parent.nommerSDProd(concept, concept.nom)
-
- def reparent(self, parent):
- """
- Cette methode sert a reinitialiser la parente de l'objet
- """
- N_ETAPE.ETAPE.reparent(self, parent)
- # on ne change pas la parente des concepts. On s'assure uniquement que
- # le jdc en reference est le bon
- for concept in self.sdprods:
- concept.jdc = self.jdc
- for e in self.etapes:
- e.reparent(self)
-
- def updateConstContext(self, d):
- """
- Met a jour le contexte des constantes pour l'evaluation de
- formules dans la macro.
- """
- # Dans le jdc, const_context est mis a jour par execCompile
- # Dans la macro, on n'a pas le code a compiler pour recupèrer les
- # constantes locales a la macro. On demande donc explicitement de
- # definir les constantes "locales".
- self.macro_const_context.update(d)
-
- def sdAccessible(self):
- """On peut acceder aux "valeurs" (jeveux) des ASSD dans
- les macro-commandes qui sont localement en PAR_LOT="NON"
- sauf pour INCLUDE.
- """
- if CONTEXT.debug:
- print((" `- MACRO sdAccessible :", self.nom))
- return self.parent.sdAccessible() or not self.isInclude()
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe MCBLOC qui sert à controler la valeur
- d'un bloc de mots-clés par rapport à sa définition portée par un objet
- de type ENTITE
-"""
-
-
-import types
-
-from . import N_MCCOMPO
-
-
-class MCBLOC(N_MCCOMPO.MCCOMPO):
-
- """
- Classe support d'un bloc de mots-clés.
-
- """
-
- nature = "MCBLOC"
-
- def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction=None):
- """
- Attributs :
-
- - val : valeur du bloc (dictionnaire dont les clés sont des noms de mots-clés et les valeurs
- les valeurs des mots-clés)
- - definition : objet de définition de type BLOC associé au bloc (porte les attributs de définition)
- - nom : nom du bloc. Ce nom lui est donné par celui qui crée le bloc de mot-clé
- - parent : le créateur du bloc. Ce peut etre un mot-clé facteur ou un autre objet composite de type
- OBJECT. Si parent vaut None, le bloc ne possède pas de contexte englobant.
- - mcListe : liste des sous-objets du bloc construite par appel à la méthode buildMc
- """
- # print ('MCBLOC' , val, definition, nom, parent)
- self.definition = definition
- self.nom = nom
- self.val = val
- self.parent = parent
- self.valeur = val
- self.objPyxbDeConstruction = None
- self.dicoPyxbDeConstruction = dicoPyxbDeConstruction
- self.estIdentifiePar = None
- if parent:
- self.jdc = self.parent.jdc
- self.niveau = self.parent.niveau
- self.etape = self.parent.etape
- else:
- # Le mot cle a été créé sans parent
- self.jdc = None
- self.niveau = None
- self.etape = None
- self.mcListe = self.buildMc()
-
- def getValeur(self):
- """
- Retourne la "valeur" de l'objet bloc. Il s'agit d'un dictionnaire dont
- les clés seront les noms des objets de self.mcListe et les valeurs
- les valeurs des objets de self.mcListe obtenues par application de
- la méthode getValeur.
-
- Dans le cas particulier d'un objet bloc les éléments du dictionnaire
- obtenu par appel de la méthode getValeur sont intégrés au niveau
- supérieur.
-
- """
- dico = {}
- for mocle in self.mcListe:
- if mocle.isBLOC():
- # Si mocle est un BLOC, on inclut ses items dans le dictionnaire
- # représentatif de la valeur de self. Les mots-clés fils de blocs sont
- # donc remontés au niveau supérieur.
- dico.update(mocle.getValeur())
- else:
- dico[mocle.nom] = mocle.getValeur()
-
- # On rajoute tous les autres mots-clés locaux possibles avec la valeur
- # par défaut ou None
- # Pour les mots-clés facteurs, on ne traite que ceux avec statut défaut ('d')
- # et caché ('c')
- # On n'ajoute aucune information sur les blocs. Ils n'ont pas de défaut seulement
- # une condition.
- for k, v in list(self.definition.entites.items()):
- if not k in dico:
- if v.label == "SIMP":
- # Mot clé simple
- dico[k] = v.defaut
- elif v.label == "FACT":
- if v.statut in ("c", "d"):
- # Mot clé facteur avec défaut ou caché provisoire
- dico[k] = v(val=None, nom=k, parent=self)
- # On demande la suppression des pointeurs arrieres
- # pour briser les eventuels cycles
- dico[k].supprime()
- else:
- dico[k] = None
-
- return dico
-
- def isBLOC(self):
- """
- Indique si l'objet est un BLOC
- """
- return 1
-
- def accept(self, visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitMCBLOC(self)
-
- def makeobjet(self):
- return self.definition(val=None, nom=self.nom, parent=self.parent)
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe MCCOMPO qui sert à factoriser les comportements
- des OBJECT composites
-"""
-
-from copy import copy
-from . import N_OBJECT
-
-
-class MCCOMPO(N_OBJECT.OBJECT):
- """
- Classe support d'un OBJECT composite
-
- """
-
- def buildMc(self):
- """
- Construit la liste des sous-entites du MCCOMPO
- à partir du dictionnaire des arguments (valeur)
- """
-
- # import traceback
- # traceback.print_stack()
- # print(("MCCOMPO.buildMc _____________________________________", self.nom))
- if CONTEXT.debug:
- print(("MCCOMPO.buildMc ", self.nom))
- # Dans la phase de reconstruction args peut contenir des mots-clés
- # qui ne sont pas dans le dictionnaire des entites de definition (self.definition.entites)
- # de l'objet courant (self)
- # mais qui sont malgré tout des descendants de l'objet courant
- # (petits-fils, ...)
- args = self.valeur
- # print ('MCCOMPO___________________', self.valeur)
- if args == None:
- args = {}
- mcListe = []
-
- # On recopie le dictionnaire des arguments pour protéger l'original des
- # delete (del args[k])
- args = args.copy()
-
- # Phase 1:
- # On construit les sous entites presentes ou obligatoires
- # 1- les entites présentes dans les arguments et dans la définition
- # 2- les entités non présentes dans les arguments, présentes dans la définition avec un défaut
- # Phase 1.1 : on traite d'abord les SIMP pour enregistrer les mots cles
- # globaux
- if not hasattr(self, "dicoPyxbDeConstruction"):
- self.dicoPyxbDeConstruction = {}
- for k, v in list(self.definition.entites.items()):
- if v.label != "SIMP":
- continue
- if k in args or v.statut in ("o", "d"):
- #
- # Creation par appel de la methode __call__ de la definition de la sous entite k de self
- # si une valeur existe dans args ou est obligatoire (generique si toutes les
- # entites ont l attribut statut )
- #
- if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction:
- objPyxbDeConstruction = self.dicoPyxbDeConstruction[k]
- del self.dicoPyxbDeConstruction[k]
- else:
- objPyxbDeConstruction = None
- # print (args.get(k, None))
- objet = v(
- val=args.get(k, None),
- nom=k,
- parent=self,
- objPyxbDeConstruction=objPyxbDeConstruction,
- )
- mcListe.append(objet)
- # Si l'objet a une position globale on l'ajoute aux listes
- # correspondantes
- if hasattr(objet.definition, "position"):
- if objet.definition.position == "global":
- self.append_mc_global(objet)
- if objet.definition.position == "reCalculeEtape":
- # print ('-------------------------- rencontre reCalculeEtape: ', objet.nom)
- self.append_mc_global_avecRecalcule(objet)
- elif objet.definition.position == "global_jdc":
- self.append_mc_global_jdc(objet)
- if k in args:
- del args[k]
-
- # Phase 1.2 : on traite les autres entites que SIMP
- # FACT ou listeDeFAct en fait car un BLOC ne peut etre present dans les args
- for k, v in list(self.definition.entites.items()):
- if v.label == "SIMP":
- continue
- if k in args or v.statut == "o":
- # print ('construit', k)
- #
- # Creation par appel de la methode __call__ de la definition de la sous entite k de self
- # si une valeur existe dans args ou est obligatoire (generique si toutes les
- # entites ont l attribut statut )
- #
- if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction:
- dicoPyxbDeConstruction = self.dicoPyxbDeConstruction[k]
- del self.dicoPyxbDeConstruction[k]
- else:
- dicoPyxbDeConstruction = None
- objet = v(
- val=args.get(k, None),
- nom=k,
- parent=self,
- dicoPyxbDeConstruction=dicoPyxbDeConstruction,
- )
- mcListe.append(objet)
- if k in args:
- del args[k]
-
- # Phase 2:
- # On construit les objets (en général, blocs) conditionnés par les mots-clés précédemment créés.
- # A ce stade, mcListe ne contient que les fils de l'objet courant
- # args ne contient plus que des mots-clés qui n'ont pas été attribués car ils sont
- # à attribuer à des blocs du niveau inférieur ou bien sont des mots-clés erronés
- for k, v in list(self.definition.entites.items()):
- if v.label != "BLOC":
- continue
- # PNPN on recalcule dico_valeurs dans le for
- # pour les globaux imbriques (exple Telemac Advection)
- # avant le calcul etait avant le for
- dico_valeurs = self.creeDictCondition(mcListe, condition=1)
- globs = self.jdc and self.jdc.condition_context or {}
- if v.verifPresence(dico_valeurs, globs):
- # print ('appel construit bloc', k, 'avec', args, 'a partir de', self.nom )
- # Si le bloc existe :
- # 1- on le construit
- # 2- on l'ajoute à mcListe
- # 3- on récupère les arguments restant
- # 4- on reconstruit le dictionnaire équivalent à mcListe
- bloc = v(
- nom=k,
- val=args,
- parent=self,
- dicoPyxbDeConstruction=self.dicoPyxbDeConstruction,
- )
- mcListe.append(bloc)
- args = bloc.reste_val
- # print ('les args deviennent ', args)
- # On ne recalcule pas le contexte car on ne tient pas compte des blocs
- # pour évaluer les conditions de présence des blocs
- # dico_valeurs = self.creeDictValeurs(mcListe)
-
- # On conserve les arguments superflus dans l'attribut reste_val
- # les reste_val des blocs vont contenir trop de MC
- # car ils sont appeles avec tous les MC de leur niveau qui n ont pas ete consommes
- # et le reste_val n est pas remis a jour
- # est-ce un pb ? a priori non
- self.reste_val = args
- # print ('self.reste_val de ', self.nom, self.reste_val)
- # On ordonne la liste ainsi créée suivant l'ordre du catalogue
- # (utile seulement pour IHM graphique)
- mcListe = self.ordonneListe(mcListe)
- # on retourne la liste ainsi construite
- if self.jdc:
- self.cata = self.jdc.cata
- else:
- self.cata = None
- self.buildObjPyxb(mcListe)
- # print ('______________________________________ fin ', self.nom)
- return mcListe
-
- def buildMcApresGlobalEnSuppression(self):
- blocsDejaLa = []
- for mc in self.mcListe:
- if mc.nature == "MCBLOC":
- blocsDejaLa.append(mc)
- for mc in blocsDejaLa:
- dico_valeurs = self.creeDictCondition(self.mcListe, condition=1)
- globs = self.jdc and self.jdc.condition_context or {}
- defBloc = mc.definition
- if not (defBloc.verifPresence(dico_valeurs, globs)):
- self.suppEntite(mc)
-
- def reConstruitResteVal(self):
- # normal que apres buildMcApresGlobalEnCreation les reste_val ne soient pas corrects
- for mc in self.mcListe:
- if mc.nom in self.reste_val:
- del self.reste_val[mc.nom]
- if mc.nature == "MCBLOC":
- ancetre = mc.parent
- for mcFDuMc in mc.mcListe:
- while ancetre.nature == "MCBLOC":
- ancetre = ancetre.parent
- if mcFDuMc.nom in ancetre.reste_val:
- del ancetre.reste_val[mcFDuMc.nom]
- if mc.nature == "MCSIMP":
- continue
- if mc.nature == "MCList":
- for mcObj in mc.data:
- mcObj.reConstruitResteVal()
- else:
- mc.reConstruitResteVal()
-
- def buildMcApresGlobalEnCreation(self):
- nouveau_args = self.reste_val
- blocsDejaLa = []
- for mc in self.mcListe:
- if mc.nature == "MCBLOC":
- blocsDejaLa.append(mc.nom)
- for k, v in list(self.definition.entites.items()):
- if v.label != "BLOC":
- continue
- if k in blocsDejaLa:
- continue
- dico_valeurs = self.creeDictCondition(self.mcListe, condition=1)
- globs = self.jdc and self.jdc.condition_context or {}
- if v.verifPresence(dico_valeurs, globs):
- bloc = v(
- nom=k,
- val=nouveau_args,
- parent=self,
- dicoPyxbDeConstruction=self.dicoPyxbDeConstruction,
- )
- if bloc:
- self.mcListe.append(bloc)
- bloc.addObjPyxb(self.chercheIndiceDsLeContenu(bloc))
- nouveau_args = self.reste_val
- self.reste_val = bloc.reste_val
-
- def ordonneListe(self, mcListe):
- """
- Ordonne la liste suivant l'ordre du catalogue.
- Seulement pour IHM graphique
- """
- if self.jdc and self.jdc.cata_ordonne_dico != None:
- liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(
- self.getGenealogie(), self.jdc.cata_ordonne_dico
- )
- return self.ordonneListeMc(mcListe, liste_noms_mc_ordonnee)
- else:
- return mcListe
-
- def creeDictValeurs(self, liste=[], condition=0):
- """
- Cette méthode crée un contexte (sous la forme d'un dictionnaire)
- à partir des valeurs des mots clés contenus dans l'argument liste.
- L'opération consiste à parcourir la liste (d'OBJECT) et à la
- transformer en un dictionnaire dont les clés sont les noms des
- mots clés et les valeurs dépendent du type d'OBJECT.
- Ce dictionnaire servira de liste d'arguments d'appel pour les
- fonctions sd_prod de commandes et ops de macros ou de contexte
- d'évaluation des conditions de présence de BLOC.
-
- Si l'argument condition de la méthode vaut 1, on ne
- remonte pas les valeurs des mots clés contenus dans des blocs
- pour eviter les bouclages.
-
- Cette méthode réalise les opérations suivantes en plus de transformer
- la liste en dictionnaire :
-
- - ajouter tous les mots-clés non présents avec la valeur None
- - ajouter tous les mots-clés globaux (attribut position = 'global'
- et 'global_jdc')
-
- L'argument liste est, en général, une mcListe en cours de
- construction, contenant les mots-clés locaux et les blocs déjà créés.
-
- """
- dico = {}
- for v in liste:
- if v.isBLOC():
- # Si v est un BLOC, on inclut ses items dans le dictionnaire
- # représentatif du contexte. Les blocs sont retournés par getValeur
- # sous la forme d'un dictionnaire : les mots-clés fils de blocs sont
- # donc remontés au niveau du contexte.
- if not condition:
- dadd = v.getValeur()
- assert intersection_vide(dico, dadd)
- dico.update(dadd)
- else:
- assert not v.nom in dico, "deja vu : %s" % v.nom
- dico[v.nom] = v.getValeur()
-
- # On rajoute tous les autres mots-clés locaux possibles avec la valeur
- # par défaut ou None
- # Pour les mots-clés facteurs, on ne traite que ceux avec statut défaut ('d')
- # et caché ('c')
- # On n'ajoute aucune information sur les blocs. Ils n'ont pas de défaut seulement
- # une condition.
- # XXX remplacer le not has_key par un dico différent et faire dico2.update(dico)
- # ce n'est qu'un pb de perf
- for k, v in list(self.definition.entites.items()):
- if not k in dico:
- if v.label == "SIMP":
- # Mot clé simple
- dico[k] = v.defaut
- elif v.label == "FACT":
- if v.statut in ("c", "d"):
- # Mot clé facteur avec défaut ou caché provisoire
- dico[k] = v(val=None, nom=k, parent=self)
- # On demande la suppression des pointeurs arrieres
- # pour briser les eventuels cycles
- dico[k].supprime()
- else:
- dico[k] = None
- # A ce stade on a rajouté tous les mots-clés locaux possibles (fils directs) avec leur
- # valeur par défaut ou la valeur None
-
- # On rajoute les mots-clés globaux sans écraser les clés existantes
- dico_mc = self.rechercheMcGlobaux()
- dico_mc.update(dico)
- dico = dico_mc
-
- return dico
-
- def creeDictToutesValeurs(self):
- """Semblable à `creeDictValeurs(liste=self.mcListe)` en supprimant les
- valeurs None."""
- dico = self.creeDictValeurs(self.mcListe, condition=0)
- dico = dict([(k, v) for k, v in list(dico.items()) if v is not None])
- return dico
-
- def creeDictCondition(self, liste=[], condition=0):
- """
- Methode pour construire un contexte qui servira dans l'évaluation
- des conditions de présence de blocs. Si une commande a un concept
- produit réutilisé, on ajoute la clé 'reuse'
- """
- dico = self.creeDictValeurs(liste, condition=1)
- # On ajoute la cle "reuse" pour les MCCOMPO qui ont un attribut reuse. A destination
- # uniquement des commandes. Ne devrait pas etre dans cette classe mais
- # dans une classe dérivée
- if not "reuse" in dico and hasattr(self, "reuse"):
- dico["reuse"] = self.reuse
- return dico
-
- def rechercheMcGlobaux(self):
- """
- Retourne la liste des mots-clés globaux de l'étape à laquelle appartient self
- et des mots-clés globaux du jdc
- """
- etape = self.getEtape()
- if etape:
- dict_mc_globaux_fac = self.rechercheMcGlobauxFacultatifs()
- for k, v in list(etape.mc_globaux.items()):
- dict_mc_globaux_fac[k] = v.getValeur()
- if self.jdc:
- for k, v in list(self.jdc.mc_globaux.items()):
- dict_mc_globaux_fac[k] = v.getValeur()
- return dict_mc_globaux_fac
- else:
- return {}
-
- def rechercheMcGlobauxFacultatifs(self):
- """
- Cette méthode interroge la définition de self et retourne la liste des mots-clés fils
- directs de self de type 'global'.
- position='global' n'est donc possible (et n'a de sens) qu'au plus haut niveau.
- du coup ici on ajoute les globaux de l etape qui sont dans mc_recalculeEtape
- """
- # print ('je passe par ici', self.nom)
- dico = {}
- etape = self.getEtape()
- if not etape:
- return {}
- for k, v in list(etape.definition.entites.items()):
- if v.label != "SIMP":
- continue
- if v.position == "local":
- continue
- if v.position == "inGetAttribut":
- continue
- if v.position == "reCalculeEtape":
- continue
- if v.statut == "o":
- continue
- obj = v(val=None, nom=k, parent=etape)
- dico[k] = obj.getValeur()
- return dico
-
- def supprime(self):
- """
- Méthode qui supprime toutes les références arrières afin que l'objet puisse
- etre correctement détruit par le garbage collector
- """
- N_OBJECT.OBJECT.supprime(self)
- for child in self.mcListe:
- child.supprime()
-
- def __getitem__(self, key):
- """
- Cette méthode retourne la valeur d'un sous mot-clé (key)
- """
- return self.getMocle(key)
-
- def getMocle(self, key):
- """
- Retourne la valeur du sous mot-clé key
- Ce sous mot-clé peut exister, avoir une valeur par defaut ou etre
- dans un BLOC fils de self
- """
- # on cherche dans les mots cles presents, le mot cle de nom key
- # s'il est là on retourne sa valeur (méthode getVal)
- for child in self.mcListe:
- if child.nom == key:
- return child.getValeur()
- # Si on n a pas trouve de mot cle present on retourne le defaut
- # eventuel pour les mots cles accessibles dans la definition
- # a ce niveau
- try:
- d = self.definition.entites[key]
- if d.label == "SIMP":
- return d.defaut
- elif d.label == "FACT":
- # il faut construire les objets necessaires pour
- # evaluer les conditions des blocs eventuels (a faire)
- if d.statut == "o":
- return None
- if d.statut != "c" and d.statut != "d":
- return None
- else:
- return d(val=None, nom=key, parent=self)
- except KeyError:
- # le mot cle n est pas defini a ce niveau
- pass
- # Si on a toujours rien trouve, on cherche dans les blocs presents
- # On suppose que tous les blocs possibles ont ete crees meme ceux
- # induits par un mot cle simple absent avec defaut (???)
- for mc in self.mcListe:
- if not mc.isBLOC():
- continue
- try:
- return mc.getMocle(key)
- except:
- # On n a rien trouve dans ce bloc, on passe au suivant
- pass
- # On a rien trouve, le mot cle est absent.
- # On leve une exception
- raise IndexError("Le mot cle %s n existe pas dans %s" % (key, self))
-
- def getChild(self, name, restreint="non"):
- """
- Retourne le fils de self de nom name ou None s'il n'existe pas
- Si restreint vaut oui : ne regarde que dans la mcListe
- Si restreint vaut non : regarde aussi dans les entites possibles
- avec defaut (Ce dernier cas n'est utilisé que dans le catalogue)
- """
- for v in self.mcListe:
- if v.nom == name:
- return v
- if restreint == "non":
- try:
- entite = self.definition.entites[name]
- if entite.label == "SIMP" or (
- entite.label == "FACT" and entite.statut in ("c", "d")
- ):
- return entite(None, name, None)
- except:
- pass
-
- return None
-
- def getChildOrChildInBloc(self, name, restreint="non"):
- # cherche dans les fils et les fils des blocs
- # tout est base sur le fait que deux freres ne peuvent pas avoir le meme nom
- # dans des blocs non exclusifs, sinon le .comm n est pas du python valide
- for v in self.mcListe:
- if v.nom == name:
- return v
- if restreint == "non":
- try:
- entite = self.definition.entites[name]
- if entite.label == "SIMP" or (
- entite.label == "FACT" and entite.statut in ("c", "d")
- ):
- return entite(None, name, None)
- except:
- pass
- for v in self.mcListe:
- if v.nature == "MCBLOC":
- petitFils = v.getChildOrChildInBloc(name, restreint)
- if petitFils != None:
- return petitFils
- return None
-
- def append_mc_global_avecRecalcule(self, mc):
- etape = self.getEtape()
- if etape:
- nom = mc.nom
- if not (nom in etape.mc_globaux):
- etape.doitEtreRecalculee = True
- etape.mc_globaux[nom] = mc
- # print ('ajout de nom', mc.nom, 'ds les mc_globaux de', etape.nom)
-
- def append_mc_global(self, mc):
- """
- Ajoute le mot-clé mc à la liste des mots-clés globaux de l'étape
- """
- etape = self.getEtape()
- if etape:
- nom = mc.nom
- etape.mc_globaux[nom] = mc
-
- def append_mc_global_jdc(self, mc):
- """
- Ajoute le mot-clé mc à la liste des mots-clés globaux du jdc
- """
- nom = mc.nom
- self.jdc.mc_globaux[nom] = mc
-
- def copy(self):
- """Retourne une copie de self"""
- objet = self.makeobjet()
- # attention !!! avec makeobjet, objet a le meme parent que self
- # ce qui n'est pas du tout bon dans le cas d'une copie !!!!!!!
- # le pb c'est qu'on vérifie ensuite quel parent avait l'objet
- # Il me semble preferable de changer le parent a la fin quand la copie
- # est acceptee
- objet.valeur = copy(self.valeur)
- objet.val = copy(self.val)
- objet.mcListe = []
- for obj in self.mcListe:
- new_obj = obj.copy()
- new_obj.reparent(objet)
- objet.mcListe.append(new_obj)
- return objet
-
- def reparent(self, parent):
- """
- Cette methode sert a reinitialiser la parente de l'objet
- """
- self.parent = parent
- self.jdc = parent.getJdcRoot()
- self.etape = parent.etape
- for mocle in self.mcListe:
- mocle.reparent(self)
-
- def getSd_utilisees(self):
- """
- Retourne la liste des concepts qui sont utilisés à l'intérieur de self
- ( comme valorisation d'un MCS)
- """
- l = []
- for child in self.mcListe:
- l.extend(child.getSd_utilisees())
- return l
-
- def getSdMCSUtilisees(self):
- """
- Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
- - Si aucune sd n'est utilisée, le dictionnaire est vide.
- - Sinon, les clés du dictionnaire sont les mots-clés derrière lesquels on
- trouve des sd ; la valeur est la liste des sd attenante.
- Exemple ::
-
- { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
- <Cata.cata.fonction_sdaster instance at 0x941a204> ],
- 'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
- """
- dico = {}
- for child in self.mcListe:
- daux = child.getSdMCSUtilisees()
- for cle in daux:
- dico[cle] = dico.get(cle, [])
- dico[cle].extend(daux[cle])
- return dico
-
- def getMcsWithCo(self, co):
- """
- Cette methode retourne l'objet MCSIMP fils de self
- qui a le concept co comme valeur.
- En principe, elle ne doit etre utilisee que pour les concepts
- instances de la classe CO
- """
- l = []
- for child in self.mcListe:
- l.extend(child.getMcsWithCo(co))
- return l
-
- def getAllCo(self):
- """
- Cette methode retourne tous les concepts instances de CO
- """
- l = []
- for child in self.mcListe:
- l.extend(child.getAllCo())
- return l
-
- # def getSdCreeParObjetAvecFiltre(self,objetAssdMultiple):
- # est-ce que si on est bloc, il faut passer à parent ?
- # ou prevoir une autre fonction qui tienne compte de cela
- # ou prevoir un xpath
- # classeAChercher = objetAssdMultiple.definition.type
- # filtre = objetAssdMultiple.definition.filtre
- # print ('getSdCreeParObjetAvecFiltre', classeAChercher, filtre)
- # dicoValeurs = self.creeDictCondition(self.mcListe, condition=1)
- # l=[]
- # for k,v in self.jdc.sdsDict.items():
- # if (isinstance(v, classeAChercher)) :
- # if v.executeExpression(filtre,dicoValeurs) : l.append(k)
- # return l
-
-
-def intersection_vide(dict1, dict2):
- """Verification qu'il n'y a pas de clé commune entre 'dict1' et 'dict2'."""
- sk1 = set(dict1)
- sk2 = set(dict2)
- inter = sk1.intersection(sk2)
- ok = len(inter) == 0
- if not ok:
- print(("ERREUR: Mot(s)-clef(s) vu(s) plusieurs fois :", tuple(inter)))
- return ok
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe MCFACT qui sert à controler la valeur
- d'un mot-clé facteur par rapport à sa définition portée par un objet
- de type ENTITE
-"""
-from . import N_MCCOMPO
-
-
-class MCFACT(N_MCCOMPO.MCCOMPO):
- nature = "MCFACT"
-
- def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction):
- """
- Attributs :
- - val : valeur du mot clé simple
- - definition
- - nom
- - parent
- """
- # print ('MCFACT', self, val, definition, nom, parent, dicoPyxbDeConstruction)
- # import traceback
- # traceback.print_stack()
- self.dicoPyxbDeConstruction = dicoPyxbDeConstruction
- if self.dicoPyxbDeConstruction:
- self.objPyxbDeConstruction = self.dicoPyxbDeConstruction["objEnPyxb"]
- del self.dicoPyxbDeConstruction["objEnPyxb"]
- else:
- self.objPyxbDeConstruction = None
- self.definition = definition
- self.nom = nom
- self.val = val
- self.parent = parent
- self.estIdentifiePar = None
- self.valeur = self.getValeurEffective(self.val)
- if parent:
- self.jdc = self.parent.jdc
- self.niveau = self.parent.niveau
- self.etape = self.parent.etape
- else:
- # Le mot cle a été créé sans parent
- self.jdc = None
- self.niveau = None
- self.etape = None
- self.mcListe = self.buildMc()
-
- def getValeurEffective(self, val):
- """
- Retourne la valeur effective du mot-clé en fonction
- de la valeur donnée. Defaut si val == None
- """
- if val is None and hasattr(self.definition, "defaut"):
- return self.definition.defaut
- else:
- return val
-
- def getValeur(self):
- """
- Retourne la "valeur" d'un mot-clé facteur qui est l'objet lui-meme.
- Cette valeur est utilisée lors de la création d'un contexte
- d'évaluation d'expressions à l'aide d'un interpréteur Python
- """
- return self
-
- def getVal(self):
- """
- Une autre méthode qui retourne une "autre" valeur du mot clé facteur.
- Elle est utilisée par la méthode getMocle
- """
- return [self]
-
- def __getitem__(self, key):
- """
- Dans le cas d un mot cle facteur unique on simule une liste de
- longueur 1
- """
- if key == 0:
- return self
- return self.getMocle(key)
-
- def accept(self, visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitMCFACT(self)
-
- def makeobjet(self):
- return self.definition.class_instance(
- val=None, nom=self.nom, definition=self.definition, parent=self.parent
- )
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe MCList qui sert à controler la valeur
- d'une liste de mots-clés facteur par rapport à sa définition portée par un objet
- de type ENTITE
-"""
-from copy import copy
-import types
-from collections import UserList
-
-
-class MCList(UserList):
-
- """Liste semblable a la liste Python
- mais avec quelques methodes en plus
- = liste de MCFACT
- """
-
- nature = "MCList"
-
- def init(self, nom, parent):
- self.objPyxbDeConstruction = None
- self.definition = None
- self.nom = nom
- self.parent = parent
- if parent:
- self.jdc = self.parent.jdc
- self.niveau = self.parent.niveau
- self.etape = self.parent.etape
- else:
- # Le mot cle a été créé sans parent
- self.jdc = None
- self.niveau = None
- self.etape = None
-
- def getValeur(self):
- """
- Retourne la "valeur" d'un objet MCList. Sert à construire
- un contexte d'évaluation pour une expression Python.
- On retourne l'objet lui-meme.
- """
- return self
-
- def getVal(self):
- """
- Une autre méthode qui retourne une "autre" valeur d'une MCList
- Elle est utilisée par la méthode getMocle
- """
- return self
-
- def supprime(self):
- """
- Méthode qui supprime toutes les références arrières afin que l'objet puisse
- etre correctement détruit par le garbage collector
- """
- self.parent = None
- self.etape = None
- self.jdc = None
- self.niveau = None
- for child in self.data:
- child.supprime()
-
- def getChild(self, name, restreint="non"):
- """
- Retourne le fils de nom name s'il est contenu dans self
- Par défaut retourne le fils du premier de la liste
- """
- obj = self.data[0]
- # Phase 1 : on cherche dans les fils directs de obj
- for child in obj.mcListe:
- if child.nom == name:
- return child
- # Phase 2 : on cherche dans les blocs de self
- for child in obj.mcListe:
- if child.isBLOC():
- resu = child.getChild(name)
- if resu != None:
- return resu
- # Phase 3 : on cherche dans les entites possibles pour les défauts
- for k, v in list(obj.definition.entites.items()):
- # if k == name: return v.defaut
- if k == name:
- if v.defaut != None:
- return v(None, k, None)
- # si on passe ici, c'est que l'on demande un fils qui n'est pas possible --> erreur
- # print "Erreur : %s ne peut etre un descendant de %s" %(name,self.nom)
- return None
-
- def getAllChild(self, name):
- # A utiliser uniquement dans un filtre
- maListeRetour = MCList()
- for obj in self.data:
- for objFils in obj.getChild(name):
- maListeRetour.append(objFils)
- return maListeRetour
-
- def isBLOC(self):
- """
- Indique si l'objet est de type BLOC
- """
- return 0
-
- def accept(self, visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitMCList(self)
-
- def getSd_utilisees(self):
- """
- Retourne la liste des concepts qui sont utilisés à l'intérieur de self
- ( comme valorisation d'un MCS)
- """
- l = []
- for child in self.data:
- l.extend(child.getSd_utilisees())
- return l
-
- def getSdMCSUtilisees(self):
- """
- Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
- - Si aucune sd n'est utilisée, le dictionnaire est vide.
- - Sinon, les clés du dictionnaire sont les mots-clés derrière lesquels on
- trouve des sd ; la valeur est la liste des sd attenante.
-
- Exemple ::
-
- { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
- <Cata.cata.fonction_sdaster instance at 0x941a204> ],
- 'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
- """
- dico = {}
- for child in self.data:
- daux = child.getSdMCSUtilisees()
- for cle in daux:
- dico[cle] = dico.get(cle, [])
- dico[cle].extend(daux[cle])
- return dico
-
- def getMcsWithCo(self, co):
- """
- Cette methode retourne l'objet MCSIMP fils de self
- qui a le concept co comme valeur.
- En principe, elle ne doit etre utilisee que pour les concepts
- instances de la classe CO
- """
- l = []
- for child in self.data:
- l.extend(child.getMcsWithCo(co))
- return l
-
- def getAllCo(self):
- """
- Cette methode retourne tous les concepts instances de CO
- """
- l = []
- for child in self.data:
- l.extend(child.getAllCo())
- return l
-
- def copy(self):
- """
- Réalise la copie d'une MCList
- """
- liste = self.data[0].definition.list_instance()
- # FR -->Il faut spécifier un parent pour la méthode init qui attend 2
- # arguments ...
- liste.init(self.nom, self.parent)
- for objet in self:
- new_obj = objet.copy()
- # Pour etre coherent avec le constructeur de mots cles facteurs N_FACT.__call__
- # dans lequel le parent de l'element d'une MCList est le parent de
- # la MCList
- new_obj.reparent(self.parent)
- liste.append(new_obj)
- return liste
-
- def reparent(self, parent):
- """
- Cette methode sert a reinitialiser la parente de l'objet
- """
- self.parent = parent
- self.jdc = parent.jdc
- self.etape = parent.etape
- for mcfact in self.data:
- mcfact.reparent(parent)
-
- def getEtape(self):
- """
- Retourne l'étape à laquelle appartient self
- Un objet de la catégorie etape doit retourner self pour indiquer que
- l'étape a été trouvée
- XXX double emploi avec self.etape ???
- """
- if self.parent == None:
- return None
- return self.parent.getEtape()
-
- def __getitem__(self, key):
- """
- Dans le cas d un mot cle facteur de longueur 1 on simule un scalaire
- """
- if type(key) != int and len(self) == 1:
- return self.data[0].getMocle(key)
- else:
- return self.data[key]
-
- def List_F(self):
- """
- Retourne une liste de dictionnaires (eventuellement singleton) qui peut etre
- passe directement derriere un mot-cle facteur (pour les macros).
- """
- dresu = []
- for mcf in self:
- dico = mcf.creeDictValeurs(mcf.mcListe)
- for i in list(dico.keys()):
- if dico[i] == None:
- del dico[i]
- dresu.append(dico)
- return dresu
-
- def longueurDsArbre(self):
- # pour Pyxb : longueur dans le orderedcontent de pyxb
- return len(self)
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe MCSIMP qui sert à controler la valeur
- d'un mot-clé simple par rapport à sa définition portée par un objet
- de type ENTITE
-"""
-
-from copy import copy
-from Noyau.N_ASSD import ASSD
-from Noyau.N_UserASSDMultiple import UserASSDMultiple
-from Noyau.N_CO import CO
-from . import N_OBJECT
-from .N_CONVERT import ConversionFactory
-from .N_types import forceList, isSequence
-
-
-class MCSIMP(N_OBJECT.OBJECT):
-
- """ """
-
- nature = "MCSIMP"
-
- def __init__(self, val, definition, nom, parent, objPyxbDeConstruction):
- """
- Attributs :
-
- - val : valeur du mot clé simple
- - definition
- - nom
- - parent
-
- Autres attributs :
-
- - valeur : valeur du mot-clé simple en tenant compte de la valeur par défaut
-
- """
- # print (self, val, definition, nom, parent)
- self.definition = definition
- self.nom = nom
- self.val = val
- self.parent = parent
- self.objPyxbDeConstruction = objPyxbDeConstruction
- if parent:
- self.jdc = self.parent.jdc
- if self.jdc:
- self.cata = self.jdc.cata
- else:
- self.cata = None
- self.niveau = self.parent.niveau
- self.etape = self.parent.etape
- else:
- # Le mot cle simple a été créé sans parent
- # est-ce possible ?
- print("je suis dans le else sans parent du build")
- self.jdc = None
- self.cata = None
- self.niveau = None
- self.etape = None
- if self.definition.creeDesObjets:
- if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple):
- self.convProto = ConversionFactory(
- "UserASSDMultiple", self.definition.creeDesObjetsDeType
- )
- else:
- self.convProto = ConversionFactory(
- "UserASSD", self.definition.creeDesObjetsDeType
- )
- else:
- self.convProto = ConversionFactory("type", typ=self.definition.type)
- self.valeur = self.getValeurEffective(self.val)
- if self.definition.utiliseUneReference:
- if self.valeur != None:
- if not type(self.valeur) in (list, tuple):
- self.valeur.ajoutUtilisePar(self)
- else:
- # PNPN --> chgt pour Vimmp
- for v in self.valeur:
- # print (v, type(v))
- v.ajoutUtilisePar(self)
- # try : v.ajoutUtilisePar(self)
- # except : print ('il y a un souci ici', self.nom, self.valeur)
- self.buildObjPyxb()
- self.listeNomsObjsCrees = []
-
- def getValeurEffective(self, val):
- """
- Retourne la valeur effective du mot-clé en fonction
- de la valeur donnée. Defaut si val == None
- Attention aux UserASSD et aux into (exple Wall gp de maille et 'Wall')
- """
- # print ('getValeurEffective ________________', val)
- if val is None and hasattr(self.definition, "defaut"):
- val = self.definition.defaut
- if self.definition.type[0] == "TXM" and isinstance(val, str):
- return val
- if self.definition.creeDesObjets:
- # isinstance(val, self.definition.creeDesObjetsDeType) ne fonctionne pas car il y a un avec cata devant et l autre non
- if val == None:
- return val
- if not isinstance(val, (list, tuple)):
- valATraiter = [
- val,
- ]
- else:
- valATraiter = val
- listeRetour = []
- for v in valATraiter:
- # print (v.__class__.__name__, self.definition.creeDesObjetsDeType.__name__)
- if not (
- v.__class__.__name__ == self.definition.creeDesObjetsDeType.__name__
- ):
- if self.jdc != None and v in list(self.jdc.sdsDict.keys()):
- v = self.jdc.sdsDict[v]
- else:
- v = self.convProto.convert(v)
- if v.parent == None:
- v.initialiseParent(self)
- if issubclass(
- self.definition.creeDesObjetsDeType, UserASSDMultiple
- ):
- v.ajouteUnPere(self)
- else:
- if v.nom == "sansNom":
- for leNom, laVariable in self.jdc.g_context.items():
- # print (leNom,laVariable)
- if id(laVariable) == id(v) and (leNom != "sansNom"):
- v.initialiseNom(leNom)
- if v.parent == None:
- v.initialiseParent(self)
- if issubclass(
- self.definition.creeDesObjetsDeType, UserASSDMultiple
- ):
- v.ajouteUnPere(self)
- listeRetour.append(v)
- if isinstance(val, (list, tuple)):
- newVal = listeRetour
- else:
- newVal = listeRetour[0]
- return newVal
- if self.convProto:
- val = self.convProto.convert(val)
- return val
-
- def creeUserASSDetSetValeur(self, val):
- self.state = "changed"
- nomVal = val
- if nomVal in self.jdc.sdsDict.keys():
- if isinstance(
- self.jdc.sdsDict[nomVal], self.definition.creeDesObjetsDeType
- ):
- if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple):
- p = self.parent
- while p in self.parent:
- if hasattr(p, "listeDesReferencesCrees"):
- p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal])
- else:
- p.listeDesReferencesCrees = [
- self.jdc.sdsDict[nomVal],
- ]
- p = p.parent
- self.jdc.sdsDict[nomVal].ajouteUnPere(self)
- # return (1, 'reference ajoutee')
- else:
- return (0, "concept non multiple deja reference")
- else:
- return (0, "concept d un autre type existe deja")
- if self.convProto:
- objVal = self.convProto.convert(nomVal)
- objVal.initialiseNom(nomVal)
- if objVal.parent == None:
- objVal.initialiseParent(self)
- objVal.ajouteUnPere(self)
- p = self.parent
- while p in self.parent:
- # print ('mise a jour de ',p)
- if hasattr(p, "listeDesReferencesCrees"):
- p.listeDesReferencesCrees.append(objVal)
- else:
- p.listeDesReferencesCrees = [
- objVal,
- ]
- p = p.parent
- return (self.setValeur(objVal), "reference creee")
-
- def creeUserASSD(self, val):
- self.state = "changed"
- nomVal = val
- if nomVal in self.jdc.sdsDict.keys():
- if isinstance(
- self.jdc.sdsDict[nomVal], self.definition.creeDesObjetsDeType
- ):
- if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple):
- p = self.parent
- while p in self.parent:
- if hasattr(p, "listeDesReferencesCrees"):
- p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal])
- else:
- p.listeDesReferencesCrees = [
- self.jdc.sdsDict[nomVal],
- ]
- p = p.parent
- self.jdc.sdsDict[nomVal].ajouteUnPere(self)
- return (1, self.jdc.sdsDict[nomVal], "reference ajoutee")
- else:
- return (0, None, "concept d un autre type existe deja")
- else:
- return (0, None, "concept d un autre type existe deja")
- if self.convProto:
- objVal = self.convProto.convert(nomVal)
- objVal.initialiseNom(nomVal)
- objVal.ajouteUnPere(self)
- return (1, objVal, "reference creee")
-
- def rattacheUserASSD(self, objASSD):
- if objASSD.parent == None:
- objASSD.initialiseParent(self)
- p = self.parent
- while p in self.parent:
- if hasattr(p, "listeDesReferencesCrees"):
- p.listeDesReferencesCrees.append(objASSD)
- else:
- p.listeDesReferencesCrees = [
- objASSD,
- ]
- p = p.parent
-
- def getValeur(self):
- """
- Retourne la "valeur" d'un mot-clé simple.
- Cette valeur est utilisée lors de la création d'un contexte
- d'évaluation d'expressions à l'aide d'un interpréteur Python
- """
- v = self.valeur
- # Si singleton et max=1, on retourne la valeur.
- # Si une valeur simple et max='**', on retourne un singleton.
- # (si liste de longueur > 1 et max=1, on sera arrêté plus tard)
- # Pour accepter les numpy.array, on remplace : "type(v) not in (list, tuple)"
- # par "not has_attr(v, '__iter__')".
- if v is None:
- pass
- elif isSequence(v) and len(v) == 1 and self.definition.max == 1:
- v = v[0]
- elif not isSequence(v) and self.definition.max != 1:
- v = (v,)
- # traitement particulier pour les complexes ('RI', r, i)
- if (
- "C" in self.definition.type
- and self.definition.max != 1
- and v != None
- and v[0] in ("RI", "MP")
- ):
- v = (v,)
- return v
-
- def getVal(self):
- """
- Une autre méthode qui retourne une "autre" valeur du mot clé simple.
- Elle est utilisée par la méthode getMocle
- """
- return self.valeur
-
- def accept(self, visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitMCSIMP(self)
-
- def copy(self):
- """Retourne une copie de self"""
- objet = self.makeobjet()
- # il faut copier les listes et les tuples mais pas les autres valeurs
- # possibles (réel,SD,...)
- if type(self.valeur) in (list, tuple):
- objet.valeur = copy(self.valeur)
- else:
- objet.valeur = self.valeur
- objet.val = objet.valeur
- return objet
-
- def makeobjet(self):
- return self.definition(val=None, nom=self.nom, parent=self.parent)
-
- def reparent(self, parent):
- """
- Cette methode sert a reinitialiser la parente de l'objet
- """
- self.parent = parent
- self.jdc = parent.jdc
- self.etape = parent.etape
-
- def getSd_utilisees(self):
- """
- Retourne une liste qui contient la ou les SD utilisée par self si c'est le cas
- ou alors une liste vide
- """
- l = []
- if isinstance(self.valeur, ASSD):
- l.append(self.valeur)
- elif type(self.valeur) in (list, tuple):
- for val in self.valeur:
- if isinstance(val, ASSD):
- l.append(val)
- return l
-
- def getSdMCSUtilisees(self):
- """
- Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
- - Si aucune sd n'est utilisée, le dictionnaire est vide.
- - Sinon, la clé du dictionnaire est le mot-clé simple ; la valeur est
- la liste des sd attenante.
-
- Exemple ::
- { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
- <Cata.cata.fonction_sdaster instance at 0x941a204> ] }
- """
- l = self.getSd_utilisees()
- dico = {}
- if len(l) > 0:
- dico[self.nom] = l
- return dico
-
- def getMcsWithCo(self, co):
- """
- Cette methode retourne l'objet MCSIMP self s'il a le concept co
- comme valeur.
- """
- if co in forceList(self.valeur):
- return [
- self,
- ]
- return []
-
- def getAllCo(self):
- """
- Cette methode retourne la liste de tous les concepts co
- associés au mot cle simple
- """
- return [
- co for co in forceList(self.valeur) if isinstance(co, CO) and co.isTypCO()
- ]
-
- def supprime(self):
- if not type(self.valeur) in (list, tuple):
- lesValeurs = (self.valeur,)
- else:
- lesValeurs = self.valeur
- if self.valeur == None or self.valeur == []:
- lesValeurs = []
- for val in lesValeurs:
- if self.definition.creeDesObjets:
- val.deleteReference(self)
- else:
- if hasattr(val, "enleveUtilisePar"):
- val.enleveUtilisePar(self)
- N_OBJECT.OBJECT.supprime(self)
-
- def getUserAssdPossible(self):
- debug = False
- if self.nom == "ApplyOn":
- debug = True
- if debug:
- print("____________", self, self.nom)
- classeAChercher = self.definition.type
- if debug:
- print("____________", classeAChercher)
- l = []
- dicoValeurs = {}
- d = {}
- if debug:
- print("____________", self.definition.filtreVariables)
- if self.definition.filtreVariables != None:
- for nomMC, Xpath in self.definition.filtreVariables:
- if debug:
- print(nomMC, Xpath)
- if Xpath == None:
- dicoValeurs[nomMC] = getattr(self, nomMC)
- else:
- try: # if 1 :
- pereMC = eval(Xpath)
- if debug:
- print("pereMC :", pereMC)
- if pereMC:
- exp = Xpath + '.getChild("' + nomMC + '")'
- leMotCle = eval(exp)
- else:
- leMotCle = None
- if debug:
- print("leMotCle", leMotCle)
- if leMotCle:
- if leMotCle.val:
- dicoValeurs[nomMC] = leMotCle.val
- elif leMotCle.definition.max != 1:
- dicoValeurs[nomMC] = []
- else:
- dicoValeurs[nomMC] = None
- if debug:
- print("dicoValeurs", dicoValeurs)
- else:
- # PN PN est-ce sur ? sinon quoi None ou []
- # je pense que les 2 valeurs doivent être renseignees si le filtre depend de 2 valeurs
- return l
- except:
- return l
-
- for k, v in self.parent.jdc.sdsDict.items():
- if isinstance(v, classeAChercher):
- if debug:
- print("je traite", v)
- if self.definition.filtreExpression:
- if debug:
- print("expression", self.definition.filtreExpression)
- if debug:
- print(
- v.executeExpression(
- self.definition.filtreExpression, dicoValeurs
- )
- )
- try:
- if v.executeExpression(
- self.definition.filtreExpression, dicoValeurs
- ):
- l.append(v)
- except:
- print("il faut comprendre except pour", self.nom)
- # print (self.nom)
- # print (self.parent.nom)
- # print (k,v)
- else:
- l.append(v)
- return l
+++ /dev/null
-## coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe OBJECT classe mère de tous les objets
- servant à controler les valeurs par rapport aux définitions
-"""
-from builtins import object
-from .N_CR import CR
-
-
-class OBJECT(object):
-
- """
- Classe OBJECT : cette classe est virtuelle et sert de classe mère
- aux classes de type ETAPE et MOCLES.
- Elle ne peut etre instanciée.
- Une sous classe doit obligatoirement implémenter les méthodes :
-
- - __init__
-
- """
-
- def getEtape(self):
- """
- Retourne l'étape à laquelle appartient self
- Un objet de la catégorie etape doit retourner self pour indiquer que
- l'étape a été trouvée
- XXX double emploi avec self.etape ???
- """
- if self.parent == None:
- return None
- return self.parent.getEtape()
-
- def supprime(self):
- """
- Méthode qui supprime les références arrières suffisantes pour
- que l'objet puisse etre correctement détruit par le
- garbage collector
- """
- self.parent = None
- self.etape = None
- self.jdc = None
- self.niveau = None
-
- def getVal(self):
- """
- Retourne la valeur de l'objet. Cette méthode fournit
- une valeur par defaut. Elle doit etre dérivée pour chaque
- type d'objet
- """
- return self
-
- def getJdcRoot(self):
- """
- Cette méthode doit retourner l'objet racine c'est à dire celui qui
- n'a pas de parent
- """
- if self.parent:
- return self.parent.getJdcRoot()
- else:
- return self
-
- def getValeurEffective(self, val):
- """
- Retourne la valeur effective du mot-clé en fonction
- de la valeur donnée. Defaut si val == None
- """
- if val is None and hasattr(self.definition, "defaut"):
- return self.definition.defaut
- else:
- return val
-
- def reparent(self, parent):
- """
- Cette methode sert a reinitialiser la parente de l'objet
- """
- self.parent = parent
- self.jdc = parent.jdc
-
- def isBLOC(self):
- """
- Indique si l'objet est un BLOC
- surcharge dans MCBLOC
- """
- return 0
-
- def longueurDsArbre(self):
- if self.nom == "Consigne":
- return 0
- if self.nom == "blocConsigne":
- return 0
- return 1
-
- def prepareInsertInDB(self, dictKey, dElementsRecursifs, dPrimaryKey):
- # Comme c est recursif doit etre dans Objet
- # derive pour MCSIMP et MCLIST
- debug = 1
- if debug:
- print("prepareInsertInDB traitement de ", self.nom)
- if self.nature in ("OPERATEUR", "PROCEDURE"):
- texteColonnes = "INSERT INTO {} (".format(self.nom)
- texteValeurs = " VALUES("
- elif self.nom in dPrimaryKey:
- texteColonnes = "INSERT INTO {} (".format(self.nom)
- texteValeurs = " VALUES("
- texteColonnes += dPrimaryKey[self.nom]
- texteValeurs += dictKey[dPrimaryKey[self.nom]]
- else:
- texteColonnes = ""
- texteValeurs = ""
- texteAutresTables = ""
- for mc in self.mcListe:
- if debug:
- print("prepareInsertInDB appel pour", mc.nom, dictKey)
- if mc.nom in dElementsRecursifs:
- print("Mot Clef Recursifs", mc.nom)
- if mc.nature == "MCSIMP":
- col, val = mc.prepareInsertInDB()
- if mc.nom in dictKey:
- dictKey[mc.nom] = val
- texteValeurs += val + " ,"
- texteColonnes += col + " ,"
- else:
- tc, tv, ta = mc.prepareInsertInDB(
- dictKey, dElementsRecursifs, dPrimaryKey
- )
- texteValeurs += val + " ,"
- texteColonnes += col + " ,"
- texteAutresTables += ta
-
- if self.nature in ("OPERATEUR", "PROCEDURE") or self.nom in dPrimaryKey:
- texteColonnes = texteColonnes[0:-1] + ") "
- texteValeurs = texteValeurs[0:-1] + ");\n"
- return (texteColonnes, texteValeurs, texteAutresTables)
-
-
-class ErrorObj(OBJECT):
-
- """Classe pour objets errones : emule le comportement d'un objet tel mcsimp ou mcfact"""
-
- def __init__(self, definition, valeur, parent, nom="err"):
- self.nom = nom
- self.definition = definition
- self.valeur = valeur
- self.parent = parent
- self.mcListe = []
- if parent:
- self.jdc = self.parent.jdc
- # self.niveau = self.parent.niveau
- # self.etape = self.parent.etape
- else:
- # Pas de parent
- self.jdc = None
- # self.niveau = None
- # self.etape = None
-
- def isValid(self, cr="non"):
- return 0
-
- def report(self):
- """génère le rapport de validation de self"""
- self.cr = CR()
- self.cr.debut = "Mot-clé invalide : " + self.nom
- self.cr.fin = "Fin Mot-clé invalide : " + self.nom
- self.cr.fatal(
- _("Type non autorisé pour le mot-clé %s : '%s'"), self.nom, self.valeur
- )
- return self.cr
-
-
-def newGetattr(self, name):
- try:
- fils = self.getChildOrChildInBloc(name, restreint="non")
- if fils:
- if fils.nature == "MCSIMP":
- return fils.valeur
- if fils.nature == "MCList":
- if fils[0].definition.max == 1:
- return fils[0]
- return fils
- except:
- raise AttributeError(
- "%r object has no attribute %r" % (self.__class__.__name__, name)
- )
- raise AttributeError(
- "%r object has no attribute %r" % (self.__class__.__name__, name)
- )
-
-
-def newGetattrForEtape(self, name):
- try:
- lesFils = self.getEtapesByName(name)
- if lesFils != []:
- return lesFils
- except:
- raise AttributeError(
- "%r object has no attribute %r" % (self.__class__.__name__, name)
- )
- raise AttributeError(
- "%r object has no attribute %r" % (self.__class__.__name__, name)
- )
-
-
-def activeSurcharge():
- from .N_MCCOMPO import MCCOMPO
-
- MCCOMPO.__getattr__ = newGetattr
- from .N_JDC import JDC
-
- JDC.__getattr__ = newGetattrForEtape
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe de definition OPER
- qui permet de spécifier les caractéristiques d'un opérateur
-"""
-
-
-import types
-import traceback
-
-from . import N_ENTITE
-from . import N_ETAPE
-from . import nommage
-
-
-class OPER(N_ENTITE.ENTITE):
-
- """
- Classe pour definir un opérateur
-
- Cette classe a trois attributs de classe
-
- - class_instance qui indique la classe qui devra etre utilisée
- pour créer l'objet qui servira à controler la conformité d'un
- opérateur avec sa définition
-
- - label qui indique la nature de l'objet de définition (ici, OPER)
-
- - nommage qui est un module Python qui fournit la fonctionnalité de nommage
-
- et les attributs d'instance suivants :
-
- - nom : son nom
-
- - op : le numéro d'opérateur
-
- - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
- une classe
-
- - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
- réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
-
- - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
- non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
- de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
-
- - fr : commentaire associé en francais
-
- - docu : clé de documentation associée
-
- - regles : liste des règles associées
-
- - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
- fonction est exécutée lors des phases d'initialisation de l'étape associée.
-
- - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
- rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
- Si niveau vaut None, l'opérateur est rangé au niveau global.
-
- - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
- des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
- est initialisé avec args, c'est à dire les arguments d'appel restants.
-
-
- """
-
- class_instance = N_ETAPE.ETAPE
- label = "OPER"
- nommage = nommage
-
- def __init__(
- self,
- nom,
- op=None,
- sd_prod=None,
- reentrant="n",
- repetable="o",
- fr="",
- ang="",
- fenetreIhm=None,
- docu="",
- regles=(),
- op_init=None,
- niveau=None,
- UIinfo=None,
- **args
- ):
- """
- Méthode d'initialisation de l'objet OPER. Les arguments sont utilisés pour initialiser
- les attributs de meme nom
- """
- self.nom = nom
- self.op = op
- self.sd_prod = sd_prod
- self.reentrant = reentrant
- self.fr = fr
- self.ang = ang
- self.repetable = repetable
- self.docu = docu
- self.fenetreIhm = fenetreIhm
- if type(regles) == tuple:
- self.regles = regles
- else:
- self.regles = (regles,)
- # Attribut op_init : Fonction a appeler a la construction de l
- # operateur sauf si == None
- self.op_init = op_init
- self.entites = args
- current_cata = CONTEXT.getCurrentCata()
- if niveau == None:
- self.niveau = None
- current_cata.enregistre(self)
- else:
- self.niveau = current_cata.getNiveau(niveau)
- self.niveau.enregistre(self)
- self.UIinfo = UIinfo
- self.affecter_parente()
- self.checkDefinition(self.nom)
- self.txtNomComplet = ""
- self.dejaPrepareDump = False
-
- def __call__(self, reuse=None, nomXML=None, **args):
- """
- Construit l'objet ETAPE a partir de sa definition (self),
- puis demande la construction de ses sous-objets et du concept produit.
- """
- if nomXML == None:
- nomsd = self.nommage.getNomConceptResultat(self.nom)
- else:
- nomsd = nomXML
- etape = self.class_instance(oper=self, reuse=reuse, args=args)
- etape.MCBuild()
- while etape.doitEtreRecalculee == True:
- etape.doitEtreRecalculee = False
- etape.deepUpdateConditionBlocApresCreation()
- etape.reConstruitResteVal()
- etape.state = "modified"
- # print ('on recalcule la validite depuis N_OPER')
- # etape.isValid(cr='oui')
- etape.metAJourNomASSD(nomsd)
- return etape.buildSd(nomsd)
-
- def make_objet(self, mc_list="oui"):
- """
- Cette méthode crée l'objet ETAPE dont la définition est self sans
- l'enregistrer ni créer sa sdprod.
- Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
- des objets MCxxx.
- """
- etape = self.class_instance(oper=self, reuse=None, args={})
- if mc_list == "oui":
- etape.MCBuild()
- return etape
-
- def verifCata(self):
- """
- Méthode de vérification des attributs de définition
- """
- self.checkRegles()
- self.checkFr()
- self.checkReentrant()
- self.checkDocu()
- self.checkNom()
- self.checkOp(valmin=0)
- self.verifCataRegles()
-
- def supprime(self):
- """
- Méthode pour supprimer les références arrières susceptibles de provoquer
- des cycles de références
- """
- self.niveau = None
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-from builtins import object
-from .N_utils import importObject
-
-
-class OPS(object):
-
- """Wrapper to ops functions.
- This allows to import them only when they are needed."""
-
- def __init__(self, uri):
- """Initialization"""
- self.uri = uri
-
- def __call__(self, *args, **kwargs):
- """Import the real function and call it."""
- func = importObject(self.uri)
- return func(*args, **kwargs)
-
-
-# utilisé par exemple par des macros où tout est fait dans l'init.
-class NOTHING(OPS):
-
- """OPS which does nothing."""
-
- def __call__(self, macro, *args, **kwargs):
- macro.set_icmd(1)
- return 0
-
-
-EMPTY_OPS = NOTHING(None)
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe de definition PROC
- qui permet de spécifier les caractéristiques d'une procédure
-"""
-
-
-import types
-import traceback
-
-from . import N_ENTITE
-from . import N_PROC_ETAPE
-
-
-class PROC(N_ENTITE.ENTITE):
-
- """
- Classe pour definir un opérateur
-
- Cette classe a deux attributs de classe
-
- - class_instance qui indique la classe qui devra etre utilisée
- pour créer l'objet qui servira à controler la conformité d'un
- opérateur avec sa définition
-
- - label qui indique la nature de l'objet de définition (ici, PROC)
-
-
- et les attributs d'instance suivants :
-
- - nom : son nom
-
- - op : le numéro d'opérateur
-
- - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
- réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
-
- - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
- non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
- de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
-
- - fr : commentaire associé en francais
-
- - docu : clé de documentation associée
-
- - regles : liste des règles associées
-
- - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
- fonction est exécutée lors des phases d'initialisation de l'étape associée.
-
- - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
- rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
- Si niveau vaut None, l'opérateur est rangé au niveau global.
-
- - fenetreIhm : specification de la fenetre
-
- - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
- des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
- est initialisé avec args, c'est à dire les arguments d'appel restants.
-
-
- """
-
- class_instance = N_PROC_ETAPE.PROC_ETAPE
- label = "PROC"
-
- def __init__(
- self,
- nom,
- op=None,
- reentrant="n",
- repetable="o",
- fr="",
- ang="",
- fenetreIhm=None,
- docu="",
- regles=(),
- op_init=None,
- niveau=None,
- UIinfo=None,
- **args
- ):
- """
- Méthode d'initialisation de l'objet PROC. Les arguments sont utilisés pour initialiser
- les attributs de meme nom
- """
- self.nom = nom
- self.op = op
- self.reentrant = reentrant
- self.repetable = repetable
- self.fenetreIhm = fenetreIhm
- self.fr = fr
- # self.ang=""
- self.ang = ang
- self.docu = docu
- if type(regles) == tuple:
- self.regles = regles
- else:
- self.regles = (regles,)
- # Attribut op_init : Fonction a appeler a la construction de l
- # operateur sauf si == None
- self.op_init = op_init
- self.entites = args
- current_cata = CONTEXT.getCurrentCata()
- if niveau == None:
- self.niveau = None
- current_cata.enregistre(self)
- else:
- self.niveau = current_cata.getNiveau(niveau)
- self.niveau.enregistre(self)
- self.UIinfo = UIinfo
- self.affecter_parente()
- self.checkDefinition(self.nom)
- self.dejaPrepareDump = False
- self.txtNomComplet = ""
-
- def __call__(self, **args):
- """
- Construit l'objet PROC_ETAPE a partir de sa definition (self),
- puis demande la construction de ses sous-objets et du concept produit.
- """
- etape = self.class_instance(oper=self, args=args)
- etape.MCBuild()
- while etape.doitEtreRecalculee == True:
- etape.doitEtreRecalculee = False
- etape.deepUpdateConditionBlocApresCreation()
- etape.reConstruitResteVal()
- return etape.buildSd()
-
- def make_objet(self, mc_list="oui"):
- """
- Cette méthode crée l'objet PROC_ETAPE dont la définition est self sans
- l'enregistrer ni créer sa sdprod.
- Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
- des objets MCxxx.
- """
- etape = self.class_instance(oper=self, args={})
- if mc_list == "oui":
- etape.MCBuild()
- return etape
-
- def verifCata(self):
- """
- Méthode de vérification des attributs de définition
- """
- self.checkRegles()
- self.checkFr()
- self.checkReentrant()
- self.checkDocu()
- self.checkNom()
- self.checkOp(valmin=0)
- self.verifCataRegles()
-
- def supprime(self):
- """
- Méthode pour supprimer les références arrières susceptibles de provoquer
- des cycles de références
- """
- self.niveau = None
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe PROC_ETAPE qui sert à vérifier et à exécuter
- une procédure
-"""
-
-# Modules Python
-
-import types
-import sys
-import traceback
-
-# Modules EFICAS
-from . import N_MCCOMPO
-from . import N_ETAPE
-from .N_Exception import AsException
-from . import N_utils
-
-
-class PROC_ETAPE(N_ETAPE.ETAPE):
-
- """
- Cette classe hérite de ETAPE. La seule différence porte sur le fait
- qu'une procédure n'a pas de concept produit
-
- """
-
- nature = "PROCEDURE"
-
- def __init__(self, oper=None, reuse=None, args={}):
- """
- Attributs :
- - definition : objet portant les attributs de définition d'une étape de type opérateur. Il
- est initialisé par l'argument oper.
- - valeur : arguments d'entrée de type mot-clé=valeur. Initialisé avec l'argument args.
- - reuse : forcément None pour une PROC
- """
- N_ETAPE.ETAPE.__init__(self, oper, reuse=None, args=args, niveau=5)
- self.reuse = None
-
- def buildSd(self):
- """
- Cette methode applique la fonction op_init au contexte du parent
- et lance l'exécution en cas de traitement commande par commande
- Elle doit retourner le concept produit qui pour une PROC est toujours None
- En cas d'erreur, elle leve une exception : AsException ou EOFError
- """
- if not self.isActif():
- return
- try:
- if self.parent:
- if type(self.definition.op_init) == types.FunctionType:
- self.definition.op_init(*(self, self.parent.g_context))
- else:
- pass
- except AsException as e:
- raise AsException(
- "Etape ",
- self.nom,
- "ligne : ",
- self.appel[0],
- "fichier : ",
- self.appel[1],
- e,
- )
- except EOFError:
- raise
- except:
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- raise AsException(
- "Etape ",
- self.nom,
- "ligne : ",
- self.appel[0],
- "fichier : ",
- self.appel[1] + "\n",
- "".join(l),
- )
-
- self.Execute()
- return None
-
- def supprime(self):
- """
- Méthode qui supprime toutes les références arrières afin que l'objet puisse
- etre correctement détruit par le garbage collector
- """
- N_MCCOMPO.MCCOMPO.supprime(self)
- self.jdc = None
- self.appel = None
-
- def accept(self, visitor):
- """
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
- """
- visitor.visitPROC_ETAPE(self)
-
- def updateContext(self, d):
- """
- Met à jour le contexte de l'appelant passé en argument (d)
- Une PROC_ETAPE n ajoute pas directement de concept dans le contexte
- Seule une fonction enregistree dans op_init pourrait le faire
- """
- if type(self.definition.op_init) == types.FunctionType:
- self.definition.op_init(*(self, d))
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient la classe mere pour les classes de definition des regles d exclusion.
-
- La classe REGLE est la classe de base : elle est virtuelle, elle ne doit pas etre instanciee.
-
- Les classes regles dérivées qui seront instanciées doivent implementer la methode verif
- dont l argument est le dictionnaire des mots cles effectivement presents
- sur lesquels sera operee la verification de la regle
-
- A la creation de l'objet regle on lui passe la liste des noms de mots cles concernes
-
- Exemple ::
-
- # Création de l'objet règle UNPARMI
- r=UNPARMI("INFO","AFFE")
- # Vérification de la règle r sur le dictionnaire passé en argument
- r.verif({"INFO":v1,"AFFE":v2)
-"""
-
-from builtins import object
-import types
-
-
-class REGLE(object):
- def __init__(self, *args):
- """
- Les classes dérivées peuvent utiliser cet initialiseur par défaut ou
- le surcharger
- """
- self.mcs = args
-
- def verif(self, args):
- """
- Les classes dérivées doivent implémenter cette méthode
- qui doit retourner une paire dont le premier élément est une chaine de caractère
- et le deuxième un entier.
-
- L'entier peut valoir 0 ou 1. -- s'il vaut 1, la règle est vérifiée
- s'il vaut 0, la règle n'est pas vérifiée et le texte joint contient
- un commentaire de la non validité.
- """
- raise NotImplementedError("class REGLE should be derived")
-
- def listeToDico(self, args):
- """
- Cette méthode est utilitaire pour les seuls besoins
- des classes dérivées.
-
- Elle transforme une liste de noms de mots clés en un
- dictionnaire équivalent dont les clés sont les noms des mts-clés
-
- Ceci permet d'avoir un traitement identique pour les listes et les dictionnaires
- """
- if type(args) == dict:
- return args
- elif type(args) == list:
- dico = {}
- for arg in args:
- dico[arg] = 0
- return dico
- else:
- raise Exception("Erreur ce n'est ni un dictionnaire ni une liste %s" % args)
+++ /dev/null
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-"""
- Ce module contient les règles nécessaires aux commandes sensibles
- pour renseigner l'attribut etape.sd.sensi, gérer le caractère réentrant
- sur présence de la sensibilité.
-"""
-
-
-from .N_REGLE import REGLE
-
-
-# -----------------------------------------------------------------------------
-class CONCEPT_SENSIBLE(REGLE):
- """Règle permettant de renseigner au niveau du catalogue comment sera
- rempli le concept (valeur nominale ou dérivée(s) ou les deux...).
- """
-
- def __init__(self, mode, mocle="SENSIBILITE"):
- """Constructeur.
-
- mode : manière dont la commande rempli le concept
- - 'ENSEMBLE' : concept nominal ET dérivées en une seule passe
- - 'SEPARE' : concept nominal OU dérivée (une ou plusieurs)
-
- mocle : mot-clé contenant les paramètres sensibles.
- """
- REGLE.__init__(self)
- self.mocle = mocle
- self._modes = {"ENSEMBLE": 0, "SEPARE": 1}
- self.mode = self._modes.get(mode, self._modes["ENSEMBLE"])
-
- def getText(self):
- """Pour EFICAS"""
- return ""
-
- def verif(self, args):
- """Retourne texte + 1 si ok, 0 si nook.
- On stocke dans sd.sensi l'étape courante, c'est-à-dire celle qui
- renseigne le concept si cela n'a pas déjà été fait (car verif est
- appelé à chaque validation).
- """
- obj = args["self"]
- etape = obj.etape
- id_etape = "%s_%s" % (etape.id, id(etape))
- if etape.sd == None:
- return "", 1
- if not hasattr(etape.sd, "sensi"):
- etape.sd.sensi = {}
- # si ENSEMBLE, la sd nominale est forcément produite
- if self.mode == self._modes["ENSEMBLE"] and not "nominal" in etape.sd.sensi:
- etape.sd.sensi["nominal"] = id_etape
- # liste des paramètres sensibles
- valeur = obj[self.mocle]
- if valeur == None:
- # pas de sensibilité, la sd nominale est produite
- if not "nominal" in etape.sd.sensi:
- etape.sd.sensi["nominal"] = id_etape
- return "", 1
- if not type(valeur) in (list, tuple):
- valeur = [
- valeur,
- ]
- for v in valeur:
- if not v.getName() in etape.sd.sensi:
- etape.sd.sensi[v.getName()] = id_etape
- return "", 1
-
-
-# -----------------------------------------------------------------------------
-class REUSE_SENSIBLE(REGLE):
- """Limite le caractère réentrant de la commande.
- On autorisera reuse seulement si le concept (au sens fortran) n'a pas déjà
- été calculé (d'après sd.sensi). Ce sera interdit dans les cas suivants :
- - sd nominale calculée et SENSIBILITE absent
- - PS1 dans SENSIBILITE et sd dérivée par rapport à PS1 calculée
- """
-
- def __init__(self, mocle="SENSIBILITE"):
- """Constructeur.
- mocle : mot-clé SENSIBILITE.
- """
- REGLE.__init__(self)
- self.mocle = mocle
-
- def getText(self):
- """Pour EFICAS"""
- return ""
-
- def verif(self, args):
- """Retourne texte + 1 si ok, 0 si nook = reuse interdit.
- Comme CONCEPT_SENSIBLE est appelé avant (et à chaque validation),
- on regarde si sd.sensi[ps] a été renseigné par une étape précédente.
- """
- obj = args["self"]
- etape = obj.etape
- id_etape = "%s_%s" % (etape.id, id(etape))
- sd = etape.sd
- # si la commande n'est pas réentrante, rien à faire
- if etape.reuse is not None:
- valeur = obj[self.mocle]
- if valeur is None:
- if (
- not hasattr(sd, "sensi")
- or sd.sensi.get("nominal", id_etape) != id_etape
- ):
- # pas de sensibilite et concept nominal déjà calculé : reuse interdit
- text = "Commande non réentrante en l'absence de sensibilité."
- return text, 0
- else:
- if not type(valeur) in (list, tuple):
- valeur = [
- valeur,
- ]
- for ps in valeur:
- if (
- hasattr(sd, "sensi")
- and sd.sensi.get(ps.nom, id_etape) != id_etape
- ):
- # concept dérivé par rapport à ps déjà calculé : reuse interdit
- text = (
- "Commande non réentrante : dérivée par rapport à %s déjà calculée"
- % ps.nom
- )
- return text, 0
- return "", 1
-
-
-# -----------------------------------------------------------------------------
-class DERIVABLE(REGLE):
- """Déclare que le concept fourni derrière un mot-clé est dérivable.
- Sa présence ne suffit pas à le valider, il faut encore que son attribut
- '.sensi' soit cohérent avec le contenu du mot-clé SENSIBILITE (ou l'absence
- de celui-ci).
- """
-
- def __init__(self, mocle):
- """Constructeur.
- mocle : mot-clé dérivable.
- """
- REGLE.__init__(self)
- self.mocle = mocle
-
- def getText(self):
- """Pour EFICAS"""
- return ""
-
- def verif(self, args):
- """ """
- obj = args["self"]
- try:
- concept = obj[self.mocle]
- except IndexError:
- return "", 1
- if not type(concept) in (list, tuple):
- concept = [
- concept,
- ]
- l_ps = obj["SENSIBILITE"]
- for co in concept:
- if co is None:
- text = "Concept non défini (None) sous le mot-clé %s" % self.mocle
- return text, 0
- if not l_ps:
- # pas de sensibilité
- if hasattr(co, "sensi") and not co.sensi.get("nominal"):
- text = (
- "%s ne contient que des valeurs dérivées, utilisez le mot cle SENSIBILITE"
- % co.nom
- )
- return text, 0
- else:
- # sensibilité spécifiée
- if not type(l_ps) in (list, tuple):
- l_ps = [
- l_ps,
- ]
- for ps in l_ps:
- if not hasattr(co, "sensi") or not co.sensi.get(ps.nom):
- text = (
- "La dérivée de %s par rapport à %s n'est pas disponible."
- % (co.nom, ps.nom)
- )
- return text, 0
- return "", 1
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-""" Ce module contient la classe de definition SIMP
- qui permet de spécifier les caractéristiques des mots clés simples
-"""
-
-
-import types
-
-import Accas
-from Noyau import N_ENTITE
-from Noyau import N_MCSIMP
-
-dictPourSql = {
- "I": "BIGINT",
- "R": "FLOAT8",
- "BOOL": "BOOL",
- "TXM": "TEXT",
- "date": "DATE",
-}
-
-
-class SIMP(N_ENTITE.ENTITE):
-
- """
- Classe pour definir un mot cle simple
-
- Cette classe a deux attributs de classe
-
- - class_instance qui indique la classe qui devra etre utilisée
- pour créer l'objet qui servira à controler la conformité d'un
- mot-clé simple avec sa définition
-
- - label qui indique la nature de l'objet de définition (ici, SIMP)
-
- """
-
- class_instance = N_MCSIMP.MCSIMP
- label = "SIMP"
-
- def __init__(
- self,
- typ,
- ang="",
- fr="",
- statut="f",
- into=None,
- intoSug=None,
- siValide=None,
- defaut=None,
- min=1,
- max=1,
- homo=1,
- position="local",
- filtre=None,
- val_min=float("-inf"),
- val_max=float("inf"),
- docu="",
- validators=None,
- nomXML=None,
- sug=None,
- fenetreIhm=None,
- attribut=False,
- sortie="n",
- intoXML=None,
- metAJour=None,
- avecBlancs=False,
- unite=None,
- typeXSD=None,
- formatGit=None,
- affichage=None,
- ):
- """
- Un mot-clé simple est caractérisé par les attributs suivants :
- - type : cet attribut est obligatoire et indique le type de valeur attendue
- - fr : chaîne documentaire en français
- - statut : obligatoire ou facultatif ou caché ou cache avec defaut (d)
- - into : valeurs autorisées
- - intoSug : valeurs possibles mais des valeurs autres du bon type peuvent etre entrees par l utilsateur
- - defaut : valeur par défaut
- - min : nombre minimal de valeurs
- - max : nombre maximal de valeurs
- - homo : un certatin nb de choses qui il faut redispacher ailleurs (information, constant)
- - ang : doc
- - position : si global, le mot-clé peut-être lu n'importe où dans la commande
- - val_min : valeur minimale autorisée
- - val_max : valeur maximale autorisée
- - docu : clef sur de la documentation utilisateur
- - sug : valeur suggere
- - fenetreIhm : si widget particulier
- - attribut : si projection XSD sur attribut
- - creeDesObjetsDeType : type des UserASSD si siValide en cree
- - nomXML : se projette en XSD avec un autre nom pour accepter les tirets
- - sortie : force l ecriture dans le fichier de sortie (utile pour Telemac)
- - affichage : Tuple contenant un nom de gridLayout, puis ligne et colonne pour l affichage
- """
- # print (self)
- # import traceback
- # traceback.print_stack()
- # print (self)
- N_ENTITE.ENTITE.__init__(self, validators)
- # Initialisation des attributs
- self.creeDesObjets = False
- self.utiliseUneReference = False
- self.creeDesObjetsDeType = None
- self.utiliseDesObjetsDeType = None
- if type(typ) == tuple:
- self.type = typ
- else:
- self.type = (typ,)
- for t in self.type:
- try:
- if issubclass(t, Accas.UserASSDMultiple):
- creeDesObjetsDeType = t
- self.utiliseUneReference = True
- elif issubclass(t, Accas.UserASSD):
- creeDesObjetsDeType = t
- self.utiliseUneReference = True
- except:
- pass
- if t == "createObject":
- self.creeDesObjets = True
- if self.utiliseUneReference:
- if self.creeDesObjets:
- self.utiliseUneReference = False
- self.creeDesObjetsDeType = creeDesObjetsDeType
- else:
- self.utiliseDesObjetsDeType = creeDesObjetsDeType
- self.fr = fr
- self.statut = statut
- self.into = into
- self.intoSug = intoSug
- self.siValide = siValide
- self.defaut = defaut
- self.min = min
- self.max = max
- self.homo = homo
- self.position = position
- self.val_min = val_min
- self.val_max = val_max
- self.docu = docu
- self.sug = sug
- self.ang = ang
- if self.max == "**":
- self.max = float("inf")
- if self.val_max == "**":
- self.val_max = float("inf")
- if self.min == "**":
- self.min = float("-inf")
- if self.val_min == "**":
- self.val_min = float("-inf")
- self.fenetreIhm = fenetreIhm
- self.attribut = attribut
- self.nomXML = nomXML
- self.intoXML = intoXML
- self.sortie = sortie
- self.filtre = filtre
- self.avecBlancs = avecBlancs
- self.unite = unite
- self.formatGit = formatGit
- self.affichage = affichage
- if typeXSD:
- self.typeXSD = typeXSD
- if (
- not (self.avecBlancs)
- and self.max > 1
- and "TXM" in self.type
- and self.into != None
- ):
- for val in self.into:
- if val.find(" ") > -1:
- self.avecBlancs = True
- break
- if (
- not (self.avecBlancs)
- and self.max > 1
- and "TXM" in self.type
- and self.intoXML != None
- ):
- for val in self.intoXML:
- if val.find(" ") > -1:
- self.avecBlancs = True
- break
- if self.avecBlancs and not ("TXM" in self.type):
- print("definition incoherente avecBlanc et non texte pour ", self)
- exit()
- if self.filtre:
- self.filtreExpression = self.filtre[0]
- self.filtreVariables = self.filtre[1]
- else:
- self.filtreExpression = []
- self.filtreVariables = []
- self.metAJour = metAJour
-
- def changeInto(self, listeDesIntos):
- self.into = listeDesIntos
-
- def changeIntoSelonValeurs(self, mcRecepteur):
- mcRecepteur.changeInto(self.valeurs)
-
- def addInto(self, nvlInto):
- if self.into == None:
- self.into = []
- if nvlInto in self.into:
- return
- self.into.append(nvlInto)
-
- def changeStatut(self, nvlStatut):
- self.statut = nvlStatut
-
- def changeSiValide(self, nvlFonction):
- self.siValide = nvlFonction
-
- def verifCata(self):
- """
- Cette methode sert à valider les attributs de l'objet de définition
- de la classe SIMP
- """
- self.checkMinMax()
- self.checkFr()
- self.checkStatut()
- self.checkHomo()
- self.checkInto()
- self.checkPosition()
- self.checkValidators()
-
- def dumpStringDataBase(self, inBloc):
- if self.type[0] in dictPourSql:
- leTypeSql = dictPourSql[self.type[0]]
- else:
- leTypeSql = "texte"
- # est-ce toujours vrai ? est ce que cela ne depend pas un peu des tables
- if self.statut == "o" and not inBloc:
- contraintes = "NOT NULL"
- else:
- contraintes = ""
- texte = "\t{} {} {} ,\n".format(self.nom, leTypeSql, contraintes)
- return texte
-
- def __call__(self, val, nom, parent=None, objPyxbDeConstruction=None):
- """
- Construit un objet mot cle simple (MCSIMP) a partir de sa definition (self)
- de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
- """
- return self.class_instance(
- nom=nom,
- definition=self,
- val=val,
- parent=parent,
- objPyxbDeConstruction=objPyxbDeConstruction,
- )
+++ /dev/null
-import types
-import Accas
-import inspect
-
-
-class N_Tuple:
- def __init__(self, ntuple):
- self.ntuple = ntuple
-
- def __convert__(self, valeur):
- try:
- if isinstance(valeur, basestring):
- return None
- except NameError:
- if isinstance(valeur, str):
- return None
- if len(valeur) != self.ntuple:
- return None
- return valeur
-
- def info(self):
- return "Tuple de %s elements" % self.ntuple
-
-
-class N_Matrice:
- def __init__(
- self,
- nbLigs=None,
- nbCols=None,
- methodeCalculTaille=None,
- formatSortie="ligne",
- valSup=None,
- valMin=None,
- structure=None,
- typElt="R",
- typEltInto=None,
- listeHeaders=None,
- coloree=False,
- defaut=None,
- ):
- self.nbLigs = nbLigs
- self.nbCols = nbCols
- self.methodeCalculTaille = methodeCalculTaille
- self.formatSortie = formatSortie
- self.valSup = valSup
- self.valMin = valMin
- self.structure = structure
- self.typElt = typElt
- self.listeHeaders = listeHeaders
- self.typEltInto = typEltInto
- self.jdc = None
- self.coloree = coloree
- self.defaut = defaut
- if self.coloree:
- self.activeCouleur()
-
- def __convert__(self, valeur):
- # Attention ne verifie pas grand chose
- if not isinstance(valeur, types.ListType):
- return None
- return valeur
-
- def verifItem(self, texte, mc):
- val = ""
- if self.typElt == "R":
- try:
- val = float(str(texte))
- ok = True
- except:
- return (False, "Entrer un float SVP")
- if self.typElt == "I":
- try:
- val = int(str(texte))
- ok = True
- except:
- return (False, "Entrer un float SVP")
- if self.typElt in ("R", "I") and self.valSup != None:
- if val > self.valSup:
- return (False, "Entrer un nombre inferieur a " + repr(self.valSup))
- if self.typElt in ("R", "I") and self.valMin != None:
- if val < self.valMin:
- return (False, "Entrer un nombre superieur a " + repr(self.valMin))
- if val == "":
- val = texte
- if self.typEltInto != None and val not in self.typEltInto:
- return "Entrer une valeur contenue dans " + str(self.typEltInto)
- try:
- if issubclass(self.typElt, Accas.ASSD):
- if not self.jdc:
- self.jdc = CONTEXT.getCurrentJdC()
- if not (val in self.jdc.sdsDict.keys()):
- return (False, "Concept inexistant")
- if not (isinstance(self.jdc.sdsDict[val], self.typElt)):
- return (False, "Concept d un autre type")
- a = self.jdc.getSdAvantDuBonType(mc.etape, (self.typElt,))
- if texte not in self.jdc.getSdAvantDuBonType(mc.etape, (self.typElt,)):
- return (False, "Le concept doit etre defini avant")
- except:
- pass
- return (True, "")
-
- def convertItem(self, texte):
- if self.typElt == "R":
- val = float(str(texte))
- if self.typElt == "I":
- val = int(str(texte))
- try:
- if issubclass(self.typElt, Accas.ASSD):
- return self.jdc.sdsDict[texte]
- except:
- pass
-
- def info(self):
- return "Matrice %s x %s" % (self.nbLigs, self.nbCols)
-
- __repr__ = info
- __str__ = info
-
-
-class N_Matrice_Correlation(N_Matrice):
- pass
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-"""
-
-"""
-
-
-from builtins import object
-import traceback
-import sys
-
-from .N_ASSD import ASSD
-from Ihm import CONNECTOR
-
-
-class UserASSD(ASSD):
- """
- Classe de base pour definir des types de structures de donnees definie par
- l utilisateur
- equivalent d un concept ASSD pour un SIMP ou un FACT
- Attention : le parent est a None au debut et non le MC createur que l on ne connait pas
- Lorsqu on ecrit le jdc, n ecrit nom=UserASSD()
- le parent est le SIMP qui cree l objet
- a la lecture si la classe commence par un majuscule on fait le boulot dans MCSIMP, sinon dans
- l init de parametre car le parsing considere qu on a un parametre
- """
-
- def __init__(self, nom="sansNom"):
- # print ('dans init de UserASSD pour ', nom, type(nom))
- self.nom = nom
- self.jdc = CONTEXT.getCurrentJdC()
- self.parent = None
- self.initialiseValeur()
- self.utilisePar = set()
- if self.nom != "sansNom":
- self.id = self.jdc.regSD(self)
- if self.nom != "sansNom":
- self.initialiseNom(nom)
- else:
- self.id = None
- self.ptr_sdj = None
-
- def initialiseParent(self, parent):
- # attention parent.parent peut être un bloc
- # print ('je passe initialiseParent pour : ', self, parent.nom)
- self.parent = parent
- self.etape = self.parent.getEtape()
- self.etape.userASSDCrees.append(self)
- if self.parent.parent != self.etape:
- if self.parent.parent.estIdentifiePar != None:
- print(
- "il y a un souci dans l initialisation de l identifiant pour",
- self.parent.parent.nom,
- )
- print(self.parent.nom)
- print(self.nom)
- self.parent.parent.estIdentifiePar = self
-
- def initialiseNom(self, nom):
- # print ('je passe initialiseNom pour : ', self, nom, type(nom))
- for i, j in list(self.jdc.sdsDict.items()):
- if j == self:
- del self.jdc.sdsDict[i]
- self.jdc.sdsDict[nom] = self
- self.nom = nom
- if self.nom != "sansNom" and self.id == None:
- self.id = self.jdc.regSD(self)
-
- def initialiseValeur(self, valeur=None):
- self.valeur = valeur
-
- def ajoutUtilisePar(self, mc):
- # print ('je passe ajoutUtilisePar pour : ', self.nom)
- self.utilisePar.add(mc)
-
- def enleveUtilisePar(self, mc):
- try:
- self.utilisePar.remove(mc)
- except:
- pass
-
- def renomme(self, nouveauNom):
- print("je passe dans renomme")
- self.jdc.delConcept(self.nom)
- self.jdc.sdsDict[nouveauNom] = self
- self.setName(nouveauNom)
- # print ('je suis dans renomme',nouveauNom, self.nom)
- # print (self.utilisePar)
- for mc in self.utilisePar:
- mc.demandeRedessine()
-
- def transfere(self, obj):
- # uniquement utise pour les lectures XML
- self.utilisePar = obj.utilisePar
- self.id = obj.id
- for mc in self.utilisePar:
- mc.valeur = self
-
- def deleteReference(self, mcCreateur=None):
- print("je passe dans supprime de N_UserASSDMultiple")
- # meme signature que UserASSDMultiple
- for MC in self.utilisePar:
- # le delete est appele en cascade par toute la hierachie
- # du mcsimp (au cas ou on detruise le fact ou le proc)
- # du coup pas beau
- try:
- if type(MC.valeur) in (list, tuple):
- MC.valeur = list(MC.valeur)
- while self in MC.valeur:
- MC.valeur.remove(self)
- if MC.valeur == []:
- MC.Valeur = None
- else:
- MC.valeur = None
- MC.state = "changed"
- MC.isValid()
- CONNECTOR.Emit(MC, "valid")
- except:
- pass
- # on peut avoir des listes qui contiennent plusieurs fois la meme valeur
- self.jdc.delConcept(self.nom)
-
- def executeExpression(self, condition, dico):
- # if self.nom == 'shape1' : print ('je suis dans executeExpression ', self.nom, ' ', condition)
- dict = locals()
- dict.update(dico)
- # if self.nom == 'shape1' or self.nom == 'G1' : print (dict)
- # if self.nom == 'shape1' :
- # print (self.getParentsWithId().getListeUserASSD("systemGeometryId"))
- # print (self.getParentsWithId().getListeUserASSD("SystemGeometryId"))
- # test = eval(condition, globals(), dict)
- # print ('-------------------------------------------------------------------------')
- try:
- test = eval(condition, globals(), dict)
- except:
- print("executeExpression ", self.nom, " ", condition, "exception")
- test = 0
- return test
-
- def getEficasAttribut(self, attribut):
- # print ('je suis dans getEficasAttr', attribut)
- if self.parent == None:
- return None
- # print ('apres if')
- # parent est le SIMP donc c est bien parent.parent
- try:
- valeur = self.parent.parent.getMocle(attribut)
- except:
- valeur = None
- # print (valeur)
- return valeur
-
- def supprime(self, mcCreateur=None):
- # mcCreateur utile pour N_UserASSDMultiple
- print("je passe dans supprime de N_UserASSDMultiple")
- self.deleteReference(mcCreateur)
-
- def __repr__(self):
- return "concept " + self.getName() + " type " + self.__class__.__name__
-
- def __str__(self):
- return self.getName() or "<None>"
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-"""
-"""
-
-from builtins import object
-import traceback
-import sys
-
-from .N_UserASSD import UserASSD
-from .N_ASSD import ASSD
-
-from collections import UserList
-
-
-class UserASSDMultiple(UserASSD):
- """
- Classe de base pour definir des types de structures de donnees definie par
- l utilisateur
- equivalent d un concept ASSD pour un SIMP ou un FACT
- mais pouvant referencer 2 objets par exemple les groupes de mailles qui peuvent porter
- le meme nom dans 2 maillages differents
- """
-
- def __init__(self, nom="sansNom"):
- # print ('dans init de UserASSDMultiple ',nom)
- UserASSD.__init__(self, nom)
- self.peres = []
-
- def ajouteUnPere(self, pere):
- # print ('dans ajouteUnPere', self.peres, self.nom, pere)
- if pere not in self.peres:
- self.peres.append(pere)
- etape = pere.getEtape()
- if self not in etape.userASSDCrees:
- etape.userASSDCrees.append(self)
-
- def renomme(self, nouveauNom):
- print("je passe dans renomme")
- # import traceback
- # traceback.print_stack()
- self.jdc.delConcept(self.nom)
- self.jdc.sdsDict[nouveauNom] = self
- self.setName(nouveauNom)
- for mc in self.utilisePar:
- mc.demandeRedessine()
-
- def initialiseParent(self, pere):
- # surcharge N_UserASSD parent ici n a pas de sens
- pass
-
- def deleteReference(self, mcCreateur):
- print("je passe dans deleteReference", mcCreateur.nom)
- if not (mcCreateur in self.peres):
- return
- self.peres.pop(self.peres.index(mcCreateur))
- if len(self.peres) == 0:
- UserASSD.deleteReference(self)
-
- def getParentsWithId(self):
- # print ('je suis dans getParentsWithId ')
- listeRetour = listUserASSD()
- for pere in self.peres:
- pereWithId = pere.parent
- monEtape = pere.getEtape()
- while pereWithId:
- if pereWithId == monEtape:
- listeRetour.append(pereWithId)
- break
- if pereWithId.estIdentifiePar != None:
- listeRetour.append(pereWithId)
- break
- pereWithId = pereWithId.parent
- return listeRetour
-
- def getEtapes(self):
- listeRetour = listUserASSD()
- for pere in self.peres:
- if pere.etape not in listeRetour:
- listeRetour.append(pere.etape)
- return listeRetour
-
-
-class listUserASSD(UserList):
- def getListeMotsCles(self, nomMc):
- if self.data == None:
- return []
- listeRetour = []
- for concept in self.data:
- listeRetour.append(concept.getChild(nomMc).val)
- return listeRetour
-
- def getListeNomsUserASSD(self, nomMc):
- if self.data == None:
- return []
- listeRetour = []
- for concept in self.data:
- listeRetour.append(concept.getChild(nomMc).val.nom)
- return listeRetour
-
- def getListeUserASSD(self, nomMc):
- if self.data == None:
- return []
- listeRetour = []
- for concept in self.data:
- if concept.getChild(nomMc):
- if concept.getChild(nomMc).val:
- listeRetour.append(concept.getChild(nomMc).val)
- return listeRetour
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-# ======================================================================
-
-"""
- Ce module contient toutes les classes necessaires pour
- implanter le concept de validateur dans Accas
-"""
-
-
-from builtins import object
-
-import types
-import traceback
-import re
-from .N_ASSD import ASSD
-from .N_types import isInt, isFloat_or_int, isComplex, isNumber, isStr, isSequence
-from Accas import A_TUPLE
-from Extensions.i18n import tr
-
-
-class ValError(Exception):
- pass
-
-
-def cls_mro(cls):
- if hasattr(cls, "__mro__"):
- return cls.__mro__
- mro = [cls]
- for base in cls.__bases__:
- mro.extend(cls_mro(base))
- return mro
-
-
-class Protocol(object):
- def __init__(self, name):
- self.registry = {}
- self.name = name
- self.args = {}
-
- def register(self, T, A):
- print("register Protocol", T, A)
- self.registry[T] = A
-
- def adapt(self, obj):
- # (a) verifier si l'objet peut s'adapter au protocole
- adapt = getattr(obj, "__adapt__", None)
- if adapt is not None:
- # on demande à l'objet obj de réaliser lui-meme l'adaptation
- return adapt(self)
-
- # (b) verifier si un adapteur est enregistré (si oui l'utiliser)
- if self.registry:
- for T in cls_mro(obj.__class__):
- if T in self.registry:
- return self.registry[T](obj, self, **self.args)
-
- # (c) utiliser l'adapteur par defaut
- return self.default(obj, **self.args)
-
- def default(self, obj, **args):
- raise TypeError("Can't adapt %s to %s" % (obj.__class__.__name__, self.name))
-
-
-class PProtocol(Protocol):
-
- """Verificateur de protocole paramétré (classe de base)"""
-
- # Protocole paramétré. Le registre est unique pour toutes les instances.
- # La methode register est une methode de classe
- registry = {}
-
- def __init__(self, name, **args):
- self.name = name
- self.args = args
-
- def register(cls, T, A):
- cls.registry[T] = A
-
- register = classmethod(register)
-
-
-class ListProtocol(Protocol):
-
- """Verificateur de protocole liste : convertit un objet quelconque en liste pour validation ultérieure"""
-
- def default(self, obj):
- if type(obj) is tuple:
- if len(obj) > 0 and obj[0] in ("RI", "MP"):
- # il s'agit d'un complexe ancienne mode. La cardinalite vaut 1
- return (obj,)
- else:
- return obj
- elif type(obj) is list:
- return obj
- elif obj == None:
- # pas de valeur affecte. La cardinalite vaut 0
- return obj
- elif isStr(obj):
- # il s'agit d'une chaine. La cardinalite vaut 1
- return (obj,)
- else:
- try:
- # si l'objet supporte len, on a la cardinalite
- length = len(obj)
- return obj
- except:
- # sinon elle vaut 1
- return (obj,)
-
-
-listProto = ListProtocol("list")
-
-
-class TypeProtocol(PProtocol):
-
- """Verificateur de type parmi une liste de types possibles"""
-
- # pas de registre par instance. Registre unique pour toutes les instances
- # de TypeProtocol
- registry = {}
-
- def __init__(self, name, typ=None):
- PProtocol.__init__(self, name, typ=typ)
- self.typ = typ
-
- def default(self, obj, typ):
- err = ""
- for type_permis in typ:
- if type_permis == "createObject":
- continue
- if type_permis == "R":
- if isFloat_or_int(obj):
- return obj
- elif type_permis == "I":
- if isInt(obj):
- return obj
- elif type_permis == "C":
- if self.isComplexe(obj):
- return obj
- elif type_permis == "TXM":
- if isStr(obj):
- return obj
- elif type_permis == "date":
- from datetime import datetime
-
- try:
- d = datetime.strptime(obj, "%Y-%m-%d")
- return obj
- except:
- raise ValError("%s n'est pas une date valide" % repr(obj))
- elif type_permis == "shell":
- if isStr(obj):
- return obj
- elif type_permis == "Fichier":
- import os
-
- try:
- if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj):
- return obj
- else:
- raise ValError("%s n'est pas un fichier valide" % repr(obj))
- except:
- raise ValError("%s n'est pas un fichier valide" % repr(obj))
-
- elif type_permis == "FichierNoAbs":
- import os
-
- if (len(typ) > 2 and typ[2] == "Sauvegarde") or isinstance(
- obj, type("")
- ):
- return obj
- else:
- raise ValError("%s n'est pas un fichier valide" % repr(obj))
-
- elif type_permis == "Repertoire":
- import os
-
- try:
- if os.path.isdir(obj):
- return obj
- else:
- raise ValError("%s n'est pas un repertoire valide" % repr(obj))
- except:
- raise ValError("%s n'est pas un repertoire valide" % repr(obj))
- elif type_permis == "FichierOuRepertoire":
- import os
-
- try:
- if os.path.isdir(obj) or os.path.isfile(obj):
- return obj
- else:
- raise ValError(
- "%s n'est pas un fichier ou un repertoire valide"
- % repr(obj)
- )
- except:
- raise ValError(
- "%s n'est pas un fichier ou un repertoire valide" % repr(obj)
- )
- elif type(type_permis) == type or isinstance(type_permis, type):
- try:
- if self.isObjectFrom(obj, type_permis):
- return obj
- except Exception as err:
- pass
- elif isinstance(type_permis, A_TUPLE.Tuple):
- try:
- if type_permis.__convert__(obj):
- return obj
- except Exception as err:
- pass
- elif isinstance(type_permis, object):
- try:
- if type_permis.__convert__(obj):
- return obj
- except Exception as err:
- pass
- else:
- print(("Type non encore gere %s" % type_permis))
- raise ValError(
- tr("%s (de type %s) n'est pas d'un type autorise: %s ")
- % (repr(obj), type(obj), typ)
- )
- # import traceback; traceback.print_stack()
- # print (object, type_permis,)
-
- def isComplexe(self, valeur):
- """Retourne 1 si valeur est un complexe, 0 sinon"""
- if isNumber(valeur):
- # Pour permettre l'utilisation de complexes Python (accepte les
- # entiers et réels)
- return 1
- elif type(valeur) != tuple:
- # On n'autorise pas les listes pour les complexes
- return 0
- elif len(valeur) != 3:
- return 0
- else:
- # Un complexe doit etre un tuple de longueur 3 avec 'RI' ou 'MP' comme premiere
- # valeur suivie de 2 reels.
- if valeur[0].strip() in ("RI", "MP"):
- try:
- v1 = reelProto.adapt(valeur[1]), reelProto.adapt(valeur[2])
- return 1
- except:
- return 0
- else:
- return 0
-
- def isObjectFrom(self, objet, classe):
- """
- Retourne 1 si objet est une instance de la classe classe, 0 sinon
- """
- convert = getattr(classe, "__convert__", None)
- if convert is not None:
- # classe verifie les valeurs
- try:
- v = convert(objet)
- return v is not None
- except ValueError as err:
- raise
- except:
- return 0
- # On accepte les instances de la classe et des classes derivees
- return isinstance(objet, classe)
-
-
-reelProto = TypeProtocol("reel", typ=("R",))
-
-
-class CardProtocol(PProtocol):
-
- """Verificateur de cardinalité"""
-
- # pas de registre par instance. Registre unique pour toutes les instances
- registry = {}
-
- def __init__(self, name, min=1, max=1):
- PProtocol.__init__(self, name, min=min, max=max)
-
- def default(self, obj, min, max):
- length = len(obj)
- if (length < min) or (length > max):
- raise ValError(
- "Nombre d'arguments de %s incorrect (min = %s, max = %s)"
- % (repr(obj), min, max)
- )
- return obj
-
-
-class IntoProtocol(PProtocol):
-
- """Verificateur de choix possibles : liste discrète ou intervalle"""
-
- # pas de registre par instance. Registre unique pour toutes les instances
- registry = {}
-
- def __init__(self, name, into=None, val_min=float("-inf"), val_max=float("inf")):
- PProtocol.__init__(self, name, into=into, val_min=val_min, val_max=val_max)
- self.val_min = val_min
- self.val_max = val_max
-
- def default(self, obj, into, val_min, val_max):
- if type(into) == types.FunctionType:
- maListeDeValeur = into()
- into = maListeDeValeur
- if into:
- if obj not in into:
- raise ValError(
- tr("La valeur : %s ne fait pas partie des choix possibles %s")
- % (repr(obj), into)
- )
- else:
- # on est dans le cas d'un ensemble continu de valeurs possibles
- # (intervalle)
- if isFloat_or_int(obj):
- if val_min == "**":
- val_min = obj - 1
- if val_max == "**":
- val_max = obj + 1
- if obj < val_min or obj > val_max:
- raise ValError(
- tr(
- "La valeur : %s est en dehors du domaine de validite [ %s , %s ]"
- )
- % (repr(obj), self.val_min, self.val_max)
- )
- return obj
-
-
-class MinStr(object):
- # exemple de classe pour verificateur de type
- # on utilise des instances de classe comme type (typ=MinStr(3,6), par
- # exemple)
-
- def __init__(self, min, max):
- self.min = min
- self.max = max
-
- def __convert__(self, valeur):
- if isStr(valeur) and self.min <= len(valeur) <= self.max:
- return valeur
- raise ValError(
- "%s n'est pas une chaine de longueur comprise entre %s et %s"
- % (valeur, self.min, self.max)
- )
-
- def __repr__(self):
- return tr("TXM de longueur entre %s et %s" % (self.min, self.max))
-
-
-class Valid(PProtocol):
-
- """
- Cette classe est la classe mere des validateurs Accas
- Elle doit etre derivee
- Elle presente la signature des methodes indispensables pour son bon
- fonctionnement et dans certains cas leur comportement par défaut.
-
- @ivar cata_info: raison de la validite ou de l'invalidite du validateur meme
- @type cata_info: C{}
- """
-
- registry = {}
-
- def __init__(self, **args):
- PProtocol.__init__(self, "valid", **args)
-
- def info(self):
- """
- Cette methode retourne une chaine de caractères informative sur
- la validation demandée par le validateur. Elle est utilisée
- pour produire le compte-rendu de validité du mot clé associé.
- """
- return "valeur valide"
-
- def aide(self):
- """
- Cette methode retourne une chaine de caractère qui permet
- de construire un message d'aide en ligne.
- En général, le message retourné est le meme que celui retourné par la
- méthode info.
- """
- return self.info()
-
- def infoErreurItem(self):
- """
- Cette méthode permet d'avoir un message d'erreur pour un item
- dans une liste dans le cas ou le validateur fait des vérifications
- sur les items d'une liste. Si le validateur fait seulement des
- vérifications sur la liste elle meme et non sur ses items, la méthode
- doit retourner une chaine vide.
- """
- return " "
-
- def infoErreurListe(self):
- """
- Cette méthode a un comportement complémentaire de celui de
- infoErreurItem. Elle retourne un message d'erreur lié uniquement
- aux vérifications sur la liste elle meme et pas sur ses items.
- Dans le cas où le validateur ne fait pas de vérification sur des
- listes, elle retourne une chaine vide
- """
- return " "
-
- def verif(self, valeur):
- """
- Cette methode sert a verifier si la valeur passee en argument est consideree
- comme valide ou non par le validateur. Dans le premier cas le validateur retourne 1
- (valide) sinon 0 (invalide).
-
- @type valeur: tout type python
- @param valeur: valeur du mot cle a valider
- @rtype: C{boolean}
- @return: indicateur de validite 1 (valide) ou 0 (invalide)
- """
- raise NotImplementedError("Must be implemented")
-
- def verifItem(self, valeur):
- """
- La methode verif du validateur effectue une validation complete de
- la valeur. valeur peut etre un scalaire ou une liste. Le validateur
- doit traiter les 2 aspects s'il accepte des listes (dans ce cas la
- methode isList doit retourner 1).
- La methode valid_item sert pour effectuer des validations partielles
- de liste. Elle doit uniquement verifier la validite d'un item de
- liste mais pas les caracteristiques de la liste.
- """
- return 0
-
- def valideListePartielle(self, liste_courante):
- """
- Cette methode retourne un entier qui indique si liste_courante est partiellement valide (valeur 1)
- ou invalide (valeur 0). La validation partielle concerne les listes en cours de construction : on
- veut savoir si la liste en construction peut etre complétée ou si elle peut déjà etre considérée
- comme invalide.
- En général un validateur effectue la meme validation pour les listes partielles et les
- listes complètes.
- """
- return self.verif(liste_courante)
-
- def verifCata(self):
- """
- Cette methode sert a realiser des verifications du validateur lui meme.
- Elle est facultative et retourne 1 (valide) par defaut.
- Elle retourne 0 si le validateur est lui meme invalide si par exemple ses
- parametres de definition ne sont pas corrects.
- La raison de l'invalidite est stockee dans l'attribut cata_info.
-
- @rtype: C{boolean}
- @return: indicateur de validite 1 (valide) ou 0 (invalide)
- """
- return 1
-
- def isList(self):
- """
- Cette méthode retourne un entier qui indique si le validateur
- permet les listes (valeur 1) ou ne les permet pas (valeur 0).
- Par défaut, un validateur n'autorise que des scalaires.
- """
- return 0
-
- def hasInto(self):
- """
- Cette méthode retourne un entier qui indique si le validateur
- propose une liste de choix (valeur 1) ou n'en propose pas.
- Par défaut, un validateur n'en propose pas.
- """
- return 0
-
- def getInto(self, liste_courante=None, into_courant=None):
- """
- Cette méthode retourne la liste de choix proposée par le validateur.
- Si le validateur ne propose pas de liste de choix, la méthode
- retourne None.
- L'argument d'entrée liste_courante, s'il est différent de None, donne
- la liste des choix déjà effectués par l'utilisateur. Dans ce cas, la
- méthode getInto doit calculer la liste des choix en en tenant
- compte. Par exemple, si le validateur n'autorise pas les répétitions,
- la liste des choix retournée ne doit pas contenir les choix déjà
- contenus dans liste_courante.
- L'argument d'entrée into_courant, s'il est différent de None, donne
- la liste des choix proposés par d'autres validateurs. Dans ce cas,
- la méthode getInto doit calculer la liste des choix à retourner
- en se limitant à cette liste initiale. Par exemple, si into_courant
- vaut (1,2,3) et que le validateur propose la liste de choix (3,4,5),
- la méthode ne doit retourner que (3,).
-
- La méthode getInto peut retourner une liste vide [], ce qui veut
- dire qu'il n'y a pas (ou plus) de choix possible. Cette situation
- peut etre normale : l''utilisateur a utilisé tous les choix, ou
- résulter d'une incohérence des validateurs :
- choix parmi (1,2,3) ET choix parmi (4,5,6). Il est impossible de
- faire la différence entre ces deux situations.
- """
- return into_courant
-
-
-class ListVal(Valid):
-
- """
- Cette classe sert de classe mère pour tous les validateurs qui acceptent
- des listes.
- """
-
- def isList(self):
- return 1
-
- def getInto(self, liste_courante=None, into_courant=None):
- """
- Cette méthode getInto effectue un traitement général qui consiste
- a filtrer la liste de choix into_courant, si elle existe, en ne
- conservant que les valeurs valides (appel de la méthode valid).
- """
- if into_courant is None:
- return None
- else:
- liste_choix = []
- for e in into_courant:
- if self.verif(e):
- liste_choix.append(e)
- return liste_choix
-
- def convert(self, valeur):
- """
- Méthode convert pour les validateurs de listes. Cette méthode
- fait appel à la méthode convertItem sur chaque élément de la
- liste.
- """
- if isSequence(valeur):
- for val in valeur:
- self.convertItem(val)
- return valeur
- else:
- return self.convertItem(valeur)
-
- def verif(self, valeur):
- """
- Méthode verif pour les validateurs de listes. Cette méthode
- fait appel à la méthode verifItem sur chaque élément de la
- liste. Si valeur est un paramètre, on utilise sa valeur effective
- valeur.valeur.
- """
- if isSequence(valeur):
- for val in valeur:
- if not self.verifItem(val):
- return 0
- return 1
- else:
- return self.verifItem(valeur)
-
-
-class Compulsory(ListVal):
- """
- Validateur operationnel
- Verification de la présence obligatoire d'un élément dans une liste
- """
-
- registry = {}
-
- def __init__(self, elem=()):
- if not isSequence(elem):
- elem = (elem,)
- Valid.__init__(self, elem=elem)
- self.elem = elem
- self.cata_info = ""
-
- def info(self):
- return tr("valeur %s obligatoire") % self.elem
-
- def default(self, valeur, elem):
- return valeur
-
- def verifItem(self, valeur):
- return 1
-
- def convert(self, valeur):
- elem = list(self.elem)
- for val in valeur:
- v = self.adapt(val)
- if v in elem:
- elem.remove(v)
- if elem:
- raise ValError(
- tr("%s ne contient pas les elements obligatoires : %s ")
- % (valeur, elem)
- )
- return valeur
-
- def hasInto(self):
- return 1
-
- def verif(self, valeur):
- if not isSequence(valeur):
- liste = list(valeur)
- else:
- liste = valeur
- for val in self.elem:
- if val not in liste:
- return 0
- return 1
-
- def infoErreurItem(self):
- return tr("La valeur n'est pas dans la liste des choix possibles")
-
-
-class Together(ListVal):
- """
- Validateur operationnel
- si un des éléments est présent les autres doivent aussi l'être
- """
-
- registry = {}
-
- def __init__(self, elem=()):
- if not isSequence(elem):
- elem = (elem,)
- Valid.__init__(self, elem=elem)
- self.elem = elem
- self.cata_info = ""
-
- def info(self):
- return tr("%s present ensemble") % self.elem
-
- def default(self, valeur, elem):
- return valeur
-
- def verifItem(self, valeur):
- return 1
-
- def convert(self, valeur):
- elem = list(self.elem)
- for val in valeur:
- v = self.adapt(val)
- if v in elem:
- elem.remove(v)
- if len(elem) == 0:
- return valeur
- if len(elem) != len(list(self.elem)):
- raise ValError(
- tr("%s ne contient pas les elements devant etre presents ensemble: %s ")
- % (valeur, elem)
- )
- return valeur
-
- def hasInto(self):
- return 1
-
- def verif(self, valeur):
- if not isSequence(valeur):
- liste = list(valeur)
- else:
- liste = valeur
- compte = 0
- for val in self.elem:
- if val in liste:
- compte += 1
- if compte == 0:
- return 1
- if compte != len(list(self.elem)):
- return 0
- return 1
-
- def infoErreurItem(self):
- return tr("La valeur n'est pas dans la liste des choix possibles")
-
-
-class Absent(ListVal):
- """
- Validateur operationnel
- si un des éléments est présent non valide
- """
-
- registry = {}
-
- def __init__(self, elem=()):
- if not isSequence(elem):
- elem = (elem,)
- Valid.__init__(self, elem=elem)
- self.elem = elem
- self.cata_info = ""
-
- def info(self):
- return tr("%s absent") % self.elem
-
- def default(self, valeur, elem):
- return valeur
-
- def verifItem(self, valeur):
- return 1
-
- def convert(self, valeur):
- elem = list(self.elem)
- for val in valeur:
- v = self.adapt(val)
- if v in elem:
- raise ValError(tr("%s n'est pas autorise : %s ") % (v, elem))
- return valeur
-
- def hasInto(self):
- return 1
-
- def verif(self, valeur):
- if not isSequence(valeur):
- liste = list(valeur)
- else:
- liste = valeur
- for val in self.elem:
- if val in liste:
- return 0
- return 1
-
- def infoErreurItem(self):
- return tr("La valeur n'est pas dans la liste des choix possibles")
-
-
-class NoRepeat(ListVal):
- """
- Validateur operationnel
- Verification d'absence de doublons dans la liste.
- """
-
- def __init__(self):
- Valid.__init__(self)
- self.cata_info = ""
-
- def info(self):
- return tr("Pas de doublon dans la liste")
-
- def infoErreurListe(self):
- return tr("Les doublons ne sont pas permis")
-
- def default(self, valeur):
- if valeur in self.liste:
- raise ValError(tr("%s est un doublon") % valeur)
- return valeur
-
- def convert(self, valeur):
- self.liste = []
- for val in valeur:
- v = self.adapt(val)
- self.liste.append(v)
- return valeur
-
- def verifItem(self, valeur):
- return 1
-
- def verif(self, valeur):
- if isSequence(valeur):
- liste = list(valeur)
- for val in liste:
- if liste.count(val) != 1:
- return 0
- return 1
- else:
- return 1
-
- def getInto(self, liste_courante=None, into_courant=None):
- """
- Methode getInto spécifique pour validateur NoRepeat, on retourne
- une liste de choix qui ne contient aucune valeur de into_courant
- déjà contenue dans liste_courante
- """
- if into_courant is None:
- liste_choix = None
- else:
- liste_choix = []
- for e in into_courant:
- if e in liste_choix:
- continue
- if liste_courante is not None and e in liste_courante:
- continue
- liste_choix.append(e)
- return liste_choix
-
-
-class LongStr(ListVal):
-
- """
- Validateur operationnel
- Verification de la longueur d une chaine
- """
-
- def __init__(self, low, high):
- ListVal.__init__(self, low=low, high=high)
- self.low = low
- self.high = high
- self.cata_info = ""
-
- def info(self):
- return tr("longueur de la chaine entre %s et %s") % (self.low, self.high)
-
- def infoErreurItem(self):
- return tr("Longueur de la chaine incorrecte")
-
- def convert(self, valeur):
- for val in valeur:
- v = self.adapt(val)
- return valeur
-
- def verifItem(self, valeur):
- try:
- self.adapt(valeur)
- return 1
- except:
- return 0
-
- def default(self, valeur, low, high):
- if not isStr(valeur):
- raise ValError("%s n'est pas une chaine" % repr(valeur))
- if valeur[0] == "'" and valeur[-1] == "'":
- low = low + 2
- high = high + 2
- if len(valeur) < low or len(valeur) > high:
- raise ValError("%s n'est pas de la bonne longueur" % repr(valeur))
- return valeur
-
-
-class OnlyStr(ListVal):
-
- """
- Validateur operationnel
- Valide que c'est une chaine
- """
-
- def __init__(self):
- ListVal.__init__(self)
- self.cata_info = ""
-
- def info(self):
- return tr("regarde si c'est une chaine")
-
- def infoErreurItem(self):
- return tr("Ce n'est pas une chaine")
-
- def convert(self, valeur):
- for val in valeur:
- v = self.adapt(val)
- return valeur
-
- def verifItem(self, valeur):
- try:
- self.adapt(valeur)
- return 1
- except:
- return 0
-
- def default(self, valeur):
- if not isStr(valeur):
- raise ValError(tr("%s n'est pas une chaine") % repr(valeur))
- return valeur
-
-
-class OrdList(ListVal):
-
- """
- Validateur operationnel
- Verification qu'une liste est croissante ou decroissante
- """
-
- def __init__(self, ord):
- ListVal.__init__(self, ord=ord)
- self.ord = ord
- self.cata_info = ""
-
- def info(self):
- return "liste %s" % self.ord
-
- def infoErreurListe(self):
- return tr("La liste doit etre en ordre %s") % self.ord
-
- def convert(self, valeur):
- self.val = None
- self.liste = valeur
- for v in valeur:
- self.adapt(v)
- return valeur
-
- def default(self, valeur, ord):
- if self.ord == "croissant":
- if self.val is not None and valeur < self.val:
- raise ValError(
- (tr("%s n'est pas par valeurs croissantes") % repr(self.liste))
- )
- elif self.ord == "decroissant":
- if self.val is not None and valeur > self.val:
- raise ValError(
- (tr("%s n'est pas par valeurs decroissantes") % repr(self.liste))
- )
- self.val = valeur
- return valeur
-
- def verifItem(self, valeur):
- return 1
-
- def getInto(self, liste_courante=None, into_courant=None):
- """
- Methode getInto spécifique pour validateur OrdList, on retourne
- une liste de choix qui ne contient aucune valeur de into_courant
- dont la valeur est inférieure à la dernière valeur de
- liste_courante, si elle est différente de None.
- """
- if into_courant is None:
- return None
- elif not liste_courante:
- return into_courant
- else:
- liste_choix = []
- last_val = liste_choix[-1]
- for e in into_courant:
- if self.ord == "croissant" and e <= last_val:
- continue
- if self.ord == "decroissant" and e >= last_val:
- continue
- liste_choix.append(e)
- return liste_choix
-
-
-class OrVal(Valid):
-
- """
- Validateur operationnel
- Cette classe est un validateur qui controle une liste de validateurs
- Elle verifie qu'au moins un des validateurs de la liste valide la valeur
- """
-
- def __init__(self, validators=()):
- if not isSequence(validators):
- validators = (validators,)
- self.validators = []
- for validator in validators:
- if type(validator) == types.FunctionType:
- self.validators.append(FunctionVal(validator))
- else:
- self.validators.append(validator)
- self.cata_info = ""
-
- def info(self):
- return "\n ou ".join([v.info() for v in self.validators])
-
- def convert(self, valeur):
- for validator in self.validators:
- try:
- return validator.convert(valeur)
- except:
- pass
- raise ValError(tr("%s n'est pas du bon type") % repr(valeur))
-
- def infoErreurItem(self):
- l = []
- for v in self.validators:
- err = v.infoErreurItem()
- if err != " ":
- l.append(err)
- chaine = " \n ou ".join(l)
- return chaine
-
- def infoErreurListe(self):
- l = []
- for v in self.validators:
- err = v.infoErreurListe()
- if err != " ":
- l.append(err)
- chaine = " \n ou ".join(l)
- return chaine
-
- def isList(self):
- """
- Si plusieurs validateurs sont reliés par un OU
- il suffit qu'un seul des validateurs attende une liste
- pour qu'on considère que leur union attend une liste.
- """
- for validator in self.validators:
- v = validator.isList()
- if v:
- return 1
- return 0
-
- def verif(self, valeur):
- for validator in self.validators:
- v = validator.verif(valeur)
- if v:
- return 1
- return 0
-
- def verifItem(self, valeur):
- for validator in self.validators:
- v = validator.verifItem(valeur)
- if v:
- return 1
- return 0
-
- def verifCata(self):
- infos = []
- for validator in self.validators:
- v = validator.verifCata()
- if not v:
- infos.append(validator.cata_info)
- if infos:
- self.cata_info = "\n".join(infos)
- return 0
- self.cata_info = ""
- return 1
-
- def hasInto(self):
- """
- Dans le cas ou plusieurs validateurs sont reliés par un OU
- il faut que tous les validateurs proposent un choix pour
- qu'on considère que leur union propose un choix.
- Exemple : Enum(1,2,3) OU entier pair, ne propose pas de choix
- En revanche, Enum(1,2,3) OU Enum(4,5,6) propose un choix (1,2,3,4,5,6)
- """
- for validator in self.validators:
- v = validator.hasInto()
- if not v:
- return 0
- return 1
-
- def getInto(self, liste_courante=None, into_courant=None):
- """
- Dans le cas ou plusieurs validateurs sont reliés par un OU
- tous les validateurs doivent proposer un choix pour
- qu'on considère que leur union propose un choix. Tous les choix
- proposés par les validateurs sont réunis (opérateur d'union).
- Exemple : Enum(1,2,3) OU entier pair, ne propose pas de choix
- En revanche, Enum(1,2,3) OU Enum(4,5,6) propose un
- choix (1,2,3,4,5,6)
- """
- validator_into = []
- for validator in self.validators:
- v_into = validator.getInto(liste_courante, into_courant)
- if v_into is None:
- return v_into
- validator_into.extend(v_into)
- return validator_into
-
- def valideListePartielle(self, liste_courante=None):
- """
- Méthode de validation de liste partielle pour le validateur Or.
- Si un des validateurs gérés par le validateur Or considère la
- liste comme valide, le validateur Or la considère comme valide.
- """
- for validator in self.validators:
- v = validator.valideListePartielle(liste_courante)
- if v:
- return 1
- return 0
-
-
-class AndVal(Valid):
-
- """
- Validateur operationnel
- Cette classe est un validateur qui controle une liste de validateurs
- Elle verifie que tous les validateurs de la liste valident la valeur
- """
-
- def __init__(self, validators=()):
- if not isSequence(validators):
- validators = (validators,)
- self.validators = []
- for validator in validators:
- if type(validator) == types.FunctionType:
- self.validators.append(FunctionVal(validator))
- else:
- self.validators.append(validator)
- if hasattr(validator, "fonctions"):
- for fonction in validator.fonctions:
- f = getattr(validator, fonction)
- setattr(self, fonction, f)
- self.cata_info = ""
-
- def set_MCSimp(self, MCSimp):
- for validator in self.validators:
- if hasattr(validator, "set_MCSimp"):
- validator.set_MCSimp(MCSimp)
-
- def info(self):
- return "\n et ".join([v.info() for v in self.validators])
-
- def convert(self, valeur):
- for validator in self.validators:
- valeur = validator.convert(valeur)
- return valeur
-
- def infoErreurItem(self):
- chaine = ""
- a = 1
- for v in self.validators:
- if v.infoErreurItem() != " ":
- if a == 1:
- chaine = v.infoErreurItem()
- a = 0
- else:
- chaine = chaine + " \n et " + v.infoErreurItem()
- return chaine
-
- def infoErreurListe(self):
- chaine = ""
- a = 1
- for v in self.validators:
- if v.infoErreurListe() != " ":
- if a == 1:
- chaine = v.infoErreurListe()
- a = 0
- else:
- chaine = chaine + " \n et " + v.infoErreurListe()
- return chaine
-
- def verif(self, valeur):
- for validator in self.validators:
- v = validator.verif(valeur)
- if not v:
- self.local_info = validator.info()
- return 0
- return 1
-
- def verifItem(self, valeur):
- for validator in self.validators:
- v = validator.verifItem(valeur)
- if not v:
- # L'info n'est probablement pas la meme que pour verif ???
- self.local_info = validator.info()
- return 0
- return 1
-
- def verifCata(self):
- infos = []
- for validator in self.validators:
- v = validator.verifCata()
- if not v:
- infos.append(validator.cata_info)
- if infos:
- self.cata_info = "\n".join(infos)
- return 0
- self.cata_info = ""
- return 1
-
- def valideListePartielle(self, liste_courante=None):
- """
- Méthode de validation de liste partielle pour le validateur And.
- Tous les validateurs gérés par le validateur And doivent considérer
- la liste comme valide, pour que le validateur And la considère
- comme valide.
- """
- for validator in self.validators:
- v = validator.valideListePartielle(liste_courante)
- if not v:
- return 0
- return 1
-
- def isList(self):
- """
- Si plusieurs validateurs sont reliés par un ET
- il faut que tous les validateurs attendent une liste
- pour qu'on considère que leur intersection attende une liste.
- Exemple Range(2,5) ET Card(1) n'attend pas une liste
- Range(2,5) ET Pair attend une liste
- """
- for validator in self.validators:
- v = validator.isList()
- if v == 0:
- return 0
- return 1
-
- def hasInto(self):
- """
- Dans le cas ou plusieurs validateurs sont reliés par un ET
- il suffit qu'un seul validateur propose un choix pour
- qu'on considère que leur intersection propose un choix.
- Exemple : Enum(1,2,3) ET entier pair, propose un choix
- En revanche, entier pair ET superieur à 10 ne propose pas de choix
- """
- for validator in self.validators:
- v = validator.hasInto()
- if v:
- return 1
- return 0
-
- def getInto(self, liste_courante=None, into_courant=None):
- """
- Dans le cas ou plusieurs validateurs sont reliés par un ET
- il suffit qu'un seul validateur propose un choix pour
- qu'on considère que leur intersection propose un choix. Tous les
- choix proposés par les validateurs sont croisés (opérateur
- d'intersection)
- Exemple : Enum(1,2,3) ET entier pair, propose un choix (2,)
- En revanche, Enum(1,2,3) ET Enum(4,5,6) ne propose pas de choix.
- """
- for validator in self.validators:
- into_courant = validator.getInto(liste_courante, into_courant)
- if into_courant in ([], None):
- break
- return into_courant
-
-
-def do_liste(validators):
- """
- Convertit une arborescence de validateurs en OrVal ou AndVal
- validators est une liste de validateurs ou de listes ou de tuples
- """
- valids = []
- for validator in validators:
- if type(validator) == types.FunctionType:
- valids.append(FunctionVal(validator))
- elif type(validator) is tuple:
- valids.append(OrVal(do_liste(validator)))
- elif type(validator) is list:
- valids.append(AndVal(do_liste(validator)))
- else:
- valids.append(validator)
- return valids
-
-
-def validatorFactory(validator):
- if type(validator) == types.FunctionType:
- return FunctionVal(validator)
- elif type(validator) is tuple:
- return OrVal(do_liste(validator))
- elif type(validator) is list:
- return AndVal(do_liste(validator))
- else:
- return validator
-
-
-# Ci-dessous : exemples de validateur (peu testés)
-
-
-class RangeVal(ListVal):
-
- """
- Exemple de classe validateur : verification qu'une valeur
- est dans un intervalle.
- Pour une liste on verifie que tous les elements sont
- dans l'intervalle
- Susceptible de remplacer les attributs "vale_min" "vale_max"
- dans les catalogues
- """
-
- def __init__(self, low, high):
- self.low = low
- self.high = high
- self.cata_info = tr("%s doit etre inferieur a %s") % (low, high)
-
- def info(self):
- return tr("valeur dans l'intervalle %s , %s") % (self.low, self.high)
-
- def convertItem(self, valeur):
- if valeur > self.low and valeur < self.high:
- return valeur
- raise ValError(
- tr("%s devrait etre comprise entre %s et %s")
- % (valeur, self.low, self.high)
- )
-
- def verifItem(self, valeur):
- return valeur > self.low and valeur < self.high
-
- def infoErreurItem(self):
- return tr("la valeur %s doit etre comprise entre %s et %s") % (
- valeur,
- self.low,
- self.high,
- )
-
- def verifCata(self):
- if self.low > self.high:
- return 0
- return 1
-
-
-class CardVal(Valid):
-
- """
- Exemple de classe validateur : verification qu'une liste est
- d'une longueur superieur a un minimum (min) et inferieure
- a un maximum (max).
- Susceptible de remplacer les attributs "min" "max" dans les
- catalogues
- """
-
- def __init__(self, min=float("-inf"), max=float("inf")):
- self.min = min
- self.max = max
- self.cata_info = tr("%s doit etre inferieur a %s") % (min, max)
-
- def info(self):
- return tr("longueur de liste comprise entre %s et %s") % (self.min, self.max)
-
- def infoErreurListe(self):
- return tr("Le cardinal de la liste doit etre compris entre %s et %s") % (
- self.min,
- self.max,
- )
-
- def isList(self):
- return self.max == "**" or self.max > 1
-
- def getInto(self, liste_courante=None, into_courant=None):
- if into_courant is None:
- return None
- elif liste_courante is None:
- return into_courant
- elif self.max == "**":
- return into_courant
- elif len(liste_courante) < self.max:
- return into_courant
- else:
- return []
-
- def convert(self, valeur):
- if isSequence(valeur):
- l = len(valeur)
- elif valeur is None:
- l = 0
- else:
- l = 1
- if self.max != "**" and l > self.max:
- raise ValError(
- tr("%s devrait etre de longueur inferieure a %s") % (valeur, self.max)
- )
- if self.min != "**" and l < self.min:
- raise ValError(
- tr("%s devrait etre de longueur superieure a %s") % (valeur, self.min)
- )
- return valeur
-
- def verifItem(self, valeur):
- return 1
-
- def verif(self, valeur):
- if isSequence(valeur):
- if self.max != "**" and len(valeur) > self.max:
- return 0
- if self.min != "**" and len(valeur) < self.min:
- return 0
- return 1
- else:
- if self.max != "**" and 1 > self.max:
- return 0
- if self.min != "**" and 1 < self.min:
- return 0
- return 1
-
- def verifCata(self):
- if self.min != "**" and self.max != "**" and self.min > self.max:
- return 0
- return 1
-
- def valideListePartielle(self, liste_courante=None):
- validite = 1
- if liste_courante != None:
- if len(liste_courante) > self.max:
- validite = 0
- return validite
-
-
-class PairVal(ListVal):
-
- """
- Exemple de classe validateur : verification qu'une valeur
- est paire.
- Pour une liste on verifie que tous les elements sont
- pairs
- """
-
- def __init__(self):
- ListVal.__init__(self)
- self.cata_info = ""
-
- def info(self):
- return _("valeur paire")
-
- def infoErreurItem(self):
- return tr("La valeur saisie doit etre paire")
-
- def convert(self, valeur):
- for val in valeur:
- v = self.adapt(val)
- if v % 2 != 0:
- raise ValError(tr("%s contient des valeurs non paires") % repr(valeur))
- return valeur
-
- def default(self, valeur):
- return valeur
-
- def verifItem(self, valeur):
- if type(valeur) not in six.integer_types:
- return 0
- return valeur % 2 == 0
-
- def verif(self, valeur):
- if isSequence(valeur):
- for val in valeur:
- if val % 2 != 0:
- return 0
- return 1
- else:
- if valeur % 2 != 0:
- return 0
- return 1
-
-
-class EnumVal(ListVal):
-
- """
- Exemple de classe validateur : verification qu'une valeur
- est prise dans une liste de valeurs.
- Susceptible de remplacer l attribut "into" dans les catalogues
- """
-
- def __init__(self, into=()):
- if not isSequence(into):
- into = (into,)
- self.into = into
- self.cata_info = ""
-
- def info(self):
- return "valeur dans %s" % self.into
-
- def convertItem(self, valeur):
- if valeur in self.into:
- return valeur
- raise ValError(
- tr("%s contient des valeurs hors des choix possibles: %s ")
- % (valeur, self.into)
- )
-
- def verifItem(self, valeur):
- if valeur not in self.into:
- return 0
- return 1
-
- def hasInto(self):
- return 1
-
- def getInto(self, liste_courante=None, into_courant=None):
- if into_courant is None:
- liste_choix = list(self.into)
- else:
- liste_choix = []
- for e in into_courant:
- if e in self.into:
- liste_choix.append(e)
- return liste_choix
-
- def infoErreurItem(self):
- return tr("La valeur n'est pas dans la liste des choix possibles")
-
-
-def ImpairVal(valeur):
- """
- Exemple de validateur
- Cette fonction est un validateur. Elle verifie que la valeur passee
- est bien un nombre impair.
- """
- if isSequence(valeur):
- for val in valeur:
- if val % 2 != 1:
- return 0
- return 1
- else:
- if valeur % 2 != 1:
- return 0
- return 1
-
-
-ImpairVal.info = "valeur impaire"
-
-
-class F1Val(Valid):
-
- """
- Exemple de validateur
- Cette classe est un validateur de dictionnaire (mot cle facteur ?). Elle verifie
- que la somme des cles A et B vaut une valeur donnee
- en parametre du validateur
- """
-
- def __init__(self, somme=10):
- self.somme = somme
- self.cata_info = ""
-
- def info(self):
- return tr("valeur %s pour la somme des cles A et B ") % self.somme
-
- def verif(self, valeur):
- if isSequence(valeur):
- for val in valeur:
- if not "A" in val:
- return 0
- if not "B" in val:
- return 0
- if val["A"] + val["B"] != self.somme:
- return 0
- return 1
- else:
- if not "A" in valeur:
- return 0
- if not "B" in valeur:
- return 0
- if valeur["A"] + valeur["B"] != self.somme:
- return 0
- return 1
-
-
-class FunctionVal(Valid):
-
- """
- Exemple de validateur
- Cette classe est un validateur qui est initialise avec une fonction
- """
-
- def __init__(self, function):
- self.function = function
-
- def info(self):
- return self.function.info
-
- def infoErreurItem(self):
- return self.function.info
-
- def verif(self, valeur):
- return self.function(valeur)
-
- def verifItem(self, valeur):
- return self.function(valeur)
-
- def convert(self, valeur):
- return valeur
-
-
-# MC ca ne devrait plus servir !
-# PN : commenter le 22.11.19
-# CoercableFuncs = {int: int,
-# int: int,
-# float: float,
-# complex: complex,
-# str: six.text_type}
-
-
-class TypeVal(ListVal):
-
- """
- Exemple de validateur
- Cette classe est un validateur qui controle qu'une valeur
- est bien du type Python attendu.
- Pour une liste on verifie que tous les elements sont du bon type.
- Semblable a InstanceVal mais ici on fait le test par tentative de conversion
- alors qu'avec InstanceVal on ne teste que si isinstance est vrai.
- """
-
- def __init__(self, aType):
- # Si aType n'est pas un type, on le retrouve a l'aide de la fonction type
- # type(1) == int;type(0.2)==float;etc.
- if type(aType) != type:
- aType = type(aType)
- self.aType = aType
- try:
- self.coerce = CoercableFuncs[aType]
- except:
- self.coerce = self.identity
-
- def info(self):
- return tr("valeur de %s") % self.aType
-
- def identity(self, value):
- if type(value) == self.aType:
- return value
- raise ValError
-
- def convertItem(self, valeur):
- return self.coerce(valeur)
-
- def verifItem(self, valeur):
- try:
- self.coerce(valeur)
- except:
- return 0
- return 1
-
-
-class InstanceVal(ListVal):
-
- """
- Exemple de validateur
- Cette classe est un validateur qui controle qu'une valeur est
- bien une instance (au sens Python) d'une classe
- Pour une liste on verifie chaque element de la liste
- """
-
- def __init__(self, aClass):
- # Si aClass est une classe on la memorise dans self.aClass
- # sinon c'est une instance dont on memorise la classe
- # if type(aClass) == types.InstanceType:
- if type(aClass) == object:
- # instance ancienne mode
- aClass = aClass.__class__
- elif type(aClass) == type:
- # classe ancienne mode
- aClass = aClass
- elif type(aClass) == type:
- # classe nouvelle mode
- aClass = aClass
- elif isinstance(aClass, object):
- # instance nouvelle mode
- aClass = type(aClass)
- else:
- raise ValError(tr("type non supporté"))
-
- self.aClass = aClass
-
- def info(self):
- return tr("valeur d'instance de %s") % self.aClass.__name__
-
- def verifItem(self, valeur):
- if not isinstance(valeur, self.aClass):
- return 0
- return 1
-
-
-class VerifTypeTuple(ListVal):
- def __init__(self, typeDesTuples):
- self.typeDesTuples = typeDesTuples
- Valid.__init__(self)
- self.cata_info = ""
-
- def info(self):
- return tr(": verifie les \ntypes dans un tuple")
-
- def infoErreurListe(self):
- return tr("Les types entres ne sont pas permis")
-
- def default(self, valeur):
- return valeur
-
- def isList(self):
- return 1
-
- def convertItem(self, valeur):
- if len(valeur) != len(self.typeDesTuples):
- raise ValError(
- tr("%s devrait etre de type %s ") % (valeur, self.typeDesTuples)
- )
- for i in range(len(valeur)):
- ok = self.verifType(valeur[i], self.typeDesTuples[i])
- if ok != 1:
- raise ValError(
- tr("%s devrait etre de type %s ") % (valeur, self.typeDesTuples)
- )
- return valeur
-
- def verifItem(self, valeur):
- try:
- if len(valeur) != len(self.typeDesTuples):
- return 0
- for i in range(len(valeur)):
- ok = self.verifType(valeur[i], self.typeDesTuples[i])
- if ok != 1:
- return 0
- except:
- return 0
- return 1
-
- def verifType(self, valeur, type_permis):
- if type_permis == "R":
- if type(valeur) in (int, float, int):
- return 1
- elif type_permis == "I":
- if type(valeur) in (int, int):
- return 1
- elif type_permis == "C":
- if self.isComplexe(valeur):
- return 1
- elif type_permis == "TXM":
- if type(valeur) == bytes or type(valeur) == str:
- return 1
- elif isinstance(valeur, type_permis):
- return 1
- return 0
-
- def verif(self, valeur):
- if type(valeur) in (list, tuple):
- liste = list(valeur)
- for val in liste:
- if self.verifItem(val) != 1:
- return 0
- return 1
-
-
-class VerifExiste(ListVal):
-
- """
- fonctionne avec into
- Met une liste à jour selon les mot clefs existant
- exemple si into = ("A","B","C")
- si au niveau N du JDC les objets "A" et "C" existe
- alors la liste des into deviendra ( "A","C")
-
- niveauVerif est le niveau du JDC dans lequel va s effectuer la verification
- niveauVerif est defini par rapport au Noeud :
- exemple niveauVerif = 1 : on verifie les freres
- niveauVerif = 2 : on verifie les oncles..
- """
-
- def __init__(self, niveauVerif):
- ListVal.__init__(self)
- self.niveauVerif = niveauVerif
- self.MCSimp = None
- self.listeDesFreres = ()
- self.fonctions = ("verifieListe", "set_MCSimp")
-
- def isList(self):
- return 1
-
- def verifieListe(self, liste):
- self.set_MCSimp(self.MCSimp)
- for item in liste:
- if not (item in self.listeDesFreres):
- return 0
- return 1
-
- def verifItem(self, valeur):
- self.set_MCSimp(self.MCSimp)
- if valeur in self.listeDesFreres:
- return 1
- return 0
-
- def set_MCSimp(self, MCSimp):
- self.MCSimp = MCSimp
- k = self.niveauVerif
- mc = MCSimp
- while k != 0:
- parent = mc.parent
- mc = parent
- k = k - 1
- # on met la liste à jour
- parent.forceRecalcul = self.niveauVerif
- self.listeDesFreres = parent.listeMcPresents()
-
- def convertItem(self, valeur):
- if valeur in self.listeDesFreres:
- return valeur
- raise ValError(tr("%s n'est pas dans %s") % (valeur, self.listeDesFreres))
-
-
-class RegExpVal(ListVal):
-
- """
- Vérifie qu'une chaîne de caractère corresponde à l'expression régulière 'pattern'
- """
-
- errormsg = 'La chaîne "%(value)s" ne correspond pas au motif "%(pattern)s"'
-
- def __init__(self, pattern):
- self.pattern = pattern
- self.compiled_regexp = re.compile(pattern)
-
- def info(self):
- return (
- tr("Une chaîne correspondant au motif ")
- + str(self.pattern)
- + tr(" est attendue")
- )
-
- def infoErreurItem(self):
- return (
- tr("Une chaîne correspondant au motif ")
- + str(self.pattern)
- + tr(" est attendue")
- )
-
- def verifItem(self, valeur):
- if self.compiled_regexp.match(valeur):
- return 1
- else:
- return (0, self.errormsg % {"value": valeur, "pattern": self.pattern})
-
- def convertItem(self, valeur):
- if self.compiled_regexp.match(valeur):
- return valeur
- else:
- raise ValError(self.errormsg % {"value": valeur, "pattern": self.pattern})
-
-
-class FileExtVal(RegExpVal):
-
- """
- Vérifie qu'une chaîne de caractère soit un nom de fichier valide avec l'extension 'ext'
- """
-
- def __init__(self, ext):
- self.ext = ext
- self.errormsg = '"%%(value)s" n\'est pas un nom de fichier %(ext)s valide' % {
- "ext": ext
- }
- # PNPN Modif pour Adao
- RegExpVal.__init__(self, "^\S+\.%s$" % self.ext)
-
- def info(self):
- return 'Un nom de fichier se terminant par ".%s" est attendu.' % self.ext
-
- def infoErreurItem(self):
- return 'Un nom de fichier se terminant par ".%s" est attendu.' % self.ext
-
-
-class CreeMotClef(object):
- def __init__(self, MotClef):
- self.MotClef = MotClef
- self.MCSimp = None
-
- def convert(self, lval):
- try:
- valeur = lval[0]
- except:
- return lval
-
- parent = self.MCSimp.parent
- if hasattr(parent, "inhibeValidator") and parent.inhibeValidator:
- return lval
-
- if parent.getChild(self.MotClef) == None:
- longueur = 0
- else:
- longueur = len(parent.getChild(self.MotClef))
-
- pos = parent.getIndexChild(self.MCSimp.nom) + 1
- while longueur < valeur:
- parent.inhibeValidator = 1
- parent.addEntite(self.MotClef, pos)
- pos = pos + 1
- parent.inhibeValidator = 0
- longueur = len(parent.getChild(self.MotClef))
-
- if longueur > valeur:
- parent.inhibeValide = 1
- parentObj = parent.getChild(self.MotClef)
- obj = parent.getChild(self.MotClef)[-1]
- parentObj.suppEntite(obj)
- longueur = len(parent.getChild(self.MotClef))
- parent.inhibeValide = 0
- return lval
-
- def info(self):
- return "Cree le bon nombre de Mot %s" % self.MotClef
-
- def verifItem(self, valeur):
- return 1
-
- def set_MCSimp(self, MCSimp):
- # print "dans set_MCSimp"
- self.MCSimp = MCSimp
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-from collections import UserDict
-
-
-class _F(UserDict):
-
- """
- Cette classe a un comportement semblable à un
- dictionnaire Python et permet de donner
- la valeur d'un mot-clé facteur avec pour les sous
- mots-clés la syntaxe motcle=valeur
- """
-
- def __init__(self, *pos, **args):
- if len(pos) != 0:
- raise SyntaxError(
- "Valeur invalide pour '_F('. "
- "On attend cette syntaxe : _F(MOTCLE=valeur, ...)"
- )
- self.data = args
-
- def supprime(self):
- self.data = {}
-
- def __cmp__(self, dict):
- print("je passe ici ________________________ Attention cmp deprecated")
- from past.builtins import cmp
-
- if type(dict) == type(self.data):
- return cmp(self.data, dict)
- elif hasattr(dict, "data"):
- return cmp(self.data, dict.data)
- else:
- return cmp(self.data, dict)
-
- def __iter__(self):
- return iter(self.data)
-
- def copy(self):
- import copy
-
- c = copy.copy(self)
- c.data = self.data.copy()
- return c
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-"""
- Ce module contient des fonctions utilitaires pour tester les types
-"""
-
-# use isinstance() instead of type() because objects returned from numpy arrays
-# inherit from python scalars but are numpy.float64 or numpy.int32...
-
-
-def isInt(obj):
- return isinstance(obj, int) or type(obj) is int
-
-
-def isFloat(obj):
- return isinstance(obj, float)
-
-
-def isComplex(obj):
- return isinstance(obj, complex)
-
-
-from decimal import Decimal
-
-
-def isFloat_or_int(obj):
- return isFloat(obj) or isInt(obj) or isinstance(obj, Decimal)
-
-
-def isNumber(obj):
- return isFloat_or_int(obj) or isComplex(obj)
-
-
-def isStr(obj):
- import six
-
- return isinstance(obj, (str, six.text_type))
-
-
-def isList(obj):
- return type(obj) is list
-
-
-def isTuple(obj):
- return type(obj) is tuple
-
-
-def isArray(obj):
- """a numpy array ?"""
- import numpy as NP
- _np_arr = NP.ndarray
- return type(obj) is _np_arr
-
-
-def isSequence(obj):
- """a sequence (allow iteration, not a string) ?"""
- return isList(obj) or isTuple(obj) or isArray(obj)
-
-
-def isASSD(obj):
- from .N_ASSD import ASSD
-
- return isinstance(obj, ASSD)
-
-
-def forceList(obj):
- """Retourne `obj` si c'est une liste ou un tuple,
- sinon retourne [obj,] (en tant que list).
- """
- if not isSequence(obj):
- obj = [
- obj,
- ]
- return list(obj)
-
-
-def forceTuple(obj):
- """Return `obj` as a tuple."""
- return tuple(forceList(obj))
-
-
-# backward compatibility
-from warnings import warn
-
-
-def isEnum(obj):
- """same as isSequence"""
- warn("'isEnum' is deprecated, use 'isSequence'", DeprecationWarning, stacklevel=2)
- return isSequence(obj)
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module contient des fonctions utilitaires
-"""
-
-# Modules Python
-
-
-from builtins import str
-from builtins import object
-import sys
-
-# Modules EFICAS
-from .N_Exception import AsException
-from .N_types import isInt, isFloat, isComplex, isStr, isSequence, isASSD
-from .strfunc import getEncoding
-
-SEP = "_"
-
-try:
- cur_frame = sys._getframe
-except:
- print("pb avec la version de python pour cur_frame = sys._getframe")
-
-
-def calleeWhere(niveau=4):
- """
- recupere la position de l appel
- """
- frame = sys._getframe(niveau)
- if frame == None:
- return 0, "inconnu", 0, {}
- try:
- # Python 2.7 compile function does not accept unicode filename, so we encode it
- # with the current locale encoding in order to have a correct traceback.
- # Here, we convert it back to unicode.
- import six
-
- filename = six.text_type(frame.f_code.co_filename, getEncoding())
- return frame.fLineNo, filename, frame.f_code.co_firstlineno, frame.f_locals
- except:
- return 0, "inconnu", 0, {}
-
-
-def AsType(a):
- """
- Retourne le type d'un concept (a) à partir
- des caractéristiques de l'objet Python
- """
- if isSequence(a):
- return AsType(a[0])
- if isASSD(a):
- return type(a)
- if isFloat(a):
- return "R"
- if isInt(a):
- return "I"
- if isStr(a):
- return "TXM"
- if a == None:
- return None
- raise AsException("type inconnu: %r %s" % (a, type(a)))
-
-
-def prbanner(s):
- print(("*" * (len(s) + 10)))
- print(("*" * 5 + s + "*" * 5))
- print(("*" * (len(s) + 10)))
-
-
-def repr_float(valeur):
- """
- Cette fonction représente le réel valeur comme une chaine de caractères
- sous forme mantisse exposant si nécessaire cad si le nombre contient plus de
- 5 caractères
- NB : valeur est un réel au format Python ou une chaine de caractères représentant un réel
- """
- if type(valeur) == str:
- valeur = eval(valeur)
- if valeur == 0.0:
- return "0.0"
- if abs(valeur) > 1.0:
- if abs(valeur) < 10000.0:
- return repr(valeur)
- else:
- if abs(valeur) > 0.01:
- return repr(valeur)
- t = repr(valeur)
- if t.find("e") != -1 or t.find("E") != -1:
- # le réel est déjà sous forme mantisse exposant !
- # --> on remplace e par E
- t = t.replace("e", "E")
- # --> on doit encore vérifier que la mantisse contient bien un '.'
- if t.find(".") != -1:
- return t
- else:
- # -->il faut rajouter le point avant le E
- t = t.replace("E", ".E")
- return t
- s = ""
- neg = 0
- if t[0] == "-":
- s = s + t[0]
- t = t[1:]
- cpt = 0
- if t[0].atof() == 0.0:
- # réel plus petit que 1
- neg = 1
- t = t[2:]
- cpt = 1
- while t[0].atof() == 0.0:
- cpt = cpt + 1
- t = t[1:]
- s = s + t[0] + "."
- for c in t[1:]:
- s = s + c
- else:
- # réel plus grand que 1
- s = s + t[0] + "."
- if t[1:].atof() == 0.0:
- l = t[1:].split(".")
- cpt = len(l[0])
- else:
- r = 0
- pt = 0
- for c in t[1:]:
- r = r + 1
- if c != ".":
- if pt != 1:
- cpt = cpt + 1
- s = s + c
- else:
- pt = 1
- if r + 1 == len(t) or t[r + 1 :].atof() == 0.0:
- break
- s = s + "E" + neg * "-" + repr(cpt)
- return s
-
-
-def importObject(uri):
- """Load and return a python object (class, function...).
- Its `uri` looks like "mainpkg.subpkg.module.object", this means
- that "mainpkg.subpkg.module" is imported and "object" is
- the object to return.
- """
- path = uri.split(".")
- modname = ".".join(path[:-1])
- if len(modname) == 0:
- raise ImportError("invalid uri: %s" % uri)
- mod = object = "?"
- objname = path[-1]
- try:
- __import__(modname)
- mod = sys.modules[modname]
- except ImportError as err:
- raise ImportError("can not import module : %s (%s)" % (modname, str(err)))
- try:
- object = getattr(mod, objname)
- except AttributeError as err:
- raise AttributeError(
- "object (%s) not found in module '%s'. "
- "Module content is: %s" % (objname, modname, tuple(dir(mod)))
- )
- return object
-
-
-class Singleton(object):
-
- """Singleton implementation in python."""
-
- # add _singleton_id attribute to the class to be independant of import
- # path used
- __inst = {}
-
- def __new__(cls, *args, **kargs):
- cls_id = getattr(cls, "_singleton_id", cls)
- if Singleton.__inst.get(cls_id) is None:
- Singleton.__inst[cls_id] = object.__new__(cls)
- return Singleton.__inst[cls_id]
-
-
-class Enum(object):
-
- """
- This class emulates a C-like enum for python. It is initialized with a list
- of strings to be used as the enum symbolic keys. The enum values are automatically
- generated as sequencing integer starting at 0.
- """
-
- def __init__(self, *keys):
- """Constructor"""
- self._dict_keys = {}
- for inum, key in enumerate(keys):
- setattr(self, key, 2**inum)
- self._dict_keys[2**inum] = key
-
- def exists(self, value):
- """Tell if value is in the enumeration"""
- return self.getId(value) is not None
-
- def getId(self, value):
- """Return the key associated to the given value"""
- return self._dict_keys.get(value, None)
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-"""
- Ce package fournit les classes de base d'EFICAS.
- Ces classes permettent d'effectuer quelques operations basiques :
-
- - la creation
- - la verification des definitions
- - la creation d'objets de type OBJECT a partir d'une definition de type ENTITE
-"""
-# Avant toutes choses, on met le module context dans le global de l'interpreteur (__builtin__)
-# sous le nom CONTEXT afin d'avoir acces aux fonctions
-# getCurrentStep, setCurrentStep et unsetCurrentStep de n'importe ou
-
-
-from . import context
-
-import builtins
-
-builtins.CONTEXT = context
-
-# Only the first MAXSIZE objects will be checked
-# This is used for the number of MCFACT, the number of MCSIMP and the number of
-# values in a MCSIMP.
-
-MAXSIZE = 500
-MAXSIZE_MSGCHK = " <I> Only the first {0} occurrences (total: {1}) have been checked."
-MAXSIZE_MSGKEEP = " <I> Only the first {0} occurrences (total: {1}) have been printed."
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-_root = None
-_cata = None
-_jdc = None
-debug = 0
-
-# Le "current step" est l'etape courante.
-# Une macro se declare etape courante dans sa methode Build avant de construire
-# ses etapes filles ou dans BuildExec avant de les executer.
-# Les etapes simples le font aussi : dans Execute et BuildExec.
-# (Build ne fait rien pour une etape)
-
-
-def setCurrentStep(step):
- """
- Fonction qui permet de changer la valeur de l'etape courante
- """
- global _root
- if _root:
- raise Exception("Impossible d'affecter _root. Il devrait valoir None")
- _root = step
-
-
-def getCurrentStep():
- """
- Fonction qui permet d'obtenir la valeur de l'etape courante
- """
- return _root
-
-
-def unsetCurrentStep():
- """
- Fonction qui permet de remettre a None l'etape courante
- """
- global _root
- _root = None
-
-
-def setCurrentCata(cata):
- """
- Fonction qui permet de changer l'objet catalogue courant
- """
- global _cata
- if _cata:
- raise Exception("Impossible d'affecter _cata. Il devrait valoir None")
- _cata = cata
-
-
-def getCurrentCata():
- """
- Fonction qui retourne l'objet catalogue courant
- """
- return _cata
-
-
-def unsetCurrentCata():
- """
- Fonction qui permet de remettre a None le catalogue courant
- """
- global _cata
- _cata = None
-
-
-def getCurrentJdC():
- """
- Fonction qui retourne l'objet JDC courant
- """
- return _jdc
-
-
-def setCurrentJdC(jdc):
- """
- Fonction qui permet de changer l'objet JDC courant
- """
- global _jdc
- if _jdc:
- raise Exception("Impossible d'affecter _jdc. Il devrait valoir None")
- _jdc = jdc
-
-
-def unsetCurrentJdC():
- """
- Fonction qui permet de remettre a None le JDC courant
- """
- global _jdc
- _jdc = None
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-
-"""
- Ce module sert à nommer les concepts produits par les commandes.
- Le nom du concept est obtenu en appelant la fonction getNomConceptResultat
- du module avec le nom de la commande en argument.
-
- Cette fonction parcourt le source dans lequel la commande se trouve, parse le
- fichier et retrouve le nom du concept qui se trouve à gauche du signe = précédant
- le nom de la commande.
-
- Cette fonction utilise la fonction cur_frame du module N_utils qui retourne la frame
- d'exécution Python située 2 niveaux au-dessus. C'est à partir de cette frame que
- l'on retrouve le fichier source et le numéro de ligne où se trouve l'appel à la commande.
-
-"""
-
-# Modules Python
-from builtins import str
-import re
-import linecache
-import sys
-from functools import partial
-
-# Modules EFICAS
-from . import N_utils
-from .strfunc import getEncoding
-
-regex1 = "=?\s*%s\s*\("
-# commentaire standard precede d'un nombre quelconque de blancs (pas
-# multiligne)
-pattern_comment = re.compile(r"^\s*#.*")
-
-
-def _getNomConceptResultat(ope, level=2):
- """
- Cette fonction recherche dans la pile des appels, l'appel à la commande
- qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)).
- On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne
- dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename).
- A partir de là, on récupère la ligne de source avec linecache.getline
- et on vérifie que cette ligne correspond véritablement à l'appel.
-
- En effet, lorsque les commandes tiennent sur plusieurs lignes, on retrouve
- la dernière ligne. Il faut donc remonter dans le source jusqu'à la première
- ligne.
-
- Enfin la fonction evalnom forme un nom acceptable lorsque le concept est un
- élément d'une liste, par exemple.
-
- """
- f = N_utils.cur_frame(level)
- lineno = f.f_lineno # XXX Too bad if -O is used
- # lineno = f_lineno(f) # Ne marche pas toujours
- co = f.f_code
- if sys.version_info >= (3, 0):
- filename = co.co_filename
- else:
- import six
-
- filename = six.text_type(co.co_filename, getEncoding())
- name = co.co_name
- # pattern pour identifier le debut de la commande
- pattern_oper = re.compile(regex1 % ope)
-
- list = []
- while lineno > 0:
- line = linecache.getline(filename, lineno)
- lineno = lineno - 1
- if pattern_comment.match(line):
- continue
- list.append(line)
- if pattern_oper.search(line):
- l = pattern_oper.split(line)
- list.reverse()
- # On suppose que le concept resultat a bien ete
- # isole en tete de la ligne de source
- m = evalnom(l[0].strip(), f.f_locals)
- # print "NOMS ",m
- if m != []:
- return m[-1]
- else:
- return ""
- # print "appel inconnu"
- return ""
-
-
-def evalnom(text, d):
- """
- Retourne un nom pour le concept resultat identifie par text
- Pour obtenir ce nom il y a plusieurs possibilites :
- 1. text est un identificateur python c'est le nom du concept
- 2. text est un element d'une liste on construit le nom en
- evaluant la partie indice dans le contexte de l'appelant d
- """
- l = re.split("([\[\]]+)", text)
- if l[-1] == "":
- l = l[:-1]
- lll = []
- i = 0
- while i < len(l):
- s = l[i]
- ll = re.split("[ ,]+", s)
- if ll[0] == "":
- ll = ll[1:]
- if len(ll) == 1:
- id0 = ll[0]
- else:
- lll = lll + ll[0:-1]
- id0 = ll[-1]
- if i + 1 < len(l) and l[i + 1] == "[": # le nom est suivi d un subscript
- sub = l[i + 2]
- nom = id0 + "_" + str(eval(sub, d))
- i = i + 4
- else:
- nom = id0
- i = i + 1
- lll.append(nom)
- return lll
-
-
-def f_lineno(f):
- """
- Calcule le numero de ligne courant
- Devrait marcher meme avec -O
- Semble ne pas marcher en présence de tuples longs
- """
- c = f.f_code
- if not hasattr(c, "co_lnotab"):
- return f.f_lineno
- tab = c.co_lnotab
- line = c.co_firstlineno
- stopat = f.f_lasti
- addr = 0
- for i in range(0, len(tab), 2):
- addr = addr + ord(tab[i])
- if addr > stopat:
- break
- line = line + ord(tab[i + 1])
- return line
-
-
-class NamingSystem(N_utils.Singleton):
-
- """Cette classe définit un système de nommage dynamique des concepts."""
-
- _singleton_id = "nommage.NamingSystem"
-
- def __init__(self):
- """Initialisation"""
- self.native = _getNomConceptResultat
- self.useGlobalNaming()
-
- def useNamingFunction(self, function):
- """Utilise une fonction particulière de nommage."""
- self.naming_func = function
-
- def useGlobalNaming(self):
- """Utilise la fonction native de nommage."""
- self.naming_func = partial(self.native, level=3)
-
- def __call__(self, *args):
- """Appel à la fonction de nommage."""
- return self.naming_func(*args)
-
-
-getNomConceptResultat = NamingSystem()
+++ /dev/null
-# coding=utf-8
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
-"""Module rassemblant des fonctions utilitaires de manipulations
-de chaines de caractères
-"""
-# module identique à Execution/strfunc.py pour usage dans Eficas
-
-
-try:
- from builtins import str
-except:
- pass
-
-import locale
-import six
-
-_encoding = None
-
-
-def getEncoding():
- """Return local encoding"""
- global _encoding
- if _encoding is None:
- try:
- _encoding = locale.getpreferredencoding() or "ascii"
- except locale.Error:
- _encoding = "ascii"
- return _encoding
-
-
-def toUnicode(string):
- """Try to convert string into a unicode string."""
- if type(string) is six.text_type:
- return string
- elif type(string) is dict:
- new = {}
- for k, v in list(string.items()):
- new[k] = toUnicode(v)
- return new
- elif type(string) is list:
- return [toUnicode(elt) for elt in string]
- elif type(string) is tuple:
- return tuple(toUnicode(list(string)))
- elif type(string) is not str:
- return string
- assert type(string) is str, "unsupported object: %s" % string
- for encoding in ("utf-8", "iso-8859-15", "cp1252"):
- try:
- s = six.text_type(string, encoding)
- return s
- except UnicodeDecodeError:
- pass
- return six.text_type(string, "utf-8", "replace")
from cata import *
from math import ceil
-from Extensions import param2
+from Accas.extensions import param2
pi=param2.Variable('pi',pi)
"BETON_BURGER_FP",
"BETON_DOUBLE_DP",
"BETON_RAG",
- "BETON_REGLE_PR",
+ "BETOP_REGLE_PR",
"BETON_UMLV_FP",
"CABLE_GAINE_FROT",
"CAM_CLAY",
"VMIS_ISOT_LINE",
"VMIS_ISOT_PUIS",
"VMIS_ISOT_TRAC",
- "VMIS_JOHN_COOK",
+ "VMIS_JOHP_COOK",
"ZMAT",
"UMAT",
"MFRONT",
# ----------------------------------------------------------------------------------------------------------------------------------
- _BlocMU['GESTION_MEMOIRE'] = SIMP(statut='f', typ='TXM', defaut="AUTO", into=("IN_CORE", "OUT_OF_CORE", "AUTO", "EVAL"), )
+ _BlocMU['GESTION_MEMOIRE'] = SIMP(statut='f', typ='TXM', defaut="AUTO", into=("IP_CORE", "OUT_OF_CORE", "AUTO", "EVAL"), )
# ----------------------------------------------------------------------------------------------------------------------------------
'VECT_ASSE',
'FORCE_NODALE','FORCE_FACE','FORCE_ARETE','FORCE_CONTOUR','FORCE_INTERNE',
'PRE_SIGM','PRES_REP','EFFE_FOND','PRE_EPSI','FORCE_POUTRE','FORCE_TUYAU',
- 'FORCE_COQUE','LIAISON_COQUE','RELA_CINE_BP','FORCE_ELEC','INTE_ELEC',
+ 'FORCE_COQUE','LIAISOP_COQUE','RELA_CINE_BP','FORCE_ELEC','INTE_ELEC',
'IMPE_FACE','VITE_FACE','ONDE_FLUI','FLUX_THM_REP','FORCE_SOL',),
),
VERI_NORM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
PLAN =SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL",) ),
),
- LIAISON_COQUE =FACT(statut='f',max='**',
+ LIAISOP_COQUE =FACT(statut='f',max='**',
fr="Permet de représenter le raccord entre des éléments de coques au moyen des relations linéaires",
regles=(AU_MOINS_UN('GROUP_MA_1','MAILLE_1','GROUP_MA_2','MAILLE_2',
'GROUP_NO_1','NOEUD_1','GROUP_NO_2','NOEUD_2',),),
'FORCE_FACE','FORCE_ARETE','FORCE_CONTOUR','FORCE_INTERNE',
'PRES_REP','FORCE_POUTRE','VITE_FACE','IMPE_FACE','ONDE_PLANE',
'LIAISON_OBLIQUE','PRE_EPSI','LIAISON_GROUP','LIAISON_UNIF',
- 'LIAISON_SOLIDE','FORCE_COQUE','LIAISON_COQUE','FORCE_TUYAU',
+ 'LIAISON_SOLIDE','FORCE_COQUE','LIAISOP_COQUE','FORCE_TUYAU',
'EFFE_FOND','FLUX_THM_REP',),),
VERI_NORM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
MODELE =SIMP(statut='o',typ=modele_sdaster),
into=("SUP","INF","MOY","MAIL") ),
),
- LIAISON_COQUE =FACT(statut='f',max='**',
+ LIAISOP_COQUE =FACT(statut='f',max='**',
fr="Permet de représenter le raccord entre des éléments de coques au moyen des relations linéaires",
regles=(AU_MOINS_UN('GROUP_MA_1','MAILLE_1','GROUP_MA_2','MAILLE_2',
'GROUP_NO_1','NOEUD_1','GROUP_NO_2','NOEUD_2',),),
),
),
DOMMAGE =SIMP(statut='o',typ='TXM',
- into=("WOHLER","MANSON_COFFIN","TAHERI_MANSON",
+ into=("WOHLER","MANSOP_COFFIN","TAHERI_MANSON",
"TAHERI_MIXTE",) ),
MATER =SIMP(statut='o',typ=(mater_sdaster) ),
TAHERI_NAPPE =SIMP(statut='f',typ=(nappe_sdaster,formule) ),
b_rectangle =BLOC(condition = "FORM_FISS == 'RECTANGLE' ",fr="Paramètres de la fissure/interface rectangulaire",
DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.),
DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.),
- RAYON_CONGE =SIMP(statut='f',typ='R',val_min=0.,defaut=0.),
+ RAYOP_CONGE =SIMP(statut='f',typ='R',val_min=0.,defaut=0.),
CENTRE =SIMP(statut='o',typ='R',min=3,max=3),
VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
VECT_Y =SIMP(statut='o',typ='R',min=3,max=3),
COTE_FISS =SIMP(statut='f',typ='TXM',defaut="IN",into=("IN","OUT",) ), ),
b_entaille =BLOC(condition = "FORM_FISS == 'ENTAILLE' ",fr="Paramètres de l'interface entaille",
DEMI_LONGUEUR =SIMP(statut='o',typ='R',val_min=0.),
- RAYON_CONGE =SIMP(statut='o',typ='R',val_min=0.),
+ RAYOP_CONGE =SIMP(statut='o',typ='R',val_min=0.),
CENTRE =SIMP(statut='o',typ='R',min=3,max=3),
VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), ),
SYT =SIMP(statut='o',typ='R'),
SYC =SIMP(statut='f',typ='R'),
),
- BETON_REGLE_PR =FACT(statut='f',
+ BETOP_REGLE_PR =FACT(statut='f',
D_SIGM_EPSI =SIMP(statut='o',typ='R'),
SYT =SIMP(statut='o',typ='R'),
SYC =SIMP(statut='f',typ='R'),
A2 =SIMP(statut='f',typ='R'),
A3 =SIMP(statut='f',typ='R'),
SL =SIMP(statut='f',typ='R'),
- MANSON_COFFIN =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+ MANSOP_COFFIN =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
E_REFE =SIMP(statut='f',typ='R'),
D0 =SIMP(statut='f',typ='R'),
TAU0 =SIMP(statut='f',typ='R'),
EPSP_SEUIL =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
EXP_S =SIMP(statut='f',typ='R',val_min=0.0E0,defaut=1.0),
),
- CISA_PLAN_CRIT =FACT(statut='f',
+ CISA_PLAP_CRIT =FACT(statut='f',
CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE_MODI_AC",
"DANG_VAN_MODI_AC",
"DANG_VAN_MODI_AV",
LOGICIEL =SIMP(statut='f',typ='TXM'),
# Corrige les problemes possibles de non-connexite des sous-domaines
- CORRECTION_CONNEX =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON')),
+ CORRECTIOP_CONNEX =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON')),
# Permet de grouper des mailles dans un meme sous-doamine
GROUPAGE =FACT(statut='f',max='**',
LOGICIEL =SIMP(statut='f',typ='TXM'),
# Corrige les problemes possibles de non-connexite des sous-domaines
- CORRECTION_CONNEX =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON')),
+ CORRECTIOP_CONNEX =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON')),
# Permet de grouper des mailles dans un meme sous-doamine
GROUPAGE =FACT(statut='f',max='**',
PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
ELIM_LAGR =SIMP(statut='f',typ='TXM',defaut="LAGR2",into=("LAGR2","NON")),
- GESTION_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="IN_CORE",into=("IN_CORE","OUT_OF_CORE","EVAL")),
+ GESTION_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="IP_CORE",into=("IP_CORE","OUT_OF_CORE","EVAL")),
# mots clés pour solveur GCPC et PETSc :
PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
MATR_MASS =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r,matr_asse_gene_r) ),
MATR_AMOR =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r,matr_asse_gene_r) ),
TYPE_CONTOUR =SIMP(statut='f',typ='TXM',defaut="CERCLE",into=("CERCLE","CERCLE") ),
- RAYON_CONTOUR =SIMP(statut='o',typ='R',val_min=1.E-2 ),
+ RAYOP_CONTOUR =SIMP(statut='o',typ='R',val_min=1.E-2 ),
CENTRE_CONTOUR =SIMP(statut='f',typ='C',defaut= 0.0+0.0j),
COMPTAGE =FACT(statut='d',
METHODE =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AUTO","APM")),
fr="Liste de charges critiques" ),
b_contour =BLOC(condition = "CHAR_CRIT == None",
TYPE_CONTOUR =SIMP(statut='f',typ='TXM',defaut="CERCLE",into=("CERCLE","CERCLE") ),
- RAYON_CONTOUR =SIMP(statut='o',typ='R',val_min=1.E-2 ),
+ RAYOP_CONTOUR =SIMP(statut='o',typ='R',val_min=1.E-2 ),
CENTRE_CONTOUR =SIMP(statut='f',typ='C',defaut= 0.0+0.0j),),
COMPTAGE =FACT(statut='d',
METHODE =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AUTO","STURM","APM")),
# person_in_charge: josselin.delmas at edf.fr
-MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",
+MACR_LIGP_COUPE=MACRO(nom="MACR_LIGP_COUPE",
op=OPS('Macro.macr_lign_coupe_ops.macr_lign_coupe_ops'),
sd_prod=table_sdaster,
reentrant='n',
GROUP_MA_1 =SIMP(statut='f',typ=grma),
MAILLE_1 =SIMP(statut='f',typ=ma,max='**'),),
- LIGN_COUPE =FACT(statut='o',max='**',
+ LIGP_COUPE =FACT(statut='o',max='**',
regles=(EXCLUS("NOM_CMP","INVARIANT","ELEM_PRINCIPAUX","RESULTANTE"),
PRESENT_PRESENT("TRAC_DIR","DIRECTION"),
EXCLUS("TRAC_DIR","TRAC_NOR"),
COEF_MULT = FACT(statut='f',
KT = SIMP(statut='o',typ='R'),),
CORR_KE = SIMP(statut='f',typ='TXM',into=("RCCM",)),
- DOMMAGE = SIMP(statut='f',typ='TXM',into=("WOHLER","MANSON_COFFIN",
+ DOMMAGE = SIMP(statut='f',typ='TXM',into=("WOHLER","MANSOP_COFFIN",
"TAHERI_MANSON","TAHERI_MIXTE")),
MATER = SIMP(statut='f',typ=mater_sdaster),
CORR_SIGM_MOYE = SIMP(statut='f',typ='TXM',into=("GOODMAN","GERBER")),
# Modules Eficas
import Accas
from Accas import ASSD
-from Noyau.ascheckers import CheckLog
-from Noyau.N_info import message, SUPERV
-from Noyau.N_types import force_list
+from Accas.processing.ascheckers import CheckLog
+from Accas.processing.P_info import message, SUPERV
+from Accas.processing.P_types import force_list
try:
import aster
else:
UTMESS('I', 'SUPERVIS_70', valk=newsign, vali=self.jdc.jeveux_sysaddr)
from Cata.cata import entier
- from Noyau.N_CO import CO
+ from Accas.processing.P_CO import CO
interrupt = []
count = 0
UTMESS('I', 'SUPERVIS_65')
import types
version="$Name: V7_main $"[7:-2] or 'Test1_4'
-# ==========Path du noyau local ====================
+# ==========Path du processing local ====================
path_Noyau=".."
# ============================================================
nom_distrib="Eficas"+version+"AsterSTA8"
copyfiles('../Editeur',os.path.join(path_distrib,'Editeur'),['*.py','faqs.txt'])
copyfiles('../Traducteur',os.path.join(path_distrib,'Traducteur'),['*.py'])
copyfiles('../Ihm',os.path.join(path_distrib,'Ihm'),['*.py'])
- copyfiles('../Extensions',os.path.join(path_distrib,'Extensions'),['*.py'])
+ copyfiles('../extensions',os.path.join(path_distrib,'extensions'),['*.py'])
copyfiles('../Misc',os.path.join(path_distrib,'Misc'),['*.py'])
copyfiles('../Accas',os.path.join(path_distrib,'Accas'),['*.py'])
# Packages globaux (pour toutes les versions sauf surcharge)
import types
version="$Name: V7_main $"[7:-2] or 'Test1_4'
-# ==========Path du noyau fourni par Aster====================
+# ==========Path du processing fourni par Aster====================
path_Noyau="../../AccasAster"
# ============================================================
nom_distrib="Eficas"+version
copyfiles('../UiQT4',os.path.join(path_distrib,'UiQT4'),['*.ui','makefile'])
copyfiles('../Traducteur',os.path.join(path_distrib,'Traducteur'),['*.py'])
copyfiles('../Ihm',os.path.join(path_distrib,'Ihm'),['*.py'])
- copyfiles('../Extensions',os.path.join(path_distrib,'Extensions'),['*.py'])
+ copyfiles('../extensions',os.path.join(path_distrib,'extensions'),['*.py'])
copyfiles('../Misc',os.path.join(path_distrib,'Misc'),['*.py'])
copyfiles('../Accas',os.path.join(path_distrib,'Accas'),['*.py'])
# AIDE
#print 'DEBUG listeGroup manuel' # Il faut aussi commenter la ligne Msg,listeGroup=self.ChercheGrpMailleInSalome() dans la routine ChercheGrpMaille de qtEficas.py
#listeGroup = ['DIEL_air', 'COND_plaque', 'CURRENT_bobine' ] # cas-test plaque Rodger avec DIEL_
#listeGroup = ['NOCOND_air', 'COND_plaque', 'CURRENT_bobine' ] # cas-test plaque Rodger
- #listeGroup = ['DIEL_air', 'COND_plaque', 'NOCOND_noyau', 'CURRENT_bobine_1', 'CURRENT_bobine_2', 'CURRENT_bobine_3' ]
- #listeGroup = ['DIEL_air', 'COND_plaque', 'NOCOND_noyau', 'CURRENT_bobine' ]
- #listeGroup = ['BBK_bobine', 'DIEL_air', 'COND_plaque', 'NOCOND_noyau', 'CURRENT_bobine' ] # avec BBK
+ #listeGroup = ['DIEL_air', 'COND_plaque', 'NOCOND_processing', 'CURRENT_bobine_1', 'CURRENT_bobine_2', 'CURRENT_bobine_3' ]
+ #listeGroup = ['DIEL_air', 'COND_plaque', 'NOCOND_processing', 'CURRENT_bobine' ]
+ #listeGroup = ['BBK_bobine', 'DIEL_air', 'COND_plaque', 'NOCOND_processing', 'CURRENT_bobine' ] # avec BBK
#listeGroup = ['EPORT+_dom', 'EPORT-_dom', 'H', 'COND_cyl', 'EPORT_dom'] # cas-test CSS_Tempimpo
#listeGroup= ['BBK_spire', 'CURRENT_spire_4', 'NOCOND_air', 'CURRENT_spire_3', 'CURRENT_spire_1', 'CURRENT_spire_2'] # cas-test spire_dans l'air en 4 morceaux
#listeGroup= ['BBK_bobine', 'CURRENT_ind_2', 'DIEL_air', 'CURRENT_ind_8', 'CURRENT_ind_6', 'CURRENT_ind_1', 'CURRENT_ind_3', 'CURRENT_ind_7', 'CURRENT_ind_5', 'CURRENT_ind_4', 'BBK_topo', 'COND_plaque', 'TOPO_trou_1', 'TOPO_trou_3', 'TOPO_trou_2', 'TOPO_trou_8', 'TOPO_trou_4', 'TOPO_trou_7', 'TOPO_trou_5', 'TOPO_trou_6'] # cas-test T.E.A.M. Workshop 7
KernelSmoothingDrawingFilename = SIMP ( statut = "o",
typ = "TXM",
max = 1,
- fr = "Nom du fichier graphique de la reconstruction a noyau",
+ fr = "Nom du fichier graphique de la reconstruction a processing",
ang = "Kernel Smoothing Drawing Filename",
),
KernelSmoothingDrawingFilename = SIMP ( statut = "o",
typ = "TXM",
max = 1,
- fr = "Nom du fichier graphique de la reconstruction a noyau",
+ fr = "Nom du fichier graphique de la reconstruction a processing",
ang = "Kernel Smoothing Drawing Filename",
),
KernelSmoothingDrawingFilename = SIMP ( statut = "o",
typ = "TXM",
max = 1,
- fr = "Nom du fichier graphique de la reconstruction a noyau",
+ fr = "Nom du fichier graphique de la reconstruction a processing",
ang = "Kernel Smoothing Drawing Filename",
),
KernelSmoothingDrawingFilename = SIMP ( statut = "o",
typ = "TXM",
max = 1,
- fr = "Nom du fichier graphique de la reconstruction a noyau",
+ fr = "Nom du fichier graphique de la reconstruction a processing",
ang = "Kernel Smoothing Drawing Filename",
),
copyfiles('../Ui',os.path.join(path_distrib,'Ui'),['*.ui','makefile'])
copyfiles('../Openturns',os.path.join(path_distrib,'Openturns'),['*.py','*.ini'])
copyfiles('../Ihm',os.path.join(path_distrib,'Ihm'),['*.py'])
- copyfiles('../Extensions',os.path.join(path_distrib,'Extensions'),['*.py'])
+ copyfiles('../extensions',os.path.join(path_distrib,'extensions'),['*.py'])
copyfiles('../Misc',os.path.join(path_distrib,'Misc'),['*.py'])
copyfiles('../Accas',os.path.join(path_distrib,'Accas'),['*.py'])
copyfiles('../Accas',os.path.join(path_distrib,'Noyau'),['*.py'])
copyfiles('../Ui',os.path.join(path_distrib,'Ui'),['*.ui','makefile'])
copyfiles('../Openturns',os.path.join(path_distrib,'Openturns'),['*.py','*.ini'])
copyfiles('../Ihm',os.path.join(path_distrib,'Ihm'),['*.py'])
- copyfiles('../Extensions',os.path.join(path_distrib,'Extensions'),['*.py'])
+ copyfiles('../extensions',os.path.join(path_distrib,'extensions'),['*.py'])
copyfiles('../Misc',os.path.join(path_distrib,'Misc'),['*.py'])
copyfiles('../Accas',os.path.join(path_distrib,'Accas'),['*.py'])
copyfiles('../Accas',os.path.join(path_distrib,'Noyau'),['*.py'])
val_min=1,
defaut=20,
),
- QGEN_CONTROL = SIMP ( statut = "o",
+ QGEP_CONTROL = SIMP ( statut = "o",
typ = bool,
defaut = True,
),
- b_QgenControl = BLOC (condition = "QGEN_CONTROL == True",
+ b_QgenControl = BLOC (condition = "QGEP_CONTROL == True",
SAVE_CASE_BEFORE_QCONTROL = SIMP ( statut = "o",
typ = bool,
defaut = False,
self.fichier_text += "%s=MONMOTEUR(ID='%s',);\n" % (nom,'a')
listeNouveau.append(nom)
- import Extensions.jdc_include
- self.JdC_aux = Extensions.jdc_include.JDC_CATA_INCLUDE(code='PSEN', execmodul=None)
+ import Accas.extensions.jdc_include
+ self.JdC_aux = extensions.jdc_include.JDC_CATA_INCLUDE(code='PSEN', execmodul=None)
self.make_contexte_include(None, self.fichier_text)
self.old_context_fichier_init = self.contexte_fichier_init
self.parent.record_unit(unite, self)
JdC = JDC_CATA ( code = 'PSEN',
execmodul = None,
regles = ( AU_MOINS_UN ( 'CASE_SELECTION', 'CONTINGENCY_PROCESSING' ),
- AU_MOINS_UN ( 'CONTINGENCY_SELECTION','N_PROCESSING_OPTIONS','CONTINGENCY_PROCESSING' ),
+ AU_MOINS_UN ( 'CONTINGENCY_SELECTION','P_PROCESSING_OPTIONS','CONTINGENCY_PROCESSING' ),
PRESENT_PRESENT ( 'CONTINGENCY_SELECTION','CONTINGENCY_OPTIONS' ),
PRESENT_PRESENT ( 'CONTINGENCY_PROCESSING','CONTINGENCY_OPTIONS' ),
AU_MOINS_UN ( 'SIMULATION' ),
AU_PLUS_UN ( 'CONTINGENCY_OPTIONS' ),
AU_PLUS_UN ( 'CONTINGENCY_SELECTION' ),
AU_PLUS_UN ( 'CONTINGENCY_PROCESSING' ),
- AU_PLUS_UN ( 'N_PROCESSING_OPTIONS' ),
+ AU_PLUS_UN ( 'P_PROCESSING_OPTIONS' ),
# AU_PLUS_UN ( 'N_1_LINES' ),
# AU_PLUS_UN ( 'N_1_LOADS' ),
# AU_PLUS_UN ( 'N_1_TRANSFORMERS' ),
MaxDepth = SIMP(statut = 'o', typ = 'I', defaut = 5),
OutputNewCsv = SIMP ( statut = "o",typ=bool,defaut=False,),
)
-N_PROCESSING_OPTIONS = PROC ( nom = 'N_PROCESSING_OPTIONS',
+P_PROCESSING_OPTIONS = PROC ( nom = 'P_PROCESSING_OPTIONS',
op = None,
ang = "Select whether the program should be displaying data about the different categories.\nThe values displayed will be the min, max, and mean of each item, plus a chart.",
Output_bus_values = SIMP(statut = 'o', typ = bool, defaut = True),
)
-Ordre_Des_Commandes = ('CASE_SELECTION' , 'N_PROCESSING_OPTIONS' , 'CONTINGENCY_SELECTION', 'CONTINGENCY_OPTIONS' ,'CONTINGENCY_PROCESSING',)
-Classement_Commandes_Ds_Arbre = ('CASE_SELECTION' , 'N_PROCESSING_OPTIONS' , 'CONTINGENCY_SELECTION', 'CONTINGENCY_OPTIONS' ,'CONTINGENCY_PROCESSING',)
+Ordre_Des_Commandes = ('CASE_SELECTION' , 'P_PROCESSING_OPTIONS' , 'CONTINGENCY_SELECTION', 'CONTINGENCY_OPTIONS' ,'CONTINGENCY_PROCESSING',)
+Classement_Commandes_Ds_Arbre = ('CASE_SELECTION' , 'P_PROCESSING_OPTIONS' , 'CONTINGENCY_SELECTION', 'CONTINGENCY_OPTIONS' ,'CONTINGENCY_PROCESSING',)
JdC = JDC_CATA ( code = 'PSEN',
execmodul = None,
regles = ( AU_MOINS_UN ( 'CASE_SELECTION', 'CONTINGENCY_PROCESSING' ),
- AU_MOINS_UN ( 'CONTINGENCY_SELECTION','N_PROCESSING_OPTIONS','CONTINGENCY_PROCESSING' ),
+ AU_MOINS_UN ( 'CONTINGENCY_SELECTION','P_PROCESSING_OPTIONS','CONTINGENCY_PROCESSING' ),
PRESENT_PRESENT ( 'CONTINGENCY_SELECTION','CONTINGENCY_OPTIONS' ),
# AU_MOINS_UN ( 'SIMULATION' ),
# AU_PLUS_UN ( 'PSSE_PARAMETERS' ),
AU_PLUS_UN ( 'CONTINGENCY_OPTIONS' ),
AU_PLUS_UN ( 'CONTINGENCY_SELECTION' ),
AU_PLUS_UN ( 'CONTINGENCY_PROCESSING' ),
- AU_PLUS_UN ( 'N_PROCESSING_OPTIONS' ),
+ AU_PLUS_UN ( 'P_PROCESSING_OPTIONS' ),
# AU_PLUS_UN ( 'N_1_LINES' ),
# AU_PLUS_UN ( 'N_1_LOADS' ),
# AU_PLUS_UN ( 'N_1_TRANSFORMERS' ),
MaxDepth = SIMP(statut = 'o', typ = 'I', defaut = 5),
OutputNewCsv = SIMP ( statut = "o",typ=bool,defaut=False,),
)
-N_PROCESSING_OPTIONS = PROC ( nom = 'N_PROCESSING_OPTIONS',
+P_PROCESSING_OPTIONS = PROC ( nom = 'P_PROCESSING_OPTIONS',
op = None,
ang = "Select whether the program should be displaying data about the different categories.\nThe values displayed will be the min, max, and mean of each item, plus a chart.",
Output_bus_values = SIMP(statut = 'o', typ = bool, defaut = True),
)
-Ordre_Des_Commandes = ('CASE_SELECTION' , 'N_PROCESSING_OPTIONS' , 'CONTINGENCY_SELECTION', 'CONTINGENCY_OPTIONS' ,'CONTINGENCY_PROCESSING',)
-Classement_Commandes_Ds_Arbre = ('CASE_SELECTION' , 'N_PROCESSING_OPTIONS' , 'CONTINGENCY_SELECTION', 'CONTINGENCY_OPTIONS' ,'CONTINGENCY_PROCESSING',)
+Ordre_Des_Commandes = ('CASE_SELECTION' , 'P_PROCESSING_OPTIONS' , 'CONTINGENCY_SELECTION', 'CONTINGENCY_OPTIONS' ,'CONTINGENCY_PROCESSING',)
+Classement_Commandes_Ds_Arbre = ('CASE_SELECTION' , 'P_PROCESSING_OPTIONS' , 'CONTINGENCY_SELECTION', 'CONTINGENCY_OPTIONS' ,'CONTINGENCY_PROCESSING',)
R_EXT =SIMP(statut='o', typ='R', fr="rayon exterieur"),
EP_NOMINALE =SIMP(statut='o', typ='R', fr="epaisseur nominale sans sous epaisseur"),
ANGLE_COUDE =SIMP(statut='o', typ='R', defaut=90 , val_min=90. , val_max=90. ,fr="angle du coude"),
- ORIENTATION_COUDE =SIMP(statut='o', typ='TXM',defaut='D',into=('D','G'),fr="orientation du coude"),
+ ORIENTATIOP_COUDE =SIMP(statut='o', typ='TXM',defaut='D',into=('D','G'),fr="orientation du coude"),
LONGUEUR_PROLONGEMENT_AMONT=SIMP(statut='o', typ='R', fr="longueur du prolongement amont"),
LONGUEUR_PROLONGEMENT_AVAL =SIMP(statut='o', typ='R', fr="longueur du prologenment aval"),
PAS_MESURE =SIMP(statut='o', typ='I', fr="pas de la mesure"),
copyfiles('../UiQT4',os.path.join(path_distrib,'UiQT4'),['*.ui','makefile'])
copyfiles('../Sous_epaisseur',os.path.join(path_distrib,'Sous_epaisseur'),['*.py','*.ini'])
copyfiles('../Ihm',os.path.join(path_distrib,'Ihm'),['*.py'])
- copyfiles('../Extensions',os.path.join(path_distrib,'Extensions'),['*.py'])
+ copyfiles('../extensions',os.path.join(path_distrib,'extensions'),['*.py'])
copyfiles('../Misc',os.path.join(path_distrib,'Misc'),['*.py'])
copyfiles('../Accas',os.path.join(path_distrib,'Accas'),['*.py'])
# AIDE
import copy
from tsparser import *
from Accas import *
-from Noyau import *
+from Accas.processing import *
from dicoparser import *
def normalize( theTranslation ):
PARSER = TSParser()
def is_ok( theName, theObject ):
- ok = isinstance( theObject, N_ENTITE.ENTITE ) or theName in SPECIAL
+ ok = isinstance( theObject, P_ENTITE.ENTITE ) or theName in SPECIAL
return ok
def name_to_attr( theName ):
from viewManager import MyTabview
from getVersion import getEficasVersion
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
from Editeur import session
def setUp(self):
from qtEficas import Appli
from Editeur import session
- from Extensions import localisation
+ from Accas.extensions import localisation
options = session.parse(sys.argv)
if options.code!= None : code=options.code
-from Noyau import SIMP
+from Accas.processing import SIMP
import unittest
def __adapt__(self,protocol):
return protocol.adapt(self.valeur)
-from Noyau.N_VALIDATOR import listProto,TypeProtocol,IntoProtocol
+from Accas.processing.P_VALIDATOR import listProto,TypeProtocol,IntoProtocol
class param:
def __init__(self,valeur):
self.valeur=valeur
# coding=utf-8
from Accas import SIMP,ASSD
-from Extensions.param2 import Variable,cos
+from Accas.extensions.param2 import Variable,cos
import unittest
def __adapt__(self,protocol):
return protocol.adapt(self.valeur)
-from Noyau.N_VALIDATOR import listProto,TypeProtocol,IntoProtocol
+from Accas.processing.P_VALIDATOR import listProto,TypeProtocol,IntoProtocol
class param:
def __init__(self,valeur):
self.valeur=valeur
# coding=utf-8
from Accas import *
-from Extensions.param2 import Variable
+from Accas.extensions.param2 import Variable
import unittest
import compare
"(\"\"\".*?\"\"\"|'''.*?'''|\"[^\"]*\"|'[^']*'|#.*?\n)", re.DOTALL
)
-import six
-
-if six.PY2:
- allchars = string.maketrans("", "")
- allcharsExceptNewline = (
- allchars[: allchars.index("\n")] + allchars[allchars.index("\n") + 1 :]
- )
- allcharsExceptNewlineTranstable = string.maketrans(
- allcharsExceptNewline, "*" * len(allcharsExceptNewline)
- )
-else:
- allchars = bytes.maketrans(b"", b"")
- allcharsExceptNewline = (
+allchars = bytes.maketrans(b"", b"")
+allcharsExceptNewline = (
allchars[: allchars.index(b"\n")] + allchars[allchars.index(b"\n") + 1 :]
)
- allcharsExceptNewlineTranstable = bytes.maketrans(
+allcharsExceptNewlineTranstable = bytes.maketrans(
allcharsExceptNewline, b"*" * len(allcharsExceptNewline)
)
"MACR_FIABILITE",
"MACR_FIAB_IMPR",
"MACR_INFO_MAIL",
- "MACR_LIGN_COUPE",
+ "MACR_LIGP_COUPE",
"MACRO_ELAS_MULT",
"MACRO_EXPANS",
"MACRO_MATR_AJOU",
# Modification mot-clés liés à la mémoire
removeMotCle(jdc, "FACTORISER", "LIBERE_MEMOIRE", pasDeRegle(), 0)
renameMotCle(jdc, "FACTORISER", "OUT_OF_CORE", "GESTION_MEMOIRE")
- dMEM = {"OUI": "OUT_OF_CORE", "NON": "IN_CORE"}
+ dMEM = {"OUI": "OUT_OF_CORE", "NON": "IP_CORE"}
changementValeur(jdc, "FACTORISER", "GESTION_MEMOIRE", dCRIT)
#### traitement de FORMULE ##############################
{"REFUSER": "HOMARD", "IGNORER": "IGNORE_PYRA"},
)
- #### traitement de MACR_LIGN_COUPE ##############################
+ #### traitement de MACR_LIGP_COUPE ##############################
# Rien à faire
#### traitement de MACRO_ELAS_MULT ##############################
"CALC_FATIGUE",
"COURBE_GRD_VIE",
{
- "MANSON_C": "MANSON_COFFIN",
+ "MANSON_C": "MANSOP_COFFIN",
},
)
"POST_FATIGUE",
"DOMMAGE",
{
- "MANSON_C": "MANSON_COFFIN",
+ "MANSON_C": "MANSOP_COFFIN",
},
)
#### traitement de DEFI_PART_FETI ##############################
genereErreurMCF(jdc, "DEFI_PART_FETI", "EXCIT")
removeMotCle(jdc, "DEFI_PART_FETI", "EXCIT", pasDeRegle(), 0)
- removeMotCle(jdc, "DEFI_PART_FETI", "CORRECTION_CONNEX", pasDeRegle(), 0)
+ removeMotCle(jdc, "DEFI_PART_FETI", "CORRECTIOP_CONNEX", pasDeRegle(), 0)
genereErreurPourCommande(jdc, "DEFI_PART_FETI")
renameCommande(
jdc,
"DEBUT",
"CALC_CHAM_ELEM",
"AFFE_CHAR_THER",
- "MACR_LIGN_COUPE",
+ "MACR_LIGP_COUPE",
"POST_RCCM",
"PROJ_MESU_MODAL",
"CREA_RESU",
"AFFE_CHAR_MECA_HYDR_CALCULEE": "l'hydratation est maintenant une variable de commande",
"AFFE_CHAR_MECA_EPSA_CALCULEE": "EPSA est maintenant une variable de commande",
"AFFE_CHAR_MECA_PRESSION_CALCULEE": "PRESSION_CALCULEE est remplace par EVOL_CHAR",
- "MACR_LIGN_COUPE": "MACR_LIGN_COUPE demande un traitement manuel",
+ "MACR_LIGP_COUPE": "MACR_LIGP_COUPE demande un traitement manuel",
"POST_RCCM": "POST_RCCM demande un traitement manuel",
"DEFI_MATERIAU_CHABOCHE": "remplacer la valeur CINx_CHAB",
"DEFI_MATERIAU_POLY_CFC": "le materiau POLY_CFC est remplace par le comportement POLYCRISTAL",
"DOMM_MAXI": "MATAKE_MODI_AV",
"FATEMI_SOCIE": "FATESOCI_MODI_AV",
}
- changementValeurDsMCF(jdc, "DEFI_MATERIAU", "CISA_PLAN_CRIT", "CRITERE", dfatigue)
+ changementValeurDsMCF(jdc, "DEFI_MATERIAU", "CISA_PLAP_CRIT", "CRITERE", dfatigue)
####################### traitement IMPR_CO #######################
chercheOperInsereFacteurSiRegle(jdc, "IMPR_CO", "CONCEPT", ((("CO",), "existe"),))
)
####################### traitement MACR_LIGNE_COUPE #######################
- appelleMacroSelonValeurConcept(jdc, "MACR_LIGN_COUPE", ("LIGN_COUPE", "TABLE"))
- removeMotCleInFact(jdc, "MACR_LIGN_COUPE", "LIGN_COUPE", "TABLE")
+ appelleMacroSelonValeurConcept(jdc, "MACR_LIGP_COUPE", ("LIGP_COUPE", "TABLE"))
+ removeMotCleInFact(jdc, "MACR_LIGP_COUPE", "LIGP_COUPE", "TABLE")
####################### traitement MODI_MAILLAGE #######################
removeMotCle(jdc, "MODI_MAILLAGE", "MODELE")
"CALC_PRECONT",
"LIRE_INTE_SPEC",
"MACR_CARA_POUTRE",
- "MACR_LIGN_COUPE",
+ "MACR_LIGP_COUPE",
)
dict_erreurs = {
renameMotCle(jdc, "MACR_CARA_POUTRE", "UNITE_MAILLAGE", "UNITE")
################################################################################
- ######### traitement de MACR_LIGN_COUPE ######################################
- # il y a un probleme s'il y a plusieurs mots clefs facteurs LIGN_COUPE : la regle ne marche qu'une fois par commande
+ ######### traitement de MACR_LIGP_COUPE ######################################
+ # il y a un probleme s'il y a plusieurs mots clefs facteurs LIGP_COUPE : la regle ne marche qu'une fois par commande
ajouteMotClefDansFacteurSiRegle(
jdc,
- "MACR_LIGN_COUPE",
- "LIGN_COUPE",
+ "MACR_LIGP_COUPE",
+ "LIGP_COUPE",
"REPERE='LOCAL'",
(
(
(
- "LIGN_COUPE",
+ "LIGP_COUPE",
"VECT_Y",
),
"existeMCsousMCF",
# autre probleme : s'il y a plusieurs mots clefs facteurs le traducteur peut, dans l'insertion, se tromper de mot clef facteur
ajouteMotClefDansFacteurSiRegle(
jdc,
- "MACR_LIGN_COUPE",
- "LIGN_COUPE",
+ "MACR_LIGP_COUPE",
+ "LIGP_COUPE",
"TYPE='GROUP_NO'",
(
(
(
- "LIGN_COUPE",
+ "LIGP_COUPE",
"GROUP_NO",
),
"existeMCsousMCF",
)
ajouteMotClefDansFacteurSiRegle(
jdc,
- "MACR_LIGN_COUPE",
- "LIGN_COUPE",
+ "MACR_LIGP_COUPE",
+ "LIGP_COUPE",
"TYPE='GROUP_MA'",
(
(
(
- "LIGN_COUPE",
+ "LIGP_COUPE",
"GROUP_MA",
),
"existeMCsousMCF",
"MACR_ASPIC_CALC",
"MACR_ECREVISSE",
"MACR_INFO_MAIL",
- "MACR_LIGN_COUPE",
+ "MACR_LIGP_COUPE",
"MACRO_ELAS_MULT",
"MACRO_MATR_AJOU",
"MACRO_MISS_3D",
changementValeur(jdc, "LIRE_RESU", "NOM_CHAM", dOPTION)
changementValeur(jdc, "MACR_ADAP_MAIL", "NOM_CHAM", dOPTION)
changementValeurDsMCF(jdc, "MACR_ASPIC_CALC", "IMPRESSION", "NOM_CHAM", dOPTION)
- changementValeur(jdc, "MACR_LIGN_COUPE", "NOM_CHAM", dOPTION)
+ changementValeur(jdc, "MACR_LIGP_COUPE", "NOM_CHAM", dOPTION)
changementValeurDsMCF(jdc, "MODI_REPERE", "MODI_CHAM", "NOM_CHAM", dOPTION)
changementValeurDsMCF(jdc, "POST_ELEM", "INTEGRALE", "NOM_CHAM", dOPTION)
changementValeurDsMCF(jdc, "POST_ELEM", "MINMAX", "NOM_CHAM", dOPTION)
genereErreurValeur(jdc, "LIRE_RESU", "NOM_CHAM", rOPTION)
genereErreurValeur(jdc, "MACR_ADAP_MAIL", "NOM_CHAM", rOPTION)
# genereErreurDsMCF(jdc,"MACR_ASPIC_CALC","IMPRESSION","NOM_CHAM",rOPTION)
- genereErreurValeur(jdc, "MACR_LIGN_COUPE", "NOM_CHAM", rOPTION)
+ genereErreurValeur(jdc, "MACR_LIGP_COUPE", "NOM_CHAM", rOPTION)
genereErreurValeurDsMCF(jdc, "MODI_REPERE", "MODI_CHAM", "NOM_CHAM", rOPTION)
# genereErreurValeurDsMCF(jdc,"POST_RCCM","RESU_MECA","NOM_CHAM",rOPTION)
genereErreurValeurDsMCF(jdc, "POST_ELEM", "INTEGRALE", "NOM_CHAM", rOPTION)
+++ /dev/null
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-# Installation de tous les fichiers Python du repertoire et des sous-repertoires (sauf CVS)
-install ( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
- DESTINATION ${CMAKE_INSTALL_PREFIX}
- FILES_MATCHING PATTERN *.py
- PATTERN CVS EXCLUDE
- )
-
-
-### Local Variables:
-### mode: cmake
-### End:
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-from builtins import object
-
-
-class AU_MOINS_UN(object):
-
- """
- La regle AU_MOINS_UN verifie que l'on trouve au moins un des mots-cles
- de la regle parmi les arguments d'un OBJECT.
-
- Ces arguments sont transmis a la regle pour validation sous la forme
- d'une liste de noms de mots-cles ou d'un dictionnaire dont
- les cles sont des noms de mots-cles.
- """
-
- def verif(self, args):
- """
- La methode verif verifie que l'on trouve au moins un des mos-cles
- de la liste self.mcs parmi les elements de args
-
- args peut etre un dictionnaire ou une liste. Les elements de args
- sont soit les elements de la liste soit les cles du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text = ""
- count = 0
- args = self.listeToDico(args)
- for mc in self.mcs:
- if mc in args:
- count = count + 1
- if count == 0:
- text = "- Il faut au moins un mot-cle parmi : " + repr(self.mcs) + "\n"
- return text, 0
- return text, 1
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-
-from builtins import object
-
-class AU_PLUS_UN(object):
-
- """
- La regle verifie que l'on trouve 1 (au plus) des mots-cles
- de la regle parmi les arguments d'un OBJECT.
-
- Ces arguments sont transmis a la regle pour validation sous la forme
- d'une liste de noms de mots-cles ou d'un dictionnaire dont
- les cles sont des noms de mots-cles.
- """
-
- def verif(self, args):
- """
- La methode verif verifie que l'on trouve 1 (au plus) des mos-cles
- de la liste self.mcs parmi les elements de args
-
- args peut etre un dictionnaire ou une liste. Les elements de args
- sont soit les elements de la liste soit les cles du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text = ""
- count = 0
- args = self.listeToDico(args)
- for mc in self.mcs:
- count = count + args.get(mc, 0)
- if count > 1:
- text = (
- "- Il ne faut qu'un mot-cle (au plus) parmi : " + repr(self.mcs) + "\n"
- )
- return text, 0
- return text, 1
-
- def listeToDico(self, args):
- if type(args) is dict:
- return args
- elif type(args) in (list, tuple):
- dico = {}
- for arg in args:
- dico[arg] = dico.get(arg, 0) + 1
- return dico
- else:
- raise Exception("Erreur ce n'est ni un dictionnaire ni une liste %s" % args)
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-from builtins import str
-from builtins import object
-
-
-class A_CLASSER(object):
-
- """
- La regle A_CLASSER verifie que ...
-
- """
-
- def __init__(self, *args):
- if len(args) > 2:
- print("Erreur a la creation de la regle A_CLASSER(%s)" % str(args))
- return
- self.args = args
- if type(args[0]) == tuple:
- self.args0 = args[0]
- elif type(args[0]) == str:
- self.args0 = (args[0],)
- else:
- print(
- "Le premier argument de : %s doit etre un tuple ou une chaine"
- % str(args)
- )
- if type(args[1]) == tuple:
- self.args1 = args[1]
- elif type(args[1]) == str:
- self.args1 = (args[1],)
- else:
- print(
- "Le deuxieme argument de : %s doit etre un tuple ou une chaine"
- % str(args)
- )
- # creation de la liste des mcs
- liste = []
- liste.extend(self.args0)
- liste.extend(self.args1)
- self.mcs = liste
- self.initCouplesPermis()
-
- def initCouplesPermis(self):
- """Cree la liste des couples permis parmi les self.args, cad pour chaque element
- de self.args0 cree tous les couples possibles avec un element de self.args1"""
- liste = []
- for arg0 in self.args0:
- for arg1 in self.args1:
- liste.append((arg0, arg1))
- self.liste_couples = liste
-
- def verif(self, args):
- """
- args peut etre un dictionnaire ou une liste. Les elements de args
- sont soit les elements de la liste soit les cles du dictionnaire.
- """
- # creation de la liste des couples presents dans le fichier de
- # commandes
- l_couples = []
- couple = []
- text = ""
- test = 1
- for nom in args:
- if nom in self.mcs:
- couple.append(nom)
- if len(couple) == 2:
- l_couples.append(tuple(couple))
- couple = [
- nom,
- ]
- if len(couple) > 0:
- l_couples.append(tuple(couple))
- # l_couples peut etre vide si l'on n'a pas reussi a trouver au moins un
- # element de self.mcs
- if len(l_couples) == 0:
- message = (
- "- Il faut qu'au moins un objet de la liste : %s soit suivi d'au moins un objet de la liste %s : "
- % (self.args0, self.args1)
- )
- return message, 0
- # A ce stade, on a trouve des couples : il faut verifier qu'ils sont
- # tous licites
- num = 0
- for couple in l_couples:
- num = num + 1
- if len(couple) == 1:
- # on a un 'faux' couple
- if couple[0] not in self.args1:
- text = (
- text
- + "- L'objet : %s doit etre suivi d'un objet de la liste : %r\n"
- % (couple[0], self.args1)
- )
- test = 0
- else:
- if num > 1:
- # ce n'est pas le seul couple --> licite
- break
- else:
- text = (
- text
- + "- L'objet : %s doit etre precede d'un objet de la liste : %r\n"
- % (couple[0], self.args0)
- )
- test = 0
- elif couple not in self.liste_couples:
- text = text + "- L'objet : %s ne peut etre suivi de : %s\n" % (
- couple[0],
- couple[1],
- )
- test = 0
- return text, test
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-from builtins import object
-
-class ENSEMBLE(object):
-
- """
- La regle verifie que si un mot-cle de self.mcs est present
- parmi les elements de args tous les autres doivent etre presents.
-
- Ces arguments sont transmis a la regle pour validation sous la forme
- d'une liste de noms de mots-cles ou d'un dictionnaire dont
- les cles sont des noms de mots-cles.
- """
-
- def verif(self, args):
- """
- La methode verif effectue la verification specifique a la regle.
- args peut etre un dictionnaire ou une liste. Les elements de args
- sont soit les elements de la liste soit les cles du dictionnaire.
- """
- # on compte le nombre de mots cles presents, il doit etre egal a la liste
- # figurant dans la regle
- text = ""
- test = 1
- args = self.listeToDico(args)
- pivot = None
- for mc in self.mcs:
- if mc in args:
- pivot = mc
- break
- if pivot:
- for mc in self.mcs:
- if mc != pivot:
- if not mc in args:
- text = (
- text
- + "- "
- + pivot
- + " etant present, "
- + mc
- + " doit etre present"
- + "\n"
- )
- test = 0
- return text, test
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-"""
- Ce module contient la classe mixin ETAPE qui porte les methodes
- necessaires pour realiser la validation d'un objet de type ETAPE
- derive de OBJECT.
-
- Une classe mixin porte principalement des traitements et est
- utilisee par heritage multiple pour composer les traitements.
-"""
-
-# Modules Python
-import types
-import sys
-import traceback
-import re
-
-# Modules EFICAS
-from . import V_MCCOMPO
-from Noyau import MAXSIZE, MAXSIZE_MSGCHK
-from Noyau.N_Exception import AsException
-from Noyau.N_utils import AsType
-from Extensions.i18n import tr
-
-
-class ETAPE(V_MCCOMPO.MCCOMPO):
-
- """ """
-
- def validChild(self):
- """Cette methode teste la validite des mots cles de l'etape"""
- for child in self.mcListe:
- if not child.isValid():
- return 0
- return 1
-
- def validRegles(self, cr):
- """Cette methode teste la validite des regles de l'etape"""
- text_erreurs, test_regles = self.verifRegles()
- if not test_regles:
- if cr == "oui":
- self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs)
- return 0
- return 1
-
- def validSdnom(self, cr):
- """Cette methode teste la validite du nom du concept produit par l'etape"""
- valid = 1
- if self.sd.nom != None:
- if self.sd.nom.find("sansnom") != -1:
- # la SD est 'sansnom' : --> erreur
- if cr == "oui":
- self.cr.fatal(("object must have a name"))
- valid = 0
- elif re.search("^SD_[0-9]*$", self.sd.nom):
- # la SD est 'SD_' cad son nom = son id donc pas de nom donne
- # par utilisateur : --> erreur
- if cr == "oui":
- self.cr.fatal(("invalid name ('SD_' is a reserved keyword)"))
- valid = 0
- return valid
-
- def getValid(self):
- if hasattr(self, "valid"):
- return self.valid
- else:
- self.valid = None
- return None
-
- def setValid(self, valid):
- old_valid = self.getValid()
- self.valid = valid
- self.state = "unchanged"
- if not old_valid or old_valid != self.valid:
- self.initModifUp()
-
- def isValid(self, sd="oui", cr="non"):
- """
- Methode pour verifier la validite de l'objet ETAPE. Cette methode
- peut etre appelee selon plusieurs modes en fonction de la valeur
- de sd et de cr.
-
- Si cr vaut oui elle cree en plus un compte-rendu.
-
- Cette methode a plusieurs fonctions :
-
- - mettre a jour l'etat de self (update)
-
- - retourner un indicateur de validite 0=non, 1=oui
-
- - produire un compte-rendu : self.cr
-
- """
- # if CONTEXT.debug:
- # if 1 :
- # print(("ETAPE.isValid ", self.nom, self.state))
- # import traceback
- # traceback.print_stack()
- if self.state == "unchanged":
- return self.valid
- else:
- valid = self.validChild()
- valid = valid * self.validRegles(cr)
- if cr == "oui":
- if not hasattr(self, "cr"):
- from Noyau.N_CR import CR
-
- self.cr = CR()
- else:
- self.cr.purge()
- if self.reste_val != {}:
- if cr == "oui":
- self.cr.fatal(
- "unknown keywords : %s" % ",".join(list(self.reste_val.keys()))
- )
- valid = 0
-
- if sd == "non":
- # Dans ce cas, on ne teste qu'une validite partielle (sans tests sur le concept produit)
- # Consequence : on ne change pas l'etat ni l'attribut valid, on retourne simplement
- # l'indicateur de validite valid
- return valid
-
- if self.definition.reentrant == "n" and self.reuse:
- # Il ne peut y avoir de concept reutilise avec un OPER non
- # reentrant
- if cr == "oui":
- self.cr.fatal("Operateur non reentrant : ne pas utiliser reuse")
- valid = 0
-
- if self.sd == None:
- # Le concept produit n'existe pas => erreur
- if cr == "oui":
- self.cr.fatal(("Concept is not defined"))
- valid = 0
- else:
- valid = valid * self.validSdnom(cr)
-
- if valid:
- valid = self.updateSdprod(cr)
-
- self.setValid(valid)
-
- return self.valid
-
- def updateSdprod(self, cr="non"):
- """
- Cette methode met a jour le concept produit en fonction des conditions initiales :
-
- 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None)
-
- 2. Le concept retourne n existait pas (self.sd == None)
-
- 3. Le concept retourne existait. On change alors son type ou on le supprime
-
- En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1
- """
- sd_prod = self.definition.sd_prod
- if type(sd_prod) == types.FunctionType: # Type de concept retourne calcule
- d = self.creeDictValeurs(self.mcListe)
- try:
- sd_prod = sd_prod(*(), **d)
- except:
- # Erreur pendant le calcul du type retourne
- if CONTEXT.debug:
- traceback.print_exc()
- self.sd = None
- if cr == "oui":
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- self.cr.fatal(
- "unable to affect type to concept\n %s" % " ".join(l[2:])
- )
- return 0
- # on teste maintenant si la SD est reutilisee ou s'il faut la
- # creer
- valid = 1
- if self.reuse:
- if AsType(self.reuse) != sd_prod:
- if cr == "oui":
- self.cr.fatal(
- ("Type de concept reutilise incompatible avec type produit")
- )
- valid = 0
- if self.sdnom != "":
- if self.sdnom[0] != "_" and self.reuse.nom != self.sdnom:
- # Le nom de la variable de retour (self.sdnom) doit etre le
- # meme que celui du concept reutilise (self.reuse.nom)
- if cr == "oui":
- self.cr.fatal(
- "Concept reutilise : le nom de la variable de retour devrait etre %s et non %s"
- % (self.reuse.nom, self.sdnom)
- )
- valid = 0
- if valid:
- self.sd = self.reuse
- else:
- if sd_prod == None: # Pas de concept retourne
- # Que faut il faire de l eventuel ancien sd ?
- self.sd = None
- else:
- if self.sd:
- # Un sd existe deja, on change son type
- if CONTEXT.debug:
- print(("changement de type:", self.sd, sd_prod))
- if self.sd.__class__ != sd_prod:
- self.sd.changeType(sd_prod)
- else:
- # Le sd n existait pas , on ne le cree pas
- if cr == "oui":
- self.cr.fatal("Concept retourne non defini")
- valid = 0
- if self.definition.reentrant == "o":
- if cr == "oui":
- self.cr.fatal(
- (
- "Commande obligatoirement reentrante : specifier reuse=concept"
- )
- )
- valid = 0
- return valid
-
- def report(self):
- """
- Methode pour generation d un rapport de validite
- """
- self.cr = self.CR(
- debut="Command : "
- + tr(self.nom)
- + " line : "
- + repr(self.appel[0])
- + " file : "
- + repr(self.appel[1]),
- fin="End Command : " + tr(self.nom),
- )
- self.state = "modified"
- try:
- self.isValid(cr="oui")
- except AsException as e:
- if CONTEXT.debug:
- traceback.print_exc()
- self.cr.fatal(
- "Command : %s line : %r file : %r %s"
- % (tr(self.nom), self.appel[0], self.appel[1], e)
- )
- i = 0
- for child in self.mcListe:
- i += 1
- if i > MAXSIZE:
- print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mcListe)))
- break
- self.cr.add(child.report())
- return self.cr
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-from builtins import object
-
-
-class EXCLUS(object):
-
- """
- La regle verifie qu'un seul mot-cle de self.mcs est present
- parmi les elements de args.
-
- Ces arguments sont transmis a la regle pour validation sous la forme
- d'une liste de noms de mots-cles ou d'un dictionnaire dont
- les cles sont des noms de mots-cles.
- """
-
- def verif(self, args):
- """
- La methode verif effectue la verification specifique a la regle.
- args peut etre un dictionnaire ou une liste. Les elements de args
- sont soit les elements de la liste soit les cles du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text = ""
- count = 0
- args = self.listeToDico(args)
- for mc in self.mcs:
- if mc in args:
- count = count + 1
- if count > 1:
- text = "- Il ne faut qu un mot cle parmi : " + repr(self.mcs) + "\n"
- return text, 0
- return text, 1
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-"""
- Ce module contient la classe mixin JDC qui porte les methodes
- necessaires pour realiser la validation d'un objet de type JDC
- derive de OBJECT.
-
- Une classe mixin porte principalement des traitements et est
- utilisee par heritage multiple pour composer les traitements.
-"""
-
-# Modules EFICAS
-from . import V_MCCOMPO
-from Noyau.N_Exception import AsException
-from Noyau.N_utils import AsType
-
-
-class JDC(V_MCCOMPO.MCCOMPO):
-
- """ """
-
- def report(self):
- """
- Methode pour generation d un rapport de validite
- """
- self.cr.purge()
- # self.cr.debut = "DEBUT CR validation : " + self.nom
- # self.cr.fin = "FIN CR validation :" + self.nom
- self.cr.debut = "BEGIN validation report : " + self.nom
- self.cr.fin = "END validation report :" + self.nom
- for e in self.etapes:
- if e.isActif():
- self.cr.add(e.report())
- self.state = "modified"
- self.isValid(cr="oui")
- return self.cr
-
- def isValid(self, cr="non"):
- """
- Methode booleenne qui retourne 0 si le JDC est invalide, 1 sinon
- """
- # FR : on prend en compte l'etat du JDC ('unchanged','modified','undetermined')
- # afin d'accelerer le test de validite du JDC
- if self.state == "unchanged":
- return self.valid
- else:
- valid = 1
- texte, test = self.verifRegles()
- if test == 0:
- if cr == "oui":
- if texte != "" and (" ".strip(texte) == ""):
- self.cr.fatal(texte)
- else:
- self.cr.fatal(" ".strip(texte))
- valid = 0
- if valid:
- for e in self.etapes:
- if not e.isActif():
- continue
- if not e.isValid():
- valid = 0
- break
- self.state = "unchanged"
- self.valid = valid
- return self.valid
-
- def getValid(self, cr="non"):
- if self.state == "unchanged":
- return self.valid
- else:
- return self.isValid()
-
- def verifRegles(self):
- """
- Effectue la verification de validite des regles du jeu de commandes
- """
- noms_etapes = [etape.nom for etape in self.etapes]
- texte_global = ""
- test_global = 1
- for regle in self.regles:
- texte, test = regle.verif(noms_etapes)
- texte_global = texte_global + texte
- test_global = test_global * test
- return texte_global, test_global
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-"""
- Ce module contient la classe mixin MACRO_ETAPE qui porte les methodes
- necessaires pour realiser la validation d'un objet de type MACRO_ETAPE
- derive de OBJECT.
-
- Une classe mixin porte principalement des traitements et est
- utilisee par heritage multiple pour composer les traitements.
-"""
-
-# Modules Python
-import types
-import sys
-import traceback
-
-# Modules EFICAS
-from . import V_MCCOMPO
-from . import V_ETAPE
-from Noyau.N_Exception import AsException
-from Noyau.N_utils import AsType
-
-
-class MACRO_ETAPE(V_ETAPE.ETAPE):
-
- """ """
-
- def isValid(self, sd="oui", cr="non"):
- """
- Methode pour verifier la validite de l'objet ETAPE. Cette methode
- peut etre appelee selon plusieurs modes en fonction de la valeur
- de sd et de cr.
-
- Si cr vaut oui elle cree en plus un compte-rendu.
-
- Cette methode a plusieurs fonctions :
-
- - mettre a jour l'etat de self (update)
-
- - retourner un indicateur de validite 0=non, 1=oui
-
- - produire un compte-rendu : self.cr
-
- """
- if CONTEXT.debug:
- print(("ETAPE.isValid ", self.nom))
- if self.state == "unchanged":
- return self.valid
- else:
- valid = 1
- # On marque les concepts CO pour verification ulterieure de leur
- # bonne utilisation
- l = self.getAllCo()
- # On verifie que les concepts CO sont bien passes par typeSDProd
- for c in l:
- # if c.etape is self.parent:
- if c.isTypCO() != 2:
- # le concept est propriete de l'etape parent
- # Il n'a pas ete transforme par typeSDProd
- # Cette situation est interdite
- # Pb: La macro-commande a passe le concept a une commande
- # (macro ?) mal definie
- if cr == "oui":
- self.cr.fatal(
- "Macro-commande mal definie : le concept n'a pas ete type par un appel a typeSDProd pour %s"
- % c.nom
- )
- valid = 0
-
- valid = valid * self.validChild()
- valid = valid * self.validRegles(cr)
-
- if self.reste_val != {}:
- if cr == "oui":
- self.cr.fatal(
- "unknown keyword : %s" % ",".join(list(self.reste_val.keys()))
- )
- valid = 0
-
- if sd == "non":
- # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'etat de self
- # on retourne simplement l'indicateur valid
- return valid
-
- if self.sd != None:
- valid = valid * self.validSdnom(cr)
-
- if self.definition.reentrant == "n" and self.reuse:
- # Il ne peut y avoir de concept reutilise avec une MACRO non
- # reentrante
- if cr == "oui":
- self.cr.fatal(
- "Macro-commande non reentrante : ne pas utiliser reuse"
- )
- valid = 0
-
- if valid:
- valid = self.updateSdprod(cr)
-
- # Si la macro comprend des etapes internes, on teste leur validite
- for e in self.etapes:
- if not e.isValid():
- valid = 0
- break
-
- self.setValid(valid)
-
- return self.valid
-
- def updateSdprod(self, cr="non"):
- """
- Cette methode met a jour le concept produit en fonction des conditions initiales :
-
- 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None)
-
- 2. Le concept retourne n existait pas (self.sd == None)
-
- 3. Le concept retourne existait. On change alors son type ou on le supprime
-
- En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1
- """
- sd_prod = self.definition.sd_prod
- # On memorise le type retourne dans l attribut typret
- self.typret = None
- if type(sd_prod) == types.FunctionType:
- # Type de concept retourne calcule
- d = self.creeDictValeurs(self.mcListe)
- try:
- # la sd_prod d'une macro a l'objet lui meme en premier argument
- # contrairement a une ETAPE ou PROC_ETAPE
- # Comme sd_prod peut invoquer la methode typeSDProd qui ajoute
- # les concepts produits dans self.sdprods, il faut le mettre a
- # zero
- self.sdprods = []
- sd_prod = sd_prod(*(self,), **d)
- except:
- # Erreur pendant le calcul du type retourne
- if CONTEXT.debug:
- traceback.print_exc()
- self.sd = None
- if cr == "oui":
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- self.cr.fatal(
- "Impossible d affecter un type au resultat\n%s"
- % " ".join(l[2:])
- )
- return 0
- # on teste maintenant si la SD est reutilisee ou s'il faut la
- # creer
- valid = 1
- if self.reuse:
- # Un concept reutilise a ete specifie
- if AsType(self.reuse) != sd_prod:
- if cr == "oui":
- self.cr.fatal(
- "Type de concept reutilise incompatible avec type produit"
- )
- valid = 0
- if self.sdnom != "":
- if self.sdnom[0] != "_" and self.reuse.nom != self.sdnom:
- # Le nom de la variable de retour (self.sdnom) doit etre le
- # meme que celui du concept reutilise (self.reuse.nom)
- if cr == "oui":
- self.cr.fatal(
- "Concept reutilise : le nom de la variable de retour devrait etre %s et non %s"
- % (self.reuse.nom, self.sdnom)
- )
- valid = 0
- if valid:
- self.sd = self.reuse
- else:
- # Cas d'un concept non reutilise
- if sd_prod == None: # Pas de concept retourne
- # Que faut il faire de l eventuel ancien sd ?
- self.sd = None
- else:
- if self.sd:
- # Un sd existe deja, on change son type
- if CONTEXT.debug:
- print(("changement de type:", self.sd, sd_prod))
- if self.sd.__class__ != sd_prod:
- self.sd.changeType(sd_prod)
- self.typret = sd_prod
- else:
- # Le sd n existait pas , on ne le cree pas
- self.typret = sd_prod
- if cr == "oui":
- self.cr.fatal("Concept retourne non defini")
- valid = 0
- if self.definition.reentrant == "o":
- if cr == "oui":
- self.cr.fatal(
- "Commande obligatoirement reentrante : specifier reuse=concept"
- )
- valid = 0
- return valid
-
- def report(self):
- """
- Methode pour la generation d un rapport de validation
- """
- V_ETAPE.ETAPE.report(self)
- for e in self.etapes:
- self.cr.add(e.report())
- return self.cr
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-"""
- Ce module contient la classe mixin MCBLOC qui porte les methodes
- necessaires pour realiser la validation d'un objet de type MCBLOC
- derive de OBJECT.
-
- Une classe mixin porte principalement des traitements et est
- utilisee par heritage multiple pour composer les traitements.
-"""
-
-# Modules EFICAS
-from . import V_MCCOMPO
-
-
-class MCBLOC(V_MCCOMPO.MCCOMPO):
-
- """
- Cette classe a un attribut de classe :
-
- - txt_nat qui sert pour les comptes-rendus lies a cette classe
- """
-
- txt_nat = "Bloc :"
-
- def isValid(self, sd="oui", cr="non"):
- """
- Methode pour verifier la validite du MCBLOC. Cette methode
- peut etre appelee selon plusieurs modes en fonction de la valeur
- de sd et de cr.
-
- Si cr vaut oui elle cree en plus un compte-rendu
- sd est present pour compatibilite de l'interface mais ne sert pas
- """
- if self.state == "unchanged":
- return self.valid
- else:
- valid = 1
- if hasattr(self, "valid"):
- old_valid = self.valid
- else:
- old_valid = None
- for child in self.mcListe:
- if not child.isValid():
- valid = 0
- break
- # Apres avoir verifie la validite de tous les sous-objets, on verifie
- # la validite des regles
- text_erreurs, test_regles = self.verifRegles()
- if not test_regles:
- if cr == "oui":
- self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs)
- valid = 0
- self.valid = valid
- self.state = "unchanged"
- if not old_valid or old_valid != self.valid:
- self.initModifUp()
- return self.valid
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-"""
- Ce module contient la classe de base MCCOMPO qui sert a factoriser
- les traitements des objets composites de type OBJECT
-"""
-
-# Modules Python
-from builtins import str
-from builtins import object
-
-import os
-import traceback
-
-# Modules EFICAS
-from Noyau import MAXSIZE, MAXSIZE_MSGCHK
-from Noyau import N_CR
-from Noyau.N_Exception import AsException
-
-
-class MCCOMPO(object):
-
- """
- L'attribut mcListe a ete cree par une classe derivee de la
- classe MCCOMPO du Noyau
- """
-
- CR = N_CR.CR
-
- def __init__(self):
- self.state = "undetermined"
- # defini dans les classes derivees
- self.txt_nat = ""
-
- def initModifUp(self):
- """
- Propage l'etat modifie au parent s'il existe et n'est pas l'objet
- lui-meme
- """
- if self.parent and self.parent != self:
- self.parent.state = "modified"
-
- def report(self):
- """
- Genere le rapport de validation de self
- """
- self.cr = self.CR()
- self.cr.debut = self.txt_nat + self.nom
- self.cr.fin = "END " + self.txt_nat + self.nom
- i = 0
- for child in self.mcListe:
- i += 1
- if i > MAXSIZE:
- print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mcListe)))
- break
- self.cr.add(child.report())
- self.state = "modified"
- try:
- self.isValid(cr="oui")
- except AsException as e:
- if CONTEXT.debug:
- traceback.print_exc()
- self.cr.fatal(" ".join((self.txt_nat, self.nom, str(e))))
- return self.cr
-
- def verifRegles(self):
- """
- A partir du dictionnaire des mots-cles presents, verifie si les regles
- de self sont valides ou non.
-
- Retourne une chaine et un booleen :
-
- - texte = la chaine contient le message d'erreur de la (les) regle(s) violee(s) ('' si aucune)
-
- - testglob = booleen 1 si toutes les regles OK, 0 sinon
- """
- # On verifie les regles avec les defauts affectes
- dictionnaire = self.dictMcPresents(restreint="non")
- texte = [""]
- testglob = 1
- for r in self.definition.regles:
- erreurs, test = r.verif(dictionnaire)
- testglob = testglob * test
- if erreurs != "":
- texte.append(str(erreurs))
- texte = os.linesep.join(texte)
- return texte, testglob
-
- def dictMcPresents(self, restreint="non"):
- """
- Retourne le dictionnaire {mocle : objet} construit a partir de self.mcListe
- Si restreint == 'non' : on ajoute tous les mots-cles simples du catalogue qui ont
- une valeur par defaut
- Si restreint == 'oui' : on ne prend que les mots-cles effectivement entres par
- l'utilisateur (cas de la verification des regles)
- """
- dico = {}
- # on ajoute les couples {nom mot-cle:objet mot-cle} effectivement
- # presents
- for v in self.mcListe:
- if v == None:
- continue
- k = v.nom
- dico[k] = v
- if restreint == "oui":
- return dico
- # Si restreint != 'oui',
- # on ajoute les couples {nom mot-cle:objet mot-cle} des mots-cles simples
- # possibles pour peu qu'ils aient une valeur par defaut
- for k, v in list(self.definition.entites.items()):
- if v.label != "SIMP":
- continue
- if not v.defaut:
- continue
- if not k in dico:
- dico[k] = v(nom=k, val=None, parent=self)
- # on ajoute l'objet detenteur de regles pour des validations plus
- # sophistiquees (a manipuler avec precaution)
- dico["self"] = self
- return dico
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-"""
- Ce module contient la classe mixin MCFACT qui porte les methodes
- necessaires pour realiser la validation d'un objet de type MCFACT
- derive de OBJECT.
-
- Une classe mixin porte principalement des traitements et est
- utilisee par heritage multiple pour composer les traitements.
-"""
-# Modules EFICAS
-from . import V_MCCOMPO
-
-
-class MCFACT(V_MCCOMPO.MCCOMPO):
-
- """
- Cette classe a un attribut de classe :
-
- - txt_nat qui sert pour les comptes-rendus lies a cette classe
- """
-
- txt_nat = "Mot cle Facteur :"
-
- def isValid(self, sd="oui", cr="non"):
- """
- Methode pour verifier la validite du MCFACT. Cette methode
- peut etre appelee selon plusieurs modes en fonction de la valeur
- de sd et de cr.
-
- Si cr vaut oui elle cree en plus un compte-rendu
- sd est present pour compatibilite de l'interface mais ne sert pas
- """
- if self.state == "unchanged":
- return self.valid
- else:
- valid = 1
- if hasattr(self, "valid"):
- old_valid = self.valid
- else:
- old_valid = None
- for child in self.mcListe:
- if not child.isValid():
- valid = 0
- break
- # Apres avoir verifie la validite de tous les sous-objets, on verifie
- # la validite des regles
- text_erreurs, test_regles = self.verifRegles()
- if not test_regles:
- if cr == "oui":
- self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs)
- valid = 0
- #
- # On verifie les validateurs s'il y en a
- #
- if self.definition.validators and not self.definition.validators.verif(
- self.valeur
- ):
- if cr == "oui":
- self.cr.fatal(
- "Keyword : %s should have %s"
- % (self.nom, self.definition.validators.info())
- )
- valid = 0
- # fin des validateurs
- #
- if self.reste_val != {}:
- if cr == "oui":
- self.cr.fatal(
- "unknow keyword : %s" % ",".join(list(self.reste_val.keys()))
- )
- valid = 0
- self.valid = valid
- self.state = "unchanged"
- if not old_valid or old_valid != self.valid:
- self.initModifUp()
- return self.valid
- def getValid(self):
- if hasattr(self, "valid"):
- return self.valid
- else:
- self.valid = None
- return None
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-"""
- Ce module contient la classe mixin MCList qui porte les methodes
- necessaires pour realiser la validation d'un objet de type MCList
- derive de OBJECT.
-
- Une classe mixin porte principalement des traitements et est
- utilisee par heritage multiple pour composer les traitements.
-"""
-# Modules Python
-from builtins import object
-import traceback
-
-# Modules EFICAS
-from Extensions.i18n import tr
-from Noyau import MAXSIZE, MAXSIZE_MSGCHK
-from Noyau import N_CR
-from Noyau.N_Exception import AsException
-
-
-class MCList(object):
-
- """
- Cette classe a deux attributs de classe :
-
- - CR qui sert a construire l'objet compte-rendu
-
- - txt_nat qui sert pour les comptes-rendus lies a cette classe
- """
-
- CR = N_CR.CR
- txt_nat = "Mot cle Facteur Multiple :"
-
- def isValid(self, cr="non"):
- """
- Methode pour verifier la validite du MCList. Cette methode
- peut etre appelee selon plusieurs modes en fonction de la valeur
- de cr.
-
- Si cr vaut oui elle cree en plus un compte-rendu.
-
- On n'utilise pas d'attribut pour stocker l'etat et on ne remonte pas
- le changement d'etat au parent (pourquoi ??)
- MCLIST est une liste de MCFACT. Les MCFACT ont le meme parent
- que le MCLIST qui les contient. Il n'est donc pas necessaire de
- remonter le changement d'etat au parent. C'est deja fait
- par les MCFACT.
- """
- if len(self.data) == 0:
- return 0
-
- valid = 1
- definition = self.data[0].definition
- # Verification du nombre des mots cles facteurs
- if definition.min is not None and len(self.data) < definition.min:
- valid = 0
- if cr == "oui":
- self.cr.fatal(
- "Nombre de mots cles facteurs insuffisant minimum : %s"
- % definition.min
- )
-
- if definition.max is not None and len(self.data) > definition.max:
- valid = 0
- if cr == "oui":
- self.cr.fatal(
- "Nombre de mots cles facteurs trop grand maximum : %s"
- % definition.max
- )
- num = 0
- for i in self.data:
- num = num + 1
- if not i.isValid():
- valid = 0
- if cr == "oui" and len(self) > 1:
- self.cr.fatal(
- "L'occurrence numero %d du mot-cle facteur : %s n'est pas valide"
- % (num, self.nom)
- )
- return valid
-
- def report(self):
- """
- Genere le rapport de validation de self
- """
- if len(self) > 1:
- # Mot cle facteur multiple
- self.cr = self.CR(
- debut="Mot-cle facteur multiple : " + tr(self.nom),
- fin="Fin Mot-cle facteur multiple : " + tr(self.nom),
- )
- j = 0
- for i in self.data:
- j += 1
- if j > MAXSIZE:
- print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.data)))
- break
- self.cr.add(i.report())
- elif len(self) == 1:
- # Mot cle facteur non multiple
- self.cr = self.data[0].report()
- else:
- self.cr = self.CR(
- debut="Mot-cle facteur : " + tr(self.nom),
- fin="Fin Mot-cle facteur : " + tr(self.nom),
- )
-
- try:
- self.isValid(cr="oui")
- except AsException as e:
- if CONTEXT.debug:
- traceback.print_exc()
- self.cr.fatal(" %s Mot-cle facteur multiple : %s" % (self.nom, e))
- return self.cr
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-"""
- Ce module contient la classe mixin MCSIMP qui porte les methodes
- necessaires pour realiser la validation d'un objet de type MCSIMP
- derive de OBJECT.
-
- Une classe mixin porte principalement des traitements et est
- utilisee par heritage multiple pour composer les traitements.
-"""
-# Modules Python
-from builtins import str
-from builtins import object
-
-# Modules EFICAS
-from Noyau import N_CR
-from Noyau.N_Exception import AsException
-from Noyau.N_VALIDATOR import ValError, TypeProtocol, CardProtocol, IntoProtocol
-from Noyau.N_VALIDATOR import listProto
-from Extensions.i18n import tr
-
-
-class MCSIMP(object):
-
- """
- COMMENTAIRE CCAR:
- Cette classe est quasiment identique a la classe originale d'EFICAS
- a part quelques changements cosmetiques et des chagements pour la
- faire fonctionner de facon plus autonome par rapport a l'environnement
- EFICAS
-
- A mon avis, il faudrait aller plus loin et reduire les dependances
- amont au strict necessaire.
-
- - Est il indispensable de faire l'evaluation de la valeur dans le contexte
- du jdc dans cette classe.
- oui surtout pour les filtres et les validateurs
-
- - Ne pourrait on pas doter les objets en presence des methodes suffisantes
- pour eviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
- d'ailleurs modifie la classe pour eviter l'import de GEOM
- """
-
- CR = N_CR.CR
-
- def __init__(self):
- self.state = "undetermined"
- self.typeProto = TypeProtocol("type", typ=self.definition.type)
- self.intoProto = IntoProtocol(
- "into",
- into=self.definition.into,
- val_min=self.definition.val_min,
- val_max=self.definition.val_max,
- )
- self.cardProto = CardProtocol(
- "card", min=self.definition.min, max=self.definition.max
- )
-
- def getValid(self):
- if hasattr(self, "valid"):
- return self.valid
- else:
- self.valid = None
- return None
-
- def setValid(self, valid):
- old_valid = self.getValid()
- self.valid = valid
- self.state = "unchanged"
- if not old_valid or old_valid != self.valid:
- self.initModifUp()
-
- def isValid(self, cr="non"):
- """
- Cette methode retourne un indicateur de validite de l'objet de type MCSIMP
-
- - 0 si l'objet est invalide
- - 1 si l'objet est valide
-
- Le parametre cr permet de parametrer le traitement. Si cr == 'oui'
- la methode construit egalement un comte-rendu de validation
- dans self.cr qui doit avoir ete cree prealablement.
- """
- if self.state == "unchanged":
- return self.valid
- else:
- valid = 1
- v = self.valeur
- # verification presence
- if self.isOblig() and (v == None or v == ""):
- if cr == "oui":
- self.cr.fatal("Mandatory keyword : %s has no value" % tr(self.nom))
- valid = 0
-
- lval = listProto.adapt(v)
- # Ajout PN
- # Pour tenir compte des Tuples
- if hasattr(self.definition.type[0], "ntuple"):
- try:
- if (not (type(lval[0]) is tuple)) and (not (type(lval[0]) is list)):
- lval = (lval,)
- except:
- pass
- if lval is None:
- valid = 0
- if cr == "oui":
- self.cr.fatal("None is not a valid value")
- else:
- # type,into ...
- # typeProto=TypeProtocol("type",typ=self.definition.type)
- # intoProto=IntoProtocol("into",into=self.definition.into,val_min=self.definition.val_min,val_max=self.definition.val_max)
- # cardProto=CardProtocol("card",min=self.definition.min,max=self.definition.max)
- # typeProto=self.definition.typeProto
- # intoProto=self.definition.intoProto
- # cardProto=self.definition.cardProto
- typeProto = self.typeProto
- intoProto = self.intoProto
- cardProto = self.cardProto
- if self.definition.filtre != None:
- listePossibles = self.getUserAssdPossible()
- self.intoProto = IntoProtocol(
- "into",
- into=listePossibles,
- val_min=self.definition.val_min,
- val_max=self.definition.val_max,
- )
- intoProto = self.intoProto
- if cr == "oui":
- # un cr est demande : on collecte tous les types d'erreur
- try:
- for val in lval:
- typeProto.adapt(val)
- except ValError as e:
- valid = 0
- self.cr.fatal(str(e))
- try:
- for val in lval:
- intoProto.adapt(val)
- except ValError as e:
- valid = 0
- self.cr.fatal(str(e))
- try:
- cardProto.adapt(lval)
- except ValError as e:
- valid = 0
- self.cr.fatal(str(e))
- #
- # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
- #
- if valid and self.definition.validators:
- try:
- self.definition.validators.convert(lval)
- except ValError as e:
- self.cr.fatal(
- "invalid keyword %s : %s\nCriteria : %s"
- % (
- tr(self.nom),
- str(e),
- self.definition.validators.info(),
- )
- )
- valid = 0
- else:
- # si pas de cr demande, on sort a la toute premiere erreur
- try:
- for val in lval:
- typeProto.adapt(val)
- intoProto.adapt(val)
- cardProto.adapt(lval)
- if self.definition.validators:
- if hasattr(self.definition.validators, "set_MCSimp"):
- self.definition.validators.set_MCSimp(self)
- self.definition.validators.convert(lval)
- except ValError as e:
- valid = 0
-
- self.setValid(valid)
- return self.valid
-
- def isOblig(self):
- """indique si le mot-cle est obligatoire"""
- return self.definition.statut == "o"
-
- def initModifUp(self):
- """
- Propage l'etat modifie au parent s'il existe et n'est l'objet
- lui-meme
- """
- if self.parent and self.parent != self:
- self.parent.state = "modified"
-
- def report(self):
- """genere le rapport de validation de self"""
- self.cr = self.CR()
- self.cr.debut = "Simple Keyword : " + tr(self.nom)
- self.cr.fin = "End Simple Keyword: " + tr(self.nom)
- self.state = "modified"
- try:
- self.isValid(cr="oui")
- except AsException as e:
- if CONTEXT.debug:
- traceback.print_exc()
- self.cr.fatal("Simple Keyword : %s %s" % (tr(self.nom), e))
- return self.cr
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-from builtins import object
-
-
-class MEME_NOMBRE(object):
-
- """
- La regle MEME_NOMBRE verifie que l'on trouve au moins un des mots-cles
- de la regle parmi les arguments d'un OBJECT.
-
- Ces arguments sont transmis a la regle pour validation sous la forme
- d'une liste de noms de mots-cles ou d'un dictionnaire dont
- les cles sont des noms de mots-cles.
- """
-
- def verif(self, args):
- """
- La methode verif verifie que l'on trouve au moins un des mos-cles
- de la liste self.mcs parmi les elements de args
-
- args peut etre un dictionnaire ou une liste. Les elements de args
- sont soit les elements de la liste soit les cles du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text = ""
- args = self.listeToDico(args)
- size = -1
-
- for mc in self.mcs:
- if mc not in args:
- text = "Une cle dans la regle n'existe pas %s" % mc
- return text, 0
-
- val = args[mc].valeur
- len_val = 0
- if not isinstance(val, type([])):
- len_val = 1
- else:
- len_val = len(val)
-
- if size == -1:
- size = len_val
- elif size != len_val:
- text = "Pas la même longeur"
- return text, 0
- return text, 1
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-from builtins import object
-
-
-class PRESENT_ABSENT(object):
-
- """
- La regle verifie que si le premier mot-cle de self.mcs est present
- parmi les elements de args les autres mots cles de self.mcs
- doivent etre absents
-
- Ces arguments sont transmis a la regle pour validation sous la forme
- d'une liste de noms de mots-cles ou d'un dictionnaire dont
- les cles sont des noms de mots-cles.
- """
-
- def verif(self, args):
- """
- La methode verif effectue la verification specifique a la regle.
- args peut etre un dictionnaire ou une liste. Les elements de args
- sont soit les elements de la liste soit les cles du dictionnaire.
- """
- # on verifie que si le premier de la liste est present,
- # les autres sont absents
- text = ""
- test = 1
- args = self.listeToDico(args)
- mc0 = self.mcs[0]
- if mc0 in args:
- for mc in self.mcs[1 : len(self.mcs)]:
- if mc in args:
- text = (
- text
- + "- Le mot cle "
- + repr(mc0)
- + " etant present, il faut que : "
- + mc
- + " soit absent"
- + "\n"
- )
- test = 0
- return text, test
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-from builtins import object
-
-
-class PRESENT_PRESENT(object):
-
- """
- La regle verifie que si le premier mot-cle de self.mcs est present
- parmi les elements de args les autres doivent l'etre aussi
-
- Ces arguments sont transmis a la regle pour validation sous la forme
- d'une liste de noms de mots-cles ou d'un dictionnaire dont
- les cles sont des noms de mots-cles.
- """
-
- def verif(self, args):
- """
- La methode verif effectue la verification specifique a la regle.
- args peut etre un dictionnaire ou une liste. Les elements de args
- sont soit les elements de la liste soit les cles du dictionnaire.
- """
- # on verifie que si le premier de la liste est present,
- # les autres le sont aussi
- mc0 = self.mcs[0]
- text = ""
- test = 1
- args = self.listeToDico(args)
- if mc0 in args:
- for mc in self.mcs[1 : len(self.mcs)]:
- if not mc in args:
- text = (
- text
- + "- Le mot cle "
- + repr(mc0)
- + " etant present, il faut que : "
- + mc
- + " soit present"
- + "\n"
- )
- test = 0
- return text, test
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-"""
- Ce module contient la classe mixin PROC_ETAPE qui porte les methodes
- necessaires pour realiser la validation d'un objet de type PROC_ETAPE
- derive de OBJECT.
-
- Une classe mixin porte principalement des traitements et est
- utilisee par heritage multiple pour composer les traitements.
-"""
-# Modules EFICAS
-from . import V_ETAPE
-from Noyau.N_Exception import AsException
-from Noyau.N_utils import AsType
-from Extensions.i18n import tr
-
-
-class PROC_ETAPE(V_ETAPE.ETAPE):
-
- """
- On reutilise les methodes report,verifRegles
- de ETAPE par heritage.
- """
-
- def isValid(self, sd="oui", cr="non"):
- """
- Methode pour verifier la validite de l'objet PROC_ETAPE. Cette methode
- peut etre appelee selon plusieurs modes en fonction de la valeur
- de sd et de cr (sd n'est pas utilise).
-
- Si cr vaut oui elle cree en plus un compte-rendu.
-
- Cette methode a plusieurs fonctions :
-
- - retourner un indicateur de validite 0=non, 1=oui
-
- - produire un compte-rendu : self.cr
-
- - propager l'eventuel changement d'etat au parent
- """
- if CONTEXT.debug:
- print(("ETAPE.isValid ", self.nom))
- if self.state == "unchanged":
- return self.valid
- else:
- valid = self.validChild()
- valid = valid * self.validRegles(cr)
- if self.reste_val != {}:
- if not hasattr(self, "cr"):
- from Noyau.N_CR import CR
-
- self.cr = CR()
- if cr == "oui":
- self.cr.fatal(
- tr("unknown keywords : %s")
- % ",".join(list(self.reste_val.keys()))
- )
- valid = 0
- self.setValid(valid)
- return self.valid
+++ /dev/null
-# coding=utf-8
-# ======================================================================
-# COPYRIGHT (C) 2007-2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-from builtins import object
-
-
-class UN_PARMI(object):
-
- """
- La regle verifie que l'on trouve un des mots-cles
- de la regle parmi les arguments d'un OBJECT.
-
- Ces arguments sont transmis a la regle pour validation sous la forme
- d'une liste de noms de mots-cles ou d'un dictionnaire dont
- les cles sont des noms de mots-cles.
- """
-
- def verif(self, args):
- """
- La methode verif verifie que l'on trouve un des mos-cles
- de la liste self.mcs parmi les elements de args
-
- args peut etre un dictionnaire ou une liste. Les elements de args
- sont soit les elements de la liste soit les cles du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text = ""
- count = 0
- args = self.listeToDico(args)
- for mc in self.mcs:
- if mc in args:
- count = count + 1
- if count != 1:
- text = "- Il faut un et un seul mot-cle parmi : " + repr(self.mcs) + "\n"
- return text, 0
- return text, 1
+++ /dev/null
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce package contient la fonctionnalité de validation des objets de type OBJECT.
- Cette fonctionnalité est implémentée sous la forme de classes de type MIXIN qui
- doivent etre combinées aux classes de bases de Noyau par héritage multiple dans
- un troisième package, en général, Accas.
-"""
+++ /dev/null
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-install ( FILES __init__.py parseur_python.py convert_python.py convert_TELEMAC.py
- convert_map.py
- DESTINATION ${CMAKE_INSTALL_PREFIX}/convert
- )
-
-
-
-
-### Local Variables:
-### mode: cmake
-### End:
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- This package contains all input format converters
- into objects understandable by EFICAS.
-
- These converters are implemented in the form of plugins
-"""
-
-from Extensions import pluginloader
-import convert
-
-plugins = pluginloader.PluginLoader(convert)
+++ /dev/null
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-import re
-from Extensions.i18n import tr
-
-# import traceback
-# traceback.print_stack()
-
-"""
-this module contains the parser to read .cas files
-convert them in python
-"""
-
-from convert.convert_python import Pythonparser
-
-pattern_comment_slash = re.compile(r"^\s*/")
-pattern_comment_slash_vide = re.compile(r"^\s*/\s*$")
-pattern_comment_tiret = re.compile(r"^\s*/-*/*$")
-pattern_eta = re.compile(r".*&ETA.*")
-pattern_fin = re.compile(r".*&FIN.*")
-pattern_oui = re.compile(r"^\s*(oui|OUI|YES|yes|TRUE|true|vrai|VRAI)\s*$")
-pattern_non = re.compile(r"^\s*(non|NON|NO|no|FALSE|false|faux|FAUX)\s*$")
-pattern_blanc = re.compile(r"^\s*$")
-pattern_listeVide = re.compile(r"^\s*'\s*'\s*$")
-pattern_commence_par_quote = re.compile(r'^\s*[\'"].*')
-pattern_finit_par_virgule_ou_affect = re.compile(r"^.*(,|;|=|:)\s*$")
-
-pattern_ligne = re.compile(r"^\s*(?P<ident>[^=:]*)\s*[:=]\s*(?P<reste>.*)$")
-
-pattern_variables = re.compile(
- r"^\s*(?P<ident>C_VSM_PRINTOUT_SELECTION|COUPLAGE AVEC|COUPLING WITH|VARIABLES FOR GRAPHIC PRINTOUTS|VARIABLES POUR LES SORTIES GRAPHIQUES|VARIABLES TO BE PRINTED|VARIABLES A IMPRIMER|VARIABLES FOR 3D GRAPHIC PRINTOUTS|VARIABLES POUR LES SORTIES GRAPHIQUES 3D|VARIABLES POUR LES SORTIES GRAPHIQUES 2D|VARIABLES FOR 2D GRAPHIC PRINTOUTS)\s*[:=]\s*(?P<quote>[']?)(?P<valeur>[A-Za-z]+(\d*|\*)([,;][A-Za-z]+(\d*|\*))*)\s*(?P=quote)(?P<reste>.*)$"
-)
-
-# Attention aux listes de flottants
-pattern_liste = re.compile(
- r"^\s*(?P<valeur>[+-.\w]+(\s*;\s*[+-.\w]+)+)\s*(?P<reste>.*)$"
-)
-pattern_liste_texte = re.compile(
- r"^\s*(?P<valeur>('.*(';\s*))+('.*'\s*)?)(?P<reste>.*)$"
-)
-pattern_flottant = re.compile(
- r"^\s*(?P<valeur>[+-]?((\d+(\.\d*)?)|(\.\d+))([dDeE][+-]?\d+)?)\s*(?P<reste>.*)$"
-)
-pattern_texteQuote = re.compile(r"^\s*(?P<valeur>'[^']+(''[^']+)*')\s*(?P<reste>.*)$")
-pattern_texteSimple = re.compile(r"(?P<valeur>(^|\s)\s*[\w\.-]+)\s*(?P<reste>.*)$")
-pattern_texteVide = re.compile(r"^\s*(?P<valeur>'')\s*(?P<reste>.*)$")
-
-pattern_ContientDouble = re.compile(r"^.*''.*$")
-
-# le pattern texte reconnait
-# nom1 nom 2 : ou = chaine entre '
-# avec eventuellement des quotes au milieu par exemple
-# TITRE = 'TELEMAC 2D : GOUTTE D''EAU DANS UN BASSIN$'
-# m.group("texte") va rendre 'TELEMAC 2D : GOUTTE D''EAU DANS UN BASSIN$'
-
-
-# Si le code n est pas Telemac
-# try :
-# from enum_Telemac2d_auto import self.TelemacdicoEn
-# except :
-# pass
-
-from Extensions import localisation
-
-
-def entryPoint():
- """
- Return a dictionary containing the description needed to load the plugin
- """
- return {"name": "TELEMAC", "factory": TELEMACparser}
-
-
-class TELEMACparser(Pythonparser):
- """
- This converter works like Pythonparser, except that it also initializes all
- model variables to None in order to avoid Python syntax errors when loading
- a file with a different or inexistent definition of variables.
- """
-
- def convert(self, outformat, appliEficas=None):
- from Accas import A_BLOC, A_FACT, A_SIMP
-
- try:
- self.dicoCasToCata = appliEficas.readercata.dicoCasToCata
- except:
- self.dicoCasToCata = {}
- print("pas de dicoCasToCata")
- self.dicoInverse = appliEficas.readercata.dicoInverse
- self.dicoMC = appliEficas.readercata.dicoMC
- self.ordreDesCommandes = appliEficas.readercata.ordreDesCommandes
- try:
- self.TelemacdicoEn = appliEficas.readercata.TelemacdicoEn
- except:
- self.TelemacdicoEn = {}
- print("pas de TelemacdicoEn")
- try:
- self.DicoEnumCasFrToEnumCasEn = (
- appliEficas.readercata.DicoEnumCasFrToEnumCasEn
- )
- except:
- self.DicoEnumCasFrToEnumCasEn = {}
- print("pas de DicoEnumCasFrToEnumCasEn")
-
- if appliEficas.langue == "fr":
- # from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
- for k in self.DicoEnumCasFrToEnumCasEn:
- self.TelemacdicoEn[k] = self.DicoEnumCasFrToEnumCasEn[k]
-
- text = ""
- self.dictSimp = {}
-
- l_lignes_texte_all = self.text.split("\n")
- l_lignes_texte = []
- listeComment = []
- dicoComment = {}
- dicoCommentSimp = {}
- dicoCommentMC = {}
- texteComment = ""
- debut = True
- trouveComment = 0
- for l in l_lignes_texte_all:
- if pattern_eta.match(l):
- continue
- if pattern_fin.match(l):
- continue
- if pattern_blanc.match(l):
- continue
-
- if not (pattern_comment_slash.match(l)):
- l_lignes_texte.append(l)
- if trouveComment:
- if debut:
- dicoComment["debut"] = texteComment
- else:
- dicoComment[l] = texteComment
- trouveComment = 0
- texteComment = ""
- if debut:
- debut = False
-
- if pattern_comment_slash.match(l):
- # if pattern_comment_slash_vide.match(l) : continue
- if pattern_comment_tiret.match(l):
- continue
- texteComment += l.replace("/", "", 1)
- texteComment += "\n"
- trouveComment = 1
-
- if texteComment != "":
- dicoComment["fin"] = texteComment
-
- l_lignes = []
- i = 0
- while i < len(l_lignes_texte):
- ligne = l_lignes_texte[i]
- i = i + 1
- if not (pattern_finit_par_virgule_ou_affect.match(ligne)):
- l_lignes.append(ligne)
- continue
- nouvelle_ligne = ligne
- while i < len(l_lignes_texte):
- ligne_traitee = l_lignes_texte[i]
- i = i + 1
- nouvelle_ligne += ligne_traitee
- if not (pattern_finit_par_virgule_ou_affect.match(ligne_traitee)):
- l_lignes.append(nouvelle_ligne)
- break
-
- for ligne in l_lignes:
- if pattern_comment_slash.match(ligne):
- continue
- # PN : deja teste
- # if pattern_eta.match(ligne) : continue
- # if pattern_fin.match(ligne) : continue
- # if pattern_blanc.match(ligne) : continue
-
- finLigne = ligne
- while finLigne != "":
- if pattern_comment_slash.match(finLigne):
- finLigne = ""
- continue
- valeur = ""
- if pattern_variables.match(finLigne):
- m = pattern_variables.match(finLigne)
- simpCas = self.traiteIdent(m.group("ident"))
- if simpCas in ["COUPLING WITH", "COUPLAGE AVEC"]:
- if "," in m.group("valeur"):
- valeur = m.group("valeur").split(",")
- else:
- valeur = m.group("valeur").split(";")
- else:
- valeur = m.group("valeur")
- finLigne = m.group("reste")
- self.dictSimp[simpCas] = valeur
- continue
-
- m = pattern_ligne.match(finLigne)
- if m == None:
- # print( "________________________________________________")
- print("pb avec ****", finLigne, "**** dans ", ligne)
- # print( "________________________________________________")
- break
-
- simpCas = self.traiteIdent(m.group("ident"))
- if not simpCas:
- finLigne = m.group("reste")
- continue
-
- finLigne = m.group("reste")
- # attention, l ordre des if est important
- if pattern_liste.match(finLigne):
- m = pattern_liste.match(finLigne)
- elif pattern_liste_texte.match(finLigne):
- m = pattern_liste_texte.match(finLigne)
- elif pattern_texteQuote.match(finLigne):
- m = pattern_texteQuote.match(finLigne)
- elif pattern_flottant.match(finLigne):
- m = pattern_flottant.match(finLigne)
- elif pattern_texteVide.match(finLigne):
- m = pattern_texteVide.match(finLigne)
- elif pattern_texteSimple.match(finLigne):
- m = pattern_texteSimple.match(finLigne)
- else:
- # print ("________________________________________________")
- print("pb avec ****", finLigne, "**** dans ", ligne)
- print("non match")
- # print ("________________________________________________")
- break
-
- valeur = m.group("valeur")
- if pattern_blanc.match(valeur):
- valeur = None
-
- if pattern_flottant.match(finLigne):
- valeur = re.sub("d", "e", valeur)
- valeur = re.sub("D", "E", valeur)
-
- if pattern_liste.match(finLigne) or pattern_liste_texte.match(finLigne):
- valeur = valeur.split(";")
-
- finLigne = m.group("reste")
- self.dictSimp[simpCas] = valeur
-
- if ligne in dicoComment.keys():
- dicoCommentSimp[simpCas] = dicoComment[ligne]
-
- if "TITLE" not in self.dictSimp:
- import os
-
- # self.dictSimp['TITLE']=os.path.basename(self.filename)
-
- dicoParMC = {}
- for simp in self.dictSimp:
- if simp in TELEMACparser.__dict__:
- TELEMACparser.__dict__[simp](
- self,
- )
-
- for simp in self.dictSimp:
- if simp not in self.dicoInverse:
- # print ( "************")
- print("pb avec dans dicoInverse", simp, "------")
- print("dicoInverse", sorted(self.dicoInverse.keys()))
- # print ("************")
- continue
- listeGenea = self.dicoInverse[simp]
- listeGeneaReverse = []
- for u, v in listeGenea:
- if isinstance(v, A_BLOC.BLOC):
- continue
- listeGeneaReverse.append(u)
- listeGeneaReverse.reverse()
- dicoTravail = dicoParMC
- i = 0
- if simp in dicoCommentSimp:
- MC = listeGeneaReverse[0]
- if MC in dicoCommentMC:
- dicoCommentMC[MC] + dicoCommentSimp[simp]
- else:
- dicoCommentMC[MC] = dicoCommentSimp[simp]
- while i < len(listeGeneaReverse[0:-1]):
- mot = listeGeneaReverse[i]
- i = i + 1
- if mot not in dicoTravail:
- dicoTravail[mot] = {}
- dicoTravail = dicoTravail[mot]
- dicoTravail[simp] = self.dictSimp[simp]
-
- self.textePy = ""
- listeMC = self.tri(list(dicoParMC.keys()))
- for k in listeMC:
- if k in dicoCommentMC:
- commentaire = "COMMENTAIRE(" + repr(dicoCommentMC[k]) + ")\n"
- self.textePy += commentaire
- self.textePy += str(k) + "("
- self.traiteMC(dicoParMC[k])
- self.textePy += ");\n"
-
- # ne sert plus
- # appliEficas.listeTelemac=self.dictSimp
- appliEficas.listeTelemac = {}
- if "debut" in dicoComment:
- commentaire = "COMMENTAIRE(" + repr(dicoComment["debut"]) + ")\n"
- self.textePy = commentaire + self.textePy
- if "fin" in dicoComment:
- commentaire = "COMMENTAIRE(" + repr(dicoComment["fin"]) + ")\n"
- self.textePy = self.textePy + commentaire
-
- # print (self.textePy)
- return self.textePy
-
- # ----------------------------------------
- def traiteIdent(self, ident):
- # enleve les espaces de part et autre
- # traduit du langage Telemac vers le langage Catalogue
- # ----------------------------------------
- while ident[-1] == " " or ident[-1] == "\t":
- ident = ident[0:-1]
- while ident[0] == " " or ident[0] == "\t":
- ident = ident[1:]
- try:
- identCata = self.dicoCasToCata[ident]
- except:
- print("---> ", "pb mot clef pour", ident)
- identCata = None
- return identCata
-
- def traiteMC(self, dico):
- from Accas import A_BLOC, A_FACT, A_SIMP
-
- for k in dico:
- valeur = dico[k]
- if k not in self.dicoMC:
- kA = self.dicoFrancaisAnglais[k]
- else:
- kA = k
- obj = self.dicoMC[kA]
- if isinstance(obj, A_FACT.FACT):
- self.convertFACT(obj, kA, valeur)
- elif isinstance(obj, A_BLOC.BLOC):
- self.convertBLOC(obj, kA, valeur)
- elif isinstance(obj, A_SIMP.SIMP):
- self.convertSIMP(obj, kA, valeur)
- else:
- print(
- "%%%%%%%%%%%\n", "pb conversion type pour", k, obj, "\n%%%%%%%%%%%"
- )
-
- def convertFACT(self, obj, nom, valeur):
- # traitement LIQUID_BOUNDARIES
- if nom in TELEMACparser.__dict__:
- TELEMACparser.__dict__[nom](
- self,
- )
- return
- self.textePy += nom + "=_F( "
- self.traiteMC(valeur)
- self.textePy += "),\n"
-
- def convertBLOC(self, obj, nom, valeur):
- print("ANOMALIE _________ BLOC ")
- print(nom)
-
- def convertSIMP(self, obj, nom, valeur):
- # print ('in convertSIMP', nom,valeur)
- # if nom in ("PRESCRIBED_FLOWRATES", "PRESCRIBED_VELOCITIES", "PRESCRIBED_ELEVATIONS" ): return
- if obj.max == 1:
- if hasattr(obj.type[0], "ntuple"):
- lval = []
- for v in valeur:
- try:
- v = eval(v, {})
- except:
- pass
- lval.append(v)
- self.textePy += nom + "=" + str(lval) + ","
- return
- if "TXM" in obj.type:
- if pattern_ContientDouble.match(str(valeur)):
- valeur = re.sub("''", "''", str(valeur))
- self.textePy += nom + "=" + str(valeur) + ","
- return
- valeur = str(valeur)
-
- # ceinture et bretelle si les re sont correctes -)
- while valeur[-1] == " " or valeur[-1] == "\t":
- valeur = valeur[0:-1]
- while valeur[0] == " " or valeur[0] == "\t":
- valeur = valeur[1:]
-
- # Pour les enum
- try:
- valeur = eval(valeur, {})
- except:
- pass
-
- if nom in self.TelemacdicoEn:
- try:
- valeur = self.TelemacdicoEn[nom][valeur]
- self.textePy += nom + "= '" + str(valeur) + "',"
- return
- except:
- pass
-
- if (
- obj.into != []
- and obj.into != None
- and not ("R" in obj.type)
- and not ("I" in obj.type)
- ):
- for possible in obj.into:
- try:
- if possible.upper() == valeur.upper():
- valeur = possible
- break
- v = valeur[0].upper() + valeur[1:].lower()
- v2 = tr(v)
- if possible.upper() == v2.upper():
- valeur = possible
- break
- except:
- if valeur != None:
- print(
- "pb avec le type de ",
- obj.nom,
- obj.type,
- "et la valeur ",
- valeur,
- )
-
- if (
- "Fichier" in obj.type
- or "TXM" in obj.type
- or "Repertoire" in obj.type
- or "FichierOuRepertoire" in obj.type
- ):
- valeur = str(valeur)
- if valeur == "" or valeur == " ":
- self.textePy += nom + "= '" + str(valeur) + "' ,"
- return
- while valeur[-1] == " ":
- valeur = valeur[0:-1]
- while valeur[0] == " ":
- valeur = valeur[1:]
- self.textePy += nom + "= '" + str(valeur) + "' ,"
- return
-
- if bool in obj.type:
- if valeur == True:
- self.textePy += nom + "= True,"
- elif valeur == False:
- self.textePy += nom + "= False,"
- elif pattern_oui.match(valeur):
- self.textePy += nom + "= True,"
- elif pattern_non.match(valeur):
- self.textePy += nom + "= False,"
- else:
- self.textePy += nom + "= None,"
- return
- self.textePy += nom + "=" + str(valeur) + ","
-
- else:
- if valeur == () or valeur == [] or pattern_listeVide.match(str(valeur)):
- self.textePy += nom + "= None,"
- return
-
- # les 4 lignes suivantes sont probablement inutiles
- while valeur[-1] == " " or valeur[-1] == "'":
- valeur = valeur[0:-1]
- while valeur[0] == " " or valeur[-0] == "'":
- valeur = valeur[1:]
- oldValeur = valeur
- if isinstance(valeur, str):
- if ";" in valeur:
- valeur = valeur.split(";")
- else:
- valeur = valeur.split(",")
-
- if len(valeur) < 2 and pattern_flottant.match(oldValeur):
- # Attention : on attend une liste mais on a une seule valeur!
- try:
- oldValeur = eval(oldValeur, {})
- except:
- pass
- if nom in self.TelemacdicoEn:
- v = self.TelemacdicoEn[nom][oldValeur]
- self.textePy += nom + "= ('" + str(v) + "',),"
- else:
- self.textePy += nom + "= (" + str(oldValeur) + ",),"
- return
-
- # Cas des liste de booléen
- if bool in obj.type:
- values = []
- for val in valeur:
- if val == True or pattern_oui.match(val) or val == "True":
- values.append("True")
- elif val == False or pattern_non.match(val) or val == "False":
- values.append("False")
- else:
- values.append("None")
- self.textePy += nom + "= [" + ",".join(values) + "],"
- return
-
- if valeur == None:
- return
- newVal = []
- for v in valeur:
- try:
- v = eval(v, {})
- except:
- pass
- if nom in self.TelemacdicoEn:
- try:
- v = self.TelemacdicoEn[nom][v]
- except:
- pass
- newVal.append(v)
- self.textePy += nom + "=" + str(newVal) + ","
-
- def tri(self, listeIn):
- if len(listeIn) == 1:
- return listeIn
- if self.ordreDesCommandes == None:
- return listeIn
- listeOut = [
- listeIn[0],
- ]
- for k in listeIn[1:]:
- # k=str(self.dicoFrancaisAnglais[kF])
- ordreK = self.ordreDesCommandes.index(k)
- i = 0
- while i < len(listeOut):
- # ordreI=self.ordreDesCommandes.index(self.dicoFrancaisAnglais[listeOut[i]])
- ordreI = self.ordreDesCommandes.index(listeOut[i])
- if ordreK < ordreI:
- break
- i = i + 1
- # listeOut.insert(i,kF)
- listeOut.insert(i, k)
- return listeOut
+++ /dev/null
-# Copyright (C) 2007-2022 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-from Extensions.i18n import tr
-
-# import traceback
-# traceback.print_stack()
-
-from convert.convert_python import Pythonparser
-
-
-def entryPoint():
- """
- Return a dictionary containing the description needed to load the plugin
- """
- return {"name": "pythonUQ", "factory": pythonUQParser}
-
-
-class pythonUQParser(Pythonparser):
- """
- This converter works like Pythonparser, except that it also initializes all
- links between deterministic and probabilistic variables
- """
-
- def convert(self, outformat, appliEficas=None):
- text = Pythonparser.convert(self, outformat, appliEficas)
- return text
-
- def traitementApresLoad(self, jdc):
- debug = 0
- if debug:
- print("traitementApresLoad")
- etapeIncertitude = jdc.getEtapesByName("ExpressionIncertitude")
- if etapeIncertitude == []:
- return
-
- incertitudeInput = etapeIncertitude[0].getChildOrChildInBloc("Input")
- self.lesVariablesInput = incertitudeInput[0].getChildOrChildInBloc(
- "VariableProbabiliste"
- )
- for mc in self.lesVariablesInput:
- # if debug : print (mc,'mc')
- mcVDPath = mc.getChild("MCPath").valeur
- if debug:
- print(mcVDPath)
- # a modifier lorsque le MCPath comprendra le nom des OPERs
- if not (mcVDPath):
- mc.parent.suppentite(mc)
- break # on admet ici que le . comm n est pas valide
- mcModelVariable = mc.getChild("ModelVariable")
- mcModelVariable.definition.addInto(mcModelVariable.valeur)
- # try :
- # mcObjectName=mc.getChild('ObjectName')
- # mcObjectName.changeStatut('f')
- # except :
- # pass
- mcCherche = jdc.getObjetByMCPath(mcVDPath)
- if not (mcCherche):
- mc.parent.suppentite(mc)
- break # on admet ici que le . comm n est pas valide
- if debug:
- print(mcCherche)
- if mc.nature == "MCFACT":
- mc[0].variableDeterministe = mcCherche
- mcCherche.variableProbabiliste = mc[0]
- else:
- mc.variableDeterministe = mcCherche
- mcCherche.variableProbabiliste = mc[0]
- mcCherche.definition.siValide = mcCherche.changeValeursRefUQ
- mcCherche.associeVariableUQ = True
- itemConsigne = mc.getChild("Consigne")
- itemConsigne.setValeur(
- "la valeur entrée pour {} est {}".format(
- mcCherche.nom, mcCherche.valeur
- )
- )
+++ /dev/null
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-import re
-from Extensions.i18n import tr
-
-# import traceback
-# traceback.print_stack()
-
-from Extensions import localisation
-from Noyau import N_CR
-from .convert_UQPython import pythonUQParser
-
-
-def entryPoint():
- """
- Return a dictionary containing the description needed to load the plugin
- """
- return {"name": "xml", "factory": XMLparser}
-
-
-class XMLparser:
- """
- This converter works like Pythonparser, except that it reads XML file
- """
-
- def __init__(self, cr=None):
- # print("dans XML convert")
- self.text = ""
- if cr:
- self.cr = cr
- else:
- self.cr = N_CR.CR(
- debut="CR convertisseur format XML", fin="fin CR format XML"
- )
-
- def readfile(self, filename):
- self.filename = filename
- try:
- with open(filename) as fd:
- self.text = fd.read()
- except:
- self.cr.exception(tr("Impossible d'ouvrir le fichier %s", str(filename)))
- self.cr.fatal(tr("Impossible d'ouvrir le fichier %s", str(filename)))
- return
-
- def convert(self, outformat, appliEficas=None):
- # ici on ne fait rien
- # on le fera a la creation du JDC
- try:
- return self.text
- except Exception as e:
- # Erreur lors de la conversion
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- self.cr.exception(
- tr("Impossible de convertir le fichier XML\n %s", "".join(l))
- )
- return ""
+++ /dev/null
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-from .convert_python import Pythonparser
-from Noyau import N_CR
-
-
-def entryPoint():
- """
- Return a dictionary containing the description needed to load the plugin
- """
- return {"name": "dico", "factory": Dicoparser}
-
-
-class Dicoparser(Pythonparser):
- """
- This converter initializes model variable from a python dictionnary
- """
-
- def __init__(self, cr=None):
- # Si l'objet compte-rendu n'est pas fourni, on utilise le
- # compte-rendu standard
- self.text = ""
- self.textePy = ""
- if cr:
- self.cr = cr
- else:
- self.cr = N_CR.CR(
- debut="CR convertisseur format dico", fin="fin CR format dico"
- )
-
- def readfile(self, filename):
- self.filename = filename
- try:
- with open(filename) as fd:
- self.text = fd.read()
- except:
- self.cr.exception(tr("Impossible d'ouvrir le fichier %s", str(filename)))
- self.cr.fatal(tr("Impossible d'ouvrir le fichier %s", str(filename)))
- return
-
- def convert(self, outformat, appli=None):
- monTexteDico = {}
- exec(self.text, globals(), monTexteDico)
- if len(monTexteDico.keys()) != 1:
- self.cr.exception(tr("Impossible de traiter le fichier %s", str(filename)))
- self.cr.fatal(tr("Impossible de traiter le fichier %s", str(filename)))
- return
- self.textePy = ""
- monDico = monTexteDico[monTexteDico.keys()[0]]
- for commande in monDico:
- valeurs = monDico[commande]
- if valeurs.has_key("NomDeLaSdCommande"):
- # cas d un oper
- self.textePy += valeurs["NomDeLaSdCommande"] + " = " + commande + "("
- del valeurs["NomDeLaSdCommande"]
- else:
- self.textePy += commande + "("
- for mot in valeurs:
- if isinstance(valeurs[mot], dict):
- self.traiteMCFact(mot, valeurs[mot])
- else:
- self.textePy += mot + " = " + str(valeurs[mot]) + ","
- self.textePy += ");\n" # fin de la commande
- return self.textePy
-
- def traiteMCFact(self, mot, valeurs):
- self.textePy += mot + "=_F("
- for mot in valeurs:
- if isinstance(valeurs[mot], dict):
- self.traiteMCFact(mot, valeurs[mot])
- else:
- self.textePy += mot + " = " + str(valeurs[mot]) + ","
- self.textePy += "),"
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin convertisseur de fichier
- au format python pour EFICAS.
-
- Un plugin convertisseur doit fournir deux attributs de classe :
- extensions et formats et deux methodes : readfile,convert.
-
- L'attribut de classe extensions est une liste d'extensions
- de fichiers preconisees pour ce type de format. Cette information
- est seulement indicative.
-
- L'attribut de classe formats est une liste de formats de sortie
- supportes par le convertisseur. Les formats possibles sont :
- eval, dict ou exec.
- Le format eval est un texte source Python qui peut etre evalue. Le
- resultat de l'evaluation est un objet Python quelconque.
- Le format dict est un dictionnaire Python.
- Le format exec est un texte source Python qui peut etre execute.
-
- La methode readfile a pour fonction de lire un fichier dont le
- nom est passe en argument de la fonction.
- - convertisseur.readfile(nom_fichier)
-
- La methode convert a pour fonction de convertir le fichier
- prealablement lu dans un objet du format passe en argument.
- - objet=convertisseur.convert(outformat)
-
- Ce convertisseur supporte le format de sortie exec
-
-"""
-
-import sys, traceback
-from builtins import str
-from builtins import object
-
-from .parseur_python import PARSEUR_PYTHON
-from Noyau import N_CR
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
-
-
-def entryPoint():
- """
- 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": Pythonparser,
- }
-
-
-class Pythonparser(object):
- """
- Ce convertisseur lit un fichier au format python avec la
- methode readfile : convertisseur.readfile(nom_fichier)
- et retourne le texte au format outformat avec la
- methode convertisseur.convert(outformat)
-
- Ses caracteristiques principales sont exposees dans 2 attributs
- de classe :
- - extensions : qui donne une liste d'extensions de fichier preconisees
- - formats : qui donne une liste de formats de sortie supportes
- """
-
- # Les extensions de fichier preconisees
- extensions = (".py",)
- # Les formats de sortie supportes (eval dict ou exec)
- # Le format exec est du python executable (commande exec) converti avec PARSEUR_PYTHON
- # Le format execnoparseur est du python executable (commande exec) non converti
- formats = ("exec", "execnoparseur")
-
- def __init__(self, cr=None):
- # Si l'objet compte-rendu n'est pas fourni, on utilise le
- # compte-rendu standard
- self.text = ""
- if cr:
- self.cr = cr
- else:
- self.cr = N_CR.CR(
- debut="CR convertisseur format python", fin="fin CR format python"
- )
-
- def readfile(self, filename):
- self.filename = filename
- try:
- with open(filename) as fd:
- self.text = fd.read()
- except:
- self.cr.exception(tr("Impossible d'ouvrir le fichier %s", str(filename)))
- self.cr.fatal(tr("Impossible d'ouvrir le fichier %s", str(filename)))
- return
-
- def convert(self, outformat, appliEficas=None):
- if outformat == "exec":
- try:
- # import cProfile, pstats, StringIO
- # pr = cProfile.Profile()
- # pr.enable()
- l = PARSEUR_PYTHON(self.text).getTexte(appliEficas)
-
- # pr.disable()
- # s = StringIO.StringIO()
- # sortby = 'cumulative'
- # ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
- # ps.print_stats()
- # print (s.getValue())
-
- return l
- except EficasException:
- # Erreur lors de la conversion
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- self.cr.exception(
- tr(
- "Impossible de convertir le fichier Python qui doit contenir des erreurs.\n\
- On retourne le fichier non converti. Prevenir la maintenance.\n\n %s",
- "".join(l),
- )
- )
- # On retourne neanmoins le source initial non converti (au cas ou)
- return self.text
- elif outformat == "execnoparseur":
- return self.text
- else:
- raise EficasException(tr("Format de sortie : %s, non supporte", outformat))
- return None
+++ /dev/null
-tables.py:tables.tag
- python Translate.py -force tables.tag
+++ /dev/null
-Pour mettre à jour le parser de fichier au format Asterv5, il faut
-recompiler le fichier tables.tag en faisant :
- make
+++ /dev/null
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-#!/bin/env python -d
-#!/tools/net/app/Python-1.5.2/bin/python1.5
-
-"""Translate - a first attempt at parsing my little language
-
-Usage: Translate [switches] <infile> [<outfile>]
-
- -stdout -- write to standard output instead of a file
- -force -- write to the <outfile> even if it already
- exists (overwrite any existing file)
-
- -import -- import tag table from Translate_tags.py,
- instead of using the internal table
-
- -compare -- compare the imported and internal tag tables
- (development option!)
-
- -test -- use our internal test data and write to stdout
- -pytag -- use the interpreted tagging engine
- -debug -- if -pytag, enable its debugger
- -diag -- enable general debugging
- Beware that this currently also writes line
- numbers to the start of each line in the output,
- so it doesn't emit legal Python...
-
- -help -- show this text
- -history -- show the module history
- -version -- show the module version
-
-If <outfile> is not specified, <infile> will be used with its extension
-replaced by ".py".
-"""
-
-__author__ = """Tibs (Tony J Ibbs)
-tony@lsl.co.uk or tibs@tibsnjoan.demon.co.uk or tibs@bigfoot.com
-http://www.tibsnjoan.demon.co.uk/
-"""
-__version__ = "0.3 (tiepin) of 1999-11-15"
-__history__ = """\
-Originally created 1999-08-13
-
-First released version is 0.2 (bootstrap)/1999-09-09, which gave
-an idea of how the thing would work, and nearly did.
-
-Second released version is 0.3 (tiepin)/1999-11-15, which is sufficient
-to allow the parser used within this utility to be written in the little
-language, translated and then used as such.
-"""
-
-import sys
-import os
-import string
-
-# ............................................................
-# How we want to work things - this is fudge for me in initial development
-if os.name == "posix":
- # Unix at work
- DEFAULT_DEBUG = 0
- DEFAULT_PYTAG = 0
-else:
- # Windows 95 at home
- TEXTTOOLS_PATH = "C:\\Program Files\\Python"
- PYTAG_PATH = "C:\\Program Files\\Python\\TextTools\\Examples"
- DEFAULT_DEBUG = 0
- DEFAULT_PYTAG = 0
-
- if TEXTTOOLS_PATH not in sys.path:
- print "Adding",TEXTTOOLS_PATH
- sys.path.append(TEXTTOOLS_PATH)
-
- if PYTAG_PATH not in sys.path:
- print "Adding",PYTAG_PATH
- sys.path.append(PYTAG_PATH)
-# ............................................................
-
-# Import the TextTools themselves
-# - I'm not personally too keen on import *, but it seems to be
-# the recommended thing, so I'll leave it for now...
-try:
- from TextTools import *
-except:
- from mx.TextTools import *
- #from TextTools.Constants.TagTables import *
- #from TextTools.Constants.Sets import *
-
-\f
-# ------------------------------------------------------------
-# Useful little constants for unpicking the parsed tuples
-OBJECT = 0
-LEFT = 1
-RIGHT = 2
-SUBLIST = 3
-
-# We want to align inline comments when possible - so this is
-# the column at which we will try to place their "#" marks...
-COMMENT_COLUMN = 40
-
-# Are we (generally) debugging?
-DEBUGGING = 0
-
-# Do we want a comma after the last tuple (or item) in a table?
-WANT_LAST_COMMA = 1
-
-\f
-# ------------------------------------------------------------
-def define_tagtable():
- """Returns our tag table, if we're not importing it."""
-
- # We are not, initially, going to try for anything very sophisticated
- # - just something that will get us bootstrapped, so that I can use the
- # "little language" to write more sophisticated stuff (without having
- # to worry about dropped commas between tuples, and so on!)
-
-
- # Whitespace is always useful
- t_whitespace = (None,AllIn,' \t')
- t_opt_whitespace = t_whitespace + (+1,)
-
- # Comments are fairly simple
- t_comment = ('comment',Table,
- ((None,Is,'#'),
- (None,AllNotIn,'\n\r',MatchOk))
- )
-
- # We care about the "content" of the indentation at the start of a line,
- # but note that it is optional
- t_indent = ('indent',AllIn,' \t')
- t_indentation = t_indent + (+1,) # zero indentation doesn't show
-
- # A string is text within single or double quotes
- # (of course, this is an oversimplification, because we should also
- # deal with things like "This is a \"substring\"", and it would be
- # nice to be able to cope with triple-quoted strings too, but it
- # will do for a start)
-
- # Major bug - doesn't recognised zero length strings...
- # (since "AllNotIn" must match at least one character)
- t_string = ('str',Table,
- ((None,Is,"'",+3,+1),
- ('text',AllNotIn,"'"),
- (None,Is,"'",MatchFail,MatchOk),
- (None,Is,'"'),
- ('text',AllNotIn,'"'),
- (None,Is,'"'),
- ))
-
- # An integer is a series of digits...
- t_integer = ('int',AllIn,number)
-
- t_signed_integer = ('signed_int',Table,
- (('sign',Is,"+",+1,+2),
- ('sign',Is,"-",+1,+1),
- t_integer
- ))
-
- # Remember to be careful to specify the LONGEST possible match first,
- # so that we try for "IsIn" before we try for "Is" (because "IsIn"
- # would *match* "Is", leaving us with a spurious "In" hanging around...)
- t_operation = ('op',Table,
- (('op',Word,"AllInSet", +1,MatchOk),
- ('op',Word,"AllIn", +1,MatchOk),
- ('op',Word,"AllNotIn", +1,MatchOk),
- ('op',Word,"CallArg", +1,MatchOk),
- ('op',Word,"Call", +1,MatchOk),
- ('op',Word,"EOF", +1,MatchOk),
- ('op',Word,"Fail", +1,MatchOk),
- ('op',Word,"IsInSet", +1,MatchOk),
- ('op',Word,"IsIn", +1,MatchOk),
- ('op',Word,"IsNotIn", +1,MatchOk),
- ('op',Word,"IsNot", +1,MatchOk),
- ('op',Word,"Is", +1,MatchOk),
- ('op',Word,"Jump", +1,MatchOk),
- ('op',Word,"LoopControl",+1,MatchOk),
- ('op',Word,"Loop", +1,MatchOk),
- ('op',Word,"Move", +1,MatchOk),
- ('op',Word,"NoWord", +1,MatchOk), # alias for WordStart
- ('op',Word,"Skip", +1,MatchOk),
- ('op',Word,"SubTableInList",+1,MatchOk),
- ('op',Word,"SubTable", +1,MatchOk),
- ('op',Word,"sFindWord", +1,MatchOk),
- ('op',Word,"sWordStart", +1,MatchOk),
- ('op',Word,"sWordEnd", +1,MatchOk),
- ('op',Word,"TableInList",+1,MatchOk),
- ('op',Word,"Table", +1,MatchOk),
- ('op',Word,"WordStart", +1,MatchOk),
- ('op',Word,"WordEnd", +1,MatchOk),
- ('op',Word,"Word", MatchFail,MatchOk),
- ))
-
- # Python keywords
- t_keyword = ('keyword',Table,
- ((None,Word,"and", +1,+28),
- (None,Word,"assert", +1,+27),
- (None,Word,"break", +1,+26),
- (None,Word,"class", +1,+25),
- (None,Word,"continue",+1,+24),
- (None,Word,"def", +1,+23),
- (None,Word,"del", +1,+22),
- (None,Word,"elif", +1,+21),
- (None,Word,"else", +1,+20),
- (None,Word,"except", +1,+19),
- (None,Word,"exec", +1,+18),
- (None,Word,"finally", +1,+17),
- (None,Word,"for", +1,+16),
- (None,Word,"from", +1,+15),
- (None,Word,"global", +1,+14),
- (None,Word,"if", +1,+13),
- (None,Word,"import", +1,+12),
- (None,Word,"in", +1,+11),
- (None,Word,"is", +1,+10),
- (None,Word,"lambda", +1,+9),
- (None,Word,"not", +1,+8),
- (None,Word,"or", +1,+7),
- (None,Word,"pass", +1,+6),
- (None,Word,"print", +1,+5),
- (None,Word,"raise", +1,+4),
- (None,Word,"return", +1,+3),
- (None,Word,"try", +1,+2),
- (None,Word,"while", MatchFail,+1),
- # In order to not recognise things like "in_THIS_CASE"
- # we must check that the next character is not legitimate
- # within an identifier
- (None,IsIn,alpha+'_'+number,+1,MatchFail),
- # If it wasn't another identifier character, we need to
- # unread it so that it can be recognised as something else
- # (so that, for instance, "else:" is seen as "else" followed
- # by ":")
- (None,Skip,-1)
- ))
-
- # Do the same for mxText commands
- t_mxkeyword = ('mxKeyword',Table,
- (t_operation,
- (None,IsIn,alpha+'_'+number,+1,MatchFail),
- (None,Skip,-1)
- ))
-
- # Traditional identifiers
- t_identifier = ('identifier',Table,
- (t_keyword + (+1,MatchFail), # don't allow Python keywords
- t_mxkeyword + (+1,MatchFail), # don't allow mxText commands
- (None,IsIn,alpha+'_'), # can't start with a digit
- (None,AllIn,alpha+'_'+number,MatchOk))
- )
-
- # We don't yet deal with the following with anything in parentheses,
- # which means we can't handle functions or command lists, or other
- # things which "look like" a tuple
- t_argument = ('arg',Table,
- (('arg',Word,"Here", +1,MatchOk), # EOF Here, Fail Here
- ('arg',Word,"ToEOF", +1,MatchOk), # Move ToEOF
- ('arg',Word,"To", +1,MatchOk), # Jump To
- ('arg',Word,"ThisTable",+1,MatchOk), # [Sub]Table ThisTable
- ('arg',Word,"back", +1,MatchOk), # Skip back
- ('arg',Word,"Break", +1,MatchOk), # LoopControl Break
- ('arg',Word,"Reset", +1,MatchOk), # LoopControl Reset
- t_string + (+1,MatchOk), # e.g., Word "Fred"
- t_signed_integer + (+1,MatchOk), # e.g., Skip -4, Move 3
- t_identifier # e.g., Table Fred
- ))
-
- t_plus = ('plus',Table,
- (t_opt_whitespace,
- (None,Is,"+"),
- t_opt_whitespace
- ))
-
- # Arguments can contain "+"
- t_plus_arg = ('plusarg',Table,
- (t_argument, # start with a single argument
- t_plus + (MatchOk,), # if we have a "+"
- t_argument, # then we expect another argument
- (None,Jump,To,-2), # then look for another "+"
- ))
-
- # Match, for example:
- # <fred>
- t_label = ('label',Table,
- ((None,Is,"<"),
- t_identifier,
- (None,Is,">")
- ))
-
- # Targets for Jump and F:/T:
- t_target = ('target',Table,
- (('tgt',Word,"next", +1,MatchOk),
- ('tgt',Word,"previous", +1,MatchOk),
- ('tgt',Word,"repeat", +1,MatchOk),
- ('tgt',Word,"MatchOk", +1,MatchOk),
- ('tgt',Word,"MatchOK", +1,MatchOk), # For kindness sake
- ('tgt',Word,"MatchFail",+1,MatchOk),
- t_label
- ))
-
- # A value is either an identifier, or a string, or an integer
- t_value = ('val',Table,
- (t_identifier +(+1,MatchOk),
- t_string +(+1,MatchOk),
- t_integer
- ))
-
- # An assignment is (optionally) used in Tuple and Table definitions...
- t_assignment = ('assignment',Table,
- (t_value,
- t_opt_whitespace,
- (None,Is,'='),
- ))
-
- # A common error when writing tuples is to miss off the "=" sign
- # - the following is used in diagnosing that (see t_bad_tuple below)
- # (it's useful to have something with identical structure to the
- # "real thing")
- t_bad_tagobj = ('tagobj',Table,
- (t_string,
- ))
-
- t_bad_assignment = ('assignment',Table,
- (t_value,
- ))
-
- # This is the line that starts the definition of a single tuple.
- # For the moment, restrict what it gets assigned to to a simple identifier.
- # Match, for example:
- # Fred is:
- t_tupleblock = ('tupleblock',Table,
- (t_identifier,
- t_whitespace,
- (None,Word,"is:")
- ))
-
- # This is the line that starts a new table or sub-table.
- # For the moment, we only cope with full Tables.
- # NOTE that this is used for the "outer" declaration of a tag table,
- # and also for the "inner" declaration of an inner table or sub-table.
- # The discrimination between these is done after initial parsing.
- # Match, for example:
- # 'keyword' = Table is: (inner)
- # tagtable = Table is: (outer)
- t_tableblock = ('tableblock',Table,
- (t_assignment + (+2,+1), # left hand side is optional
- t_opt_whitespace,
- ('type',Word,"Table",+1,+2), # Either "Table"
- ('type',Word,"SubTable"), # or "SubTable" is required
- t_whitespace, # whitespace is required
- (None,Word,"is:") # "is:" is required
- ))
-
- # This is the line that starts an "if" block
- # Match, for example:
- # Is "Fred":
- # controlsymbol:
- t_ifblock = ('ifblock',Table,
- (t_assignment + (+2,+1), # left hand side is optional
- t_opt_whitespace,
- t_operation + (+4,+1),
- t_whitespace,
- t_plus_arg,
- (None,Is,":",MatchFail,MatchOk),
- t_identifier,
- (None,Is,":")
- ))
-
- # Note that we don't allow spaces WITHIN our false and true thingies
-
- t_onfalse = ('onfalse',Table,
- (t_whitespace,
- (None,Word,"F:"),
- t_target
- ))
-
- t_ontrue = ('ontrue',Table,
- (t_whitespace,
- (None,Word,"T:"),
- t_target
- ))
-
- # Valid examples are things like:
- # 'fred' = Is "xxx" F:<wow> T:MatchOk
- # AllIn jim T:<foundJim>
- #
- # For the moment, we're not trying to recognise things in any detail
- t_tuple = ('tuple',Table,
- (t_assignment + (+2,+1), # left hand side is optional
- t_opt_whitespace,
- t_operation, # operation is required
- t_whitespace, # for the moment, we always require space here
- t_plus_arg, # argument is required
- t_onfalse + (+1,+1), # F:target is optional
- t_ontrue + (MatchOk,MatchOk) # T:target is also optional
- ))
-
- # If the user has defined a "partial" tuple, they might use something
- # of the form:
- # match_fred F:MatchFalse T:MatchOk
- t_tupleplus = ('tupleplus',Table,
- (t_identifier,
- t_onfalse + (+1,+1), # F:target is optional
- t_ontrue + (MatchOk,MatchOk) # T:target is also optional
- ))
-
- # Treat Jump To specially - for example:
- # Jump To <top>
- # so that they don't have to do the less obvious "Jump To F:<label>"
- # (although that will still be recognised, of course, for people who
- # are used to the tag tuple format itself)
- t_jumpto = ('jumpto',Table,
- ((None,Word,"Jump"),
- t_whitespace,
- (None,Word,"To"),
- t_whitespace,
- t_target
- ))
-
- # Is it worth coping with these?
- t_bad_jumpto = ('jumpto',Table,
- ((None,Word,"Jump",+2), # cope with Jump to
- (None,Word,"to",MatchFail,+2),
- (None,Word,"JumpTo"), # and with JumpTo
- t_target
- ))
-
- # The "content" of a line is the bit after any indentation, and before
- # any comment...
- # For the moment, we won't try to maintain ANY context, so it is up to the
- # user of the tuples produced to see if they make sense...
- t_content = ('content',Table,
- (t_label + (+1,MatchOk),
- t_tableblock + (+1,MatchOk), # [<value> =] [Sub]Table is:
- t_tupleblock + (+1,MatchOk), # <identifier> is:
- t_ifblock + (+1,MatchOk), # <cmd> <arg>: OR <identifier>:
- t_jumpto + (+1,MatchOk), # Jump To <target>
- t_tuple + (+1,MatchOk),
- t_tupleplus + (+1,MatchOk), # name [F:<label> [T:<label>]]
- ))
-
- t_contentline = ('contentline',Table,
- (t_content, # something that we care about
- t_opt_whitespace,
- t_comment +(+1,+1), # always allow a comment
- (None,IsIn,newline) # the end of the line
- ))
-
- # Sometimes, the user (e.g., me) writes:
- # 'fred' = Table:
- # instead of:
- # 'fred' = Table is:
- # Unfortunately, without the "is", it would get too confusing whether
- # we actually wanted an if block...
- t_bad_tableblock = ('tableblock',Table,
- (t_assignment + (+2,+1), # left hand side is optional
- t_opt_whitespace,
- (None,Word,"Table"), # "Table" is required
- (None,Is,":") # "is" is needed before the ":"
- ))
-
- # Sometimes, the use (e.g., me again) write:
- # 'fred' IsIn jim
- # instead of:
- # 'fred' = IsIn jim
- # Whilst I'm not entirely convinced that "=" is the best character
- # to use here, I think we do need something!
- t_bad_tuple = ('tuple',Table,
- (t_bad_assignment, # obviously we have to have this!
- t_whitespace, # in which case the whitespace IS needed
- t_operation, # operation is required
- t_whitespace, # for the moment, we must have space here
- t_plus_arg, # argument is required
- t_onfalse + (+1,+1), # F:target is optional
- t_ontrue + (MatchOk,MatchOk) # T:target is also optional
- ))
-
- # Make some attempt to recognise common errors...
- t_badcontent = ('badcontent',Table,
- (t_bad_tableblock +(+1,MatchOk),
- t_bad_tuple
- ))
-
- t_badline = ('badline',Table,
- (t_badcontent, # something that we sort of care about
- t_opt_whitespace,
- t_comment +(+1,+1), # always allow a comment
- (None,IsIn,newline) # the end of the line
- ))
-
- t_emptyline = ('emptyline',Table,
- (t_opt_whitespace,
- (None,IsIn,newline) # the end of the line
- ))
-
- t_commentline = ('commentline',Table,
- (t_comment,
- (None,IsIn,newline) # the end of the line
- ))
-
- t_passthruline = ('passthruline',Table,
- (('passthru',AllNotIn,newline,+1), # owt else on the line
- (None,IsIn,newline) # the end of the line
- ))
-
- # Basically, a file is a series of lines
- t_line = ('line',Table,
- (t_emptyline +(+1,MatchOk), # empty lines are simple enough
- t_indent +(+1,+1), # optional indentation
- t_commentline +(+1,MatchOk), # always allow a comment
- t_contentline +(+1,MatchOk), # a line we care about
- t_badline +(+1,MatchOk), # a line we think is wrong
- t_passthruline # a line we don't care about
- ))
-
- t_file = (t_line,
- (None,EOF,Here,-1)
- )
-
- return t_file
-
-\f
-# ------------------------------------------------------------
-# We'll define some moderately interesting test data
-
-test_data = """\
-# This example isn't *meant* to make any sense!
-# It's just an accumulation of things that got checked for various reasons
-from TextTools import *
-# Some Python code
-a = b;
-fred = 3;
-if a == 1:
- print "a == 1"
-else:
- print "a != 1"
-
-# And the rest is our business...
-t_integer is:
- 'int' = AllIn '0123456789'
-t_integer is:
- 'int' = AllIn number
-t_indent is:
- # A comment here is OK
- <label> # Strangely enough, so is a label
- 'indent' = AllIn ' \t'
-t_buggy = Table is:
- 'int' AllIn number # BUGGY LINE (missing "=")
- (None,"AllIn",number) # BUGGY LINE (an actual tuple)
- fred = jim # BUGGY LINE (not our business)
- tagobj F:<op> T:next # label <op> is undefined
- # The next line is totally empty
-
- # The next line contains just indentation
-
- # This line is just a comment
-# And this comment should be JUST after the preceding block...
-t_indentation is: # This should be "= Table is:"
- t_indent
- t_indent F:previous
- t_indent T:previous
- t_indent F:previous T:previous
-t_deep = Table is:
- 'a' = SubTable is:
- SubTable is:
- 'this' = Table ThisTable
- t_integer
-t_fred = Table is:
- <top>
- AllIn 'a'
- 'a' = AllIn 'a'
- 'a' = AllIn 'a' F:previous
- 'a' = AllIn 'a' T:previous
- 'a' = AllIn 'a' F:previous T:previous
- AllIn 'abcd':
- AllIn 'xyz' F:<later> T:<top>
- 'a' = AllIn 'abcd':
- AllIn 'xyz'
- <later>
- t_indent:
- AllIn 'xyz'
- AllIn number + '_'
- AllIn number+"_"+alpha
- Jump To <top>
-"""
-
-\f
-# ------------------------------------------------------------
-# Our own exceptions
-
-class OutsideError(Exception):
- """The entity is not permitted outside a block."""
- pass
-
-class IndentError(Exception):
- """An indentation error has been detected."""
- pass
-
-class NoIdentifier(Exception):
- """We're missing an identifier (to assign to)."""
- pass
-
-\f
-# ------------------------------------------------------------
-def LineFactory(lineno,tagtuple,text):
- """Take some tagged data and return an appropriate line class.
-
- lineno -- the line number in the "file". Note that the first line
- in the file is line 1
- tagtuple -- a tag tuple for a single line of data
- text -- the text for the "file". All the "left" and "right" offsets
- are relative to this text (i.e., it is the entire content
- of the file)
-
- The tag tuples we get back from the parser will be of the form:
-
- ('line',left,right,[
- ('indent',left,right,None), -- this is optional
- ('content',left,right,[<data>])
- ])
-
- Looking at <type> should enable us to decide what to do with
- the <data>.
- """
-
- # Extract the list of tuples from this 'line'
- tuples = tagtuple[SUBLIST]
-
- # First off, do we have any indentation?
- tup = tuples[0]
- if tup[OBJECT] == "indent":
- # This is inefficient, because it actually copies strings
- # around - better would be to duplicate the calculation
- # that string.expandtabs does internally...
- indent_str = string.expandtabs(text[tup[LEFT]:tup[RIGHT]])
- tuples = tuples[1:]
- else:
- indent_str = ""
- tuples = tuples
-
- # Now, work out which class we want an instance of
- # (this is the 'fun' bit)
-
- type = tuples[0][OBJECT]
- if type == 'emptyline':
- return EmptyLine(lineno,indent_str,tuples[0],text)
- elif type == 'commentline':
- return CommentLine(lineno,indent_str,tuples[0],text)
- elif type == 'passthruline':
- return PassThruLine(lineno,indent_str,tuples[0],text)
- elif type == 'contentline':
- # OK - we need to go down another level
- sublist = tuples[0][SUBLIST]
-
- # Do we also have an in-line comment?
- if len(sublist) > 1:
- comment = sublist[1]
- else:
- comment = None
-
- # And the actual DATA for our line is down yet another level...
- sublist = sublist[0][SUBLIST]
- type = sublist[0][OBJECT]
- if type == 'label':
- return LabelLine(lineno,indent_str,sublist[0],comment,text)
- elif type == 'tableblock':
- return TableBlockLine(lineno,indent_str,sublist[0],comment,text)
- elif type == 'tupleblock':
- return TupleBlockLine(lineno,indent_str,sublist[0],comment,text)
- elif type == 'ifblock':
- return IfBlockLine(lineno,indent_str,sublist[0],comment,text)
- elif type == 'tuple':
- return TupleLine(lineno,indent_str,sublist[0],comment,text)
- elif type == 'tupleplus':
- return TuplePlusLine(lineno,indent_str,sublist[0],comment,text)
- elif type == 'jumpto':
- return JumpToLine(lineno,indent_str,sublist[0],comment,text)
- else:
- raise ValueError,\
- "Line %d is of unexpected type 'contentline/%s'"%(lineno,
- type)
- elif type == 'badline':
- # OK - we need to go down another level
- sublist = tuples[0][SUBLIST]
-
- # Do we also have an in-line comment?
- if len(sublist) > 1:
- comment = sublist[1]
- else:
- comment = None
-
- # And the actual DATA for our line is down yet another level...
- sublist = sublist[0][SUBLIST]
- type = sublist[0][OBJECT]
- if type == 'tableblock':
- return BadTableBlockLine(lineno,indent_str,sublist[0],comment,text)
- if type == 'tuple':
- return BadTupleLine(lineno,indent_str,sublist[0],comment,text)
- else:
- raise ValueError,\
- "Line %d is of unexpected type 'badline/%s'"%(lineno,type)
- else:
- raise ValueError,"Line %d is of unexpected type '%s'"%(lineno,type)
-
-
-\f
-# ------------------------------------------------------------
-class BaseLine:
- """The base class on which the various line types depend
-
- Contains:
-
- tagtuple -- the tagtuple we (our subclass instance) represent(s)
- lineno -- the line number in the file (first line is line 1)
- indent -- our indentation (integer)
- indent_str -- our indentation (a string of spaces)
- text -- the text of the "file" we're within
- class_name -- the name of the actual class this instance belongs to
- (i.e., the name of the subclass, suitable for printing)
-
- Some things only get useful values after we've been instantiated
-
- next_indent -- the indentation of the next line
- index -- for a line in a block, its index therein
- """
-
- def __init__(self,lineno,indent_str,tagtuple,text):
- """Instantiate a BaseLine.
-
- lineno -- the line number in the "file". Note that the first line
- in the file is line 1
- indent_str -- the indentation of the line (a string of spaces)
- tagtuple -- the tag tuple for this line of data
- text -- the text for the "file". All the "left" and "right"
- offsets are relative to this text (i.e., it is the
- entire content of the file)
-
- The content of the tagtuple depends on which of our subclasses
- is being used. Refer to the relevant doc string.
- """
-
- self.tagtuple = tagtuple
- self.lineno = lineno
- self.text = text
-
- self.class_name = self._class_name()
- self.indent_str = indent_str
- self.indent = len(indent_str)
-
- # OK - we don't really know! (but this will do for "EOF")
- self.next_indent = 0
-
- # We don't always HAVE a sensible value for this
- self.index = None
-
- #if DEBUGGING:
- # print "Line %3d: %s%s"%(lineno,indent_str,self.class_name)
-
- def change_indent(self,count=None,spaces=""):
- """Change our indentation.
-
- Specify either "count" or "spaces" (if both are given,
- "count" will be used, if neither is given, then the
- indentation will be set to zero)
-
- count -- the number of spaces we're indented by
- spaces -- a string of spaces
- """
- if count:
- self.indent = count
- self.indent_str = count * " "
- else:
- self.indent_str = spaces
- self.indent = len(spaces)
-
- def _class_name(self):
- """Return a representation of the class name."""
-
- full_name = "%s"%self.__class__
- bits = string.split(full_name,".")
- return bits[-1]
-
- def starts_block(self):
- """Return true if we start a new block."""
- return 0
-
- def only_in_block(self):
- """Return true if we can only occur inside a block."""
- return 0
-
- def our_business(self):
- """Return true if we are a line we understand."""
- return 1
-
- def __str__(self):
- return "%3d %s%-10s"%(self.lineno,self.indent_str,self.class_name)
-
- def _intro(self):
- """Returns a useful 'introductory' string."""
- return "%3d %-10s %s"%(self.lineno,self.class_name,self.indent_str)
-
- def _trunc(self):
- """Returns a "truncated" representation of our text."""
-
- text = "%s %s"%(self._intro(),
- `self.text[self.tagtuple[LEFT]:self.tagtuple[RIGHT]]`)
-
- if len(text) > 60:
- return text[:60]+"..."
- else:
- return text
-
- def resolve_labels(self,block):
- """Called to resolve any labels use in this line.
-
- block -- the block that contains us
- """
- # The default is to do nothing as we don't HAVE any labels...
- return
-
- def expand(self,stream,block=None):
- """Write out the expanded equivalent of ourselves.
-
- stream -- an object with a "write" method, e.g., a file
- newline -- true if we should output a terminating newline
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
- """
-
- if DEBUGGING:
- stream.write("Line %3d: "%self.lineno)
-
- stream.write(self.indent_str)
- stream.write(self.text[self.tagtuple[LEFT]:self.tagtuple[RIGHT]])
- stream.write(",\n")
-
- def warning(self,text):
- """Report a warning message.
-
- text -- the text to report
- """
-
- lines = string.split(text,"\n")
- print "###WARNING: line %d (%s)"%(self.lineno,self.class_name)
- for line in lines:
- print "### %s"%line
-
- def error(self,text):
- """Report an error.
-
- text -- the error text to report
- """
-
- lines = string.split(text,"\n")
- print "###ERROR: line %d (%s)"%(self.lineno,self.class_name)
- for line in lines:
- print "### %s"%line
-
-\f
-# ------------------------------------------------------------
-class EmptyLine(BaseLine):
- """An empty line.
-
- Note that the indentation of an empty line is taken to be the
- same as that of the next (non-empty) line. This is because it
- seems to me that (a) an empty line should not per-se close a
- block (which it would do if it had indentation 0) and (b) we
- don't remember any whitespace in an empty line, so the user
- can't assign an indentation themselves (which is a Good Thing!)
- """
-
- def __init__(self,lineno,indent_str,tagtuple,text):
- """Instantiate an EmptyLine.
-
- The content of the tagtuple is:
- None
- """
-
- BaseLine.__init__(self,lineno,indent_str,tagtuple,text)
-
- def expand(self,stream,block=None):
- """Write out the expanded equivalent of ourselves.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
- """
-
- if DEBUGGING:
- stream.write("Line %3d: "%self.lineno)
-
- # um - there's nothing to do, folks
- stream.write("\n")
-
- def our_business(self):
- """Return true if we are a line we understand."""
- return 0
-
- def _trunc(self):
- """Returns a "truncated" representation of our text."""
-
- return self._intro()
-
-\f
-# ------------------------------------------------------------
-class CommentLine(BaseLine):
- """A comment line."""
-
- def __init__(self,lineno,indent_str,tagtuple,text):
- """Instantiate a CommentLine.
-
- The content of the tagtuple is:
- ('comment',left,right,None)
- and the demarcated text includes the initial '#' character
- """
-
- BaseLine.__init__(self,lineno,indent_str,tagtuple,text)
-
- # We actually want the next tuple down (so to speak) so that
- # we lose the trailing newline...
- tup = self.tagtuple[SUBLIST][0]
- self.data = self.text[tup[LEFT]:tup[RIGHT]]
-
- def our_business(self):
- """Return true if we are a line we understand."""
- return 0
-
- def expand(self,stream,block=None):
- """Write out the expanded equivalent of ourselves.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
- """
-
- if DEBUGGING:
- stream.write("Line %3d: "%self.lineno)
-
- stream.write(self.indent_str)
- stream.write("%s\n"%self.data)
-
-\f
-# ------------------------------------------------------------
-class PassThruLine(BaseLine):
- """A line we just pass throught without interpretation."""
-
- def __init__(self,lineno,indent_str,tagtuple,text):
- """Instantiate a PassThruLine.
-
- The content of the tagtuple is:
- ('passthru',left,right,None)
- """
-
- BaseLine.__init__(self,lineno,indent_str,tagtuple,text)
-
- # We actually want the next tuple down (so to speak) so that
- # we lose the trailing newline...
- tup = self.tagtuple[SUBLIST][0]
- self.data = self.text[tup[LEFT]:tup[RIGHT]]
-
- def our_business(self):
- """Return true if we are a line we understand."""
- return 0
-
- def expand(self,stream,block=None):
- """Write out the expanded equivalent of ourselves.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
- """
-
- if DEBUGGING:
- stream.write("Line %3d: "%self.lineno)
-
- if block:
- err_str = "Unparsed line inside a block"\
- " - it has been commented out"
- # Hmm - the following advice is less often useful than I
- # had hoped - leave it out for now...
- #if string.find(self.data,",") != -1:
- # err_str = err_str + "\nCheck for a trailing comma?"
-
- self.error(err_str)
-
- # Always output the indentation, 'cos otherwise it looks silly
- stream.write(self.indent_str)
-
- if block:
- stream.write("#[ignored]#")
-
- stream.write("%s\n"%self.data)
-
-\f
-# ------------------------------------------------------------
-class ContentLine(BaseLine):
- """A line we have to interpret - another base class.
-
- Adds the following variables:
-
- comment -- any in-line comment on this line
- """
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate a ContentLine.
-
- comment -- either a comment tuple or None
-
- The content of the tagtuple is:
- ('contentline',left,right,
- [('content',left,right,[<data>]),
- ('comment',left,right,None) -- optional
- ])
- where <data> is used in the internals of one of our subclasses
- (i.e., it is what is passed down in the "tagtuple" argument)
- """
-
- BaseLine.__init__(self,lineno,indent_str,tagtuple,text)
- self.comment = comment
-
- # Assume we're not the last "our business" line in a block...
- self.is_last = 0
-
- def _write_comment(self,stream,sofar):
- """Write out the in-line comment string.
-
- Since we're the only people to call this, we can safely
- rely on it only being called when there IS a comment tuple
- to output...
-
- stream -- an object with a "write" method, e.g., a file
- sofar -- the number of characters written to the line
- so far
- """
- if sofar < COMMENT_COLUMN:
- stream.write(" "*(COMMENT_COLUMN - sofar))
- else:
- # always write at least one space...
- stream.write(" ")
- stream.write(self.text[self.comment[LEFT]:self.comment[RIGHT]])
-
- def _write_text(self,stream,block):
- """Write out the main tuple text.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
-
- This should generally be the method that subclasses override.
- It returns the number of characters written, or -1 if we had
- an error.
- """
- stream.write(self.text[self.tagtuple[LEFT]:self.tagtuple[RIGHT]])
- return self.tagtuple[RIGHT] - self.tagtuple[LEFT]
-
- def expand(self,stream,block=None):
- """Write out the expanded equivalent of ourselves.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
- """
-
- if DEBUGGING:
- stream.write("Line %3d: "%self.lineno)
-
- stream.write(self.indent_str)
- nchars = self._write_text(stream,block)
- # Don't write any in-line comment out if we had an error,
- # as the layout won't work!
- if nchars > -1 and self.comment:
- self._write_comment(stream,sofar=nchars+self.indent)
- stream.write("\n")
-
-\f
-# ------------------------------------------------------------
-class LabelLine(ContentLine):
- """A line containing a label.
-
- Contains:
- label -- our label string
- """
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate a LabelLine.
-
- For instance:
-
- <fred>
-
- The content of the tagtuple is:
-
- ('label',left,right,[
- ('identifier',left,right,None)
- ])
- """
-
- ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
-
- self.label = self.text[self.tagtuple[LEFT]:self.tagtuple[RIGHT]]
-
- def _write_text(self,stream,block):
- """Write out the main tuple text.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
- """
- # Enough difficult length calculation - let's do this one
- # the easy way...
- if DEBUGGING:
- text = "# Label %s at index %d"%(self.label,self.index)
- else:
- text = "# %s"%(self.label) # surely enough for most people...
- stream.write(text)
- return len(text)
-
- def translate(self,index,block):
- """Return the translation of a use of this label as a target.
-
- index -- the index of the line which uses the label as a target
- block -- the Block we are within
- """
-
- # Hmm - I don't think this CAN go wrong at this point...
- return block.translate_label(self.label,self)
-
- def only_in_block(self):
- """Return true if we can only occur inside a block."""
- return 1
-
-\f
-# ------------------------------------------------------------
-class TableBlockLine(ContentLine):
- """A line starting a table block."""
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate a TableBlockLine.
-
- For instance:
-
- "fred" = Table is:
- Table is:
-
- This is used for two purposes:
- 1. To define the actual tag table itself (i.e., at the outer
- level). Only "Table" is allowed in this instance, but since
- that is all we recognised for now, we shan't worry about it...
- 2. To define an inner table (i.e., at an inner level)
-
- The content of the tagtuple is:
-
- ('tableblock',left,right,[
- ('assignment',left,right,[ -- optional if inner
- ('val',left,right,[
-
- ('identifier',left,right,[])
- OR
- ('str',left,right,[
- ('text',left,right,None)
- ])
- OR
- ('int',left,right,[])
-
- ])
- ])
- ('type',left,right,[]) -- either "Table" or "SubTable"
- ])
-
- NOTE: as an "emergency" measure (so we can `pretend' that a
- TupleBlock was actually a TableBlock as part of attempted
- error correction), if tagtuple == ("error",tagobj) then we
- short-circuit some of the initialisation...
- """
-
- ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
-
- if tagtuple[0] == "error":
- # We're "bluffing" at the creation of a TableBlock
- self.tagobj = tagtuple[1]
- self.is_subtable = 0
- elif len(self.tagtuple[SUBLIST]) == 1:
- self.tagobj = "None"
- tup = self.tagtuple[SUBLIST][0]
- self.is_subtable = (self.text[tup[LEFT]:tup[RIGHT]] == "SubTable")
- else:
- # The first tuple down gives us the "<value> = " string
- tup = self.tagtuple[SUBLIST][0]
- # The next tuple down gives us "<value>" which is what we want
- tup = tup[SUBLIST][0]
- self.tagobj = self.text[tup[LEFT]:tup[RIGHT]]
- # Then we have the type of table
- tup = self.tagtuple[SUBLIST][1]
- self.is_subtable = (self.text[tup[LEFT]:tup[RIGHT]] == "SubTable")
-
- def got_tagobj(self):
- return (self.tagobj != "None")
-
- def starts_block(self):
- """Return true if we start a new block."""
- return 1
-
- def _write_text(self,stream,block):
- """Write out the main tuple text.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
-
- It returns the number of characters written, or -1 if we had
- an error.
- """
-
- if block:
- if self.is_subtable:
- stream.write("(%s,SubTable,("%self.tagobj)
- return len(self.tagobj) + 11
- else:
- stream.write("(%s,Table,("%self.tagobj)
- return len(self.tagobj) + 8
- else:
- stream.write("%s = ("%self.tagobj)
- return len(self.tagobj) + 4
-
-\f
-# ------------------------------------------------------------
-class TupleBlockLine(ContentLine):
- """A line starting a tuple block (i.e., defining a single tuple)
-
- Contains:
-
- name -- the "name" of this tuple (i.e., what comes
- before the "is:")
- """
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate a TupleBlockLine.
-
- For instance:
-
- Fred is:
-
- The content of the tagtuple is:
-
- ('tupleblock',left,right,[
- ('identifier',left,right,None)
- ])
- """
-
- ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
-
- tup = self.tagtuple[SUBLIST][0]
- self.name = self.text[tup[LEFT]:tup[RIGHT]]
-
- def starts_block(self):
- """Return true if we start a new block."""
- return 1
-
- def only_in_block(self):
- """Return true if we can only occur inside a block."""
- return 0
-
- def _write_text(self,stream,block):
- """Write out the main tuple text.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
-
- It returns the number of characters written, or -1 if we had
- an error.
- """
- # The "\" at the end is somewhat clumsy looking, but the
- # only obvious way of preserving layout...
- stream.write("%s = \\"%self.name)
- return len(self.name) + 5
-
-\f
-# ------------------------------------------------------------
-class IfBlockLine(ContentLine):
- """A line starting an if block.
-
- Contains:
- cmd -- the command within this if block
- arg -- the argument for said command
- or:
- name -- the name within this if block
- """
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate an IfBlockLine.
-
- For instance:
-
- 'jim' = Is "Fred":
- Is "Fred":
- fred:
-
- The content of the tagtuple is:
-
- ('ifblock',left,right,[
- ('assignment',left,right,[
- ('val',left,right,[
-
- ('identifier',left,right,[])
- OR
- ('str',left,right,[
- ('text',left,right,None)
- ])
- OR
- ('int',left,right,[])
-
- ])
- ])
- ('op',left,right,None),
- ('arg',left,right,None),
- ])
- or:
- ('ifblock',left,right,[
- ('op',left,right,None),
- ('arg',left,right,None),
- ])
- or:
- ('ifblock',left,right,[
- ('identifier',left,right,None)
- ])
- """
-
- ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
-
- tuples = self.tagtuple[SUBLIST]
- if tuples[0][OBJECT] == 'op':
- tup1 = tuples[0]
- tup2 = tuples[1]
- self.tagobj = "None"
- self.cmd = self.text[tup1[LEFT]:tup1[RIGHT]]
- self.arg = self.text[tup2[LEFT]:tup2[RIGHT]]
- self.name = None
- elif tuples[0][OBJECT] == 'assignment':
- # The "<value>" in the "<value> = " string is down
- # one level more than the others
- tup0 = tuples[0][SUBLIST][0]
- self.tagobj = self.text[tup0[LEFT]:tup0[RIGHT]]
- tup1 = tuples[1]
- tup2 = tuples[2]
- self.cmd = self.text[tup1[LEFT]:tup1[RIGHT]]
- self.arg = self.text[tup2[LEFT]:tup2[RIGHT]]
- self.name = None
- elif tuples[0][OBJECT] == 'identifier':
- tup = tuples[0]
- self.name = self.text[tup[LEFT]:tup[RIGHT]]
- self.cmd = None
- self.arg = None
- self.tagobj = None
- else:
- # Hmm - try to continue with anything unexpected
- tup = tuples[0]
- self.error("Unexpected IfBlock subtype %s"%tup[OBJECT])
- self.name = self.text[tup[LEFT]:tup[RIGHT]]
- self.cmd = None
- self.arg = None
- self.tagobj = None
-
- # Currently, we have one 'special' argument
- if self.arg == "back": self.arg = "-1"
-
- # We don't yet know the offset of the "virtual label" at the
- # end of this if block...
- self.end_label = None
-
- def starts_block(self):
- """Return true if we start a new block."""
- return 1
-
- def only_in_block(self):
- """Return true if we can only occur inside a block."""
- return 1
-
- def resolve_labels(self,block):
- """Called to resolve any labels used in this line.
-
- block -- the block that contains us
-
- Note that this only does something the first time it
- is called - this will be when the IF block's startline
- is asked to resolve its labels. If it is called again,
- as a 'normal' line, it will do nothing...
- """
- if not self.end_label:
- self.end_label = "%+d"%(len(block.business)+1)
-
- def _write_text(self,stream,block):
- """Write out the main tuple text.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
-
- It returns the number of characters written, or -1 if we had
- an error.
- """
- if not self.end_label:
- # This should never happen, but just in case, warn the user!
- self.error("Unable to determine 'onFalse' destination in IF")
-
- if self.name:
- stream.write("%s + (%s,+1),"%(self.name,
- self.end_label or "<undefined>"))
- return len(self.name) + 20
- else:
- stream.write("(%s,%s,%s,%s,+1),"%(self.tagobj,self.cmd,self.arg,
- self.end_label or "<undefined>"))
- return len(self.tagobj) + len(self.cmd) + len(self.arg) + \
- len(self.end_label) + 20
-
-\f
-# ------------------------------------------------------------
-class TupleLine(ContentLine):
- """A line containing a basic tuple.
-
-
- Contains:
- tagobj -- optional
- cmd -- the command
- arg -- the argument
- ontrue -- what to do if true
- onfalse -- ditto false
- """
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate a TupleLine.
-
- The content of the tagtuple is:
-
- ('tuple',left,right,[
- ('tagobj',left,right,[ -- optional
- ('str',left,right,[
- ('text',left,right,None)
- ])
- ])
- ('op',left,right,None),
- ('arg',left,right,None),
- ('onfalse',left,right,[ -- optional
- ('target',left,right,[
- ('tgt',left,right,None)
- ]),
- ('ontrue',left,right,[ -- optional
- ('target',left,right,[
- ('tgt',left,right,None)
- ])
- ])
- ])
- """
-
- ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
-
- self.unpack()
-
-
- def unpack(self):
- """Unpack our contents from our tagtuple."""
-
- # This is doubtless not the most efficient way of doing this,
- # but it IS relatively simple...
- dict = {}
- #for key in ("assignment","op","arg","onfalse","ontrue"):
- for key in ("assignment","op","plusarg","onfalse","ontrue"):
- dict[key] = None
-
- tuples = self.tagtuple[SUBLIST]
- for item in tuples:
- name = item[OBJECT]
- if name == "onfalse" or name == "ontrue" or name == "assignment":
- # For these, we need to go "down one level" for our data
- tup = item[SUBLIST][0]
- dict[name] = (tup[LEFT],tup[RIGHT])
- else:
- dict[name] = (item[LEFT],item[RIGHT])
-
- # The tag object is optional
- if dict["assignment"]:
- left,right = dict["assignment"]
- self.tagobj = self.text[left:right]
- else:
- self.tagobj = "None"
-
- # The operation (command) and argument are required
- left,right = dict["op"]
- self.cmd = self.text[left:right]
-
- #left,right = dict["arg"]
- left,right = dict["plusarg"]
- self.arg = self.text[left:right]
-
- # Currently, we have one 'special' argument
- if self.arg == "back": self.arg = "-1"
-
- # Actually, we don't want the F and T jumps explicit if not
- # given, since we mustn't output them for a single tuple if
- # they're not given (so they can be "added in" later on)
- if dict["onfalse"]:
- left,right = dict["onfalse"]
- self.onfalse = self.text[left:right]
- else:
- self.onfalse = None # "MatchFail"
- if dict["ontrue"]:
- left,right = dict["ontrue"]
- self.ontrue = self.text[left:right]
- else:
- self.ontrue = None # "next"
-
- def only_in_block(self):
- """Return true if we can only occur inside a block."""
- return 1
-
- def resolve_labels(self,block):
- """Called to resolve any labels use in this line.
-
- block -- the block that contains us
- """
- if self.onfalse:
- self.onfalse = block.translate_label(self.onfalse,self)
- if self.ontrue:
- self.ontrue = block.translate_label(self.ontrue,self)
-
- def _write_text(self,stream,block):
- """Write out the main tuple text.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
-
- It returns the number of characters written, or -1 if we had
- an error.
- """
-
- # Start with the stuff we must have...
- stream.write("(%s,%s,%s"%(self.tagobj,self.cmd,self.arg))
- length = len(self.tagobj) + len(self.cmd) + len(self.arg) + 3
-
- if self.ontrue:
- if not self.onfalse:
- # OK, we didn't get an explicit F, but because it comes
- # before the T jump in the tuple, we need to fake it
- # anyway...
- stream.write(",%s,%s)"%("MatchFail",self.ontrue))
- length = length + len("MatchFail") + len(self.ontrue) + 3
- else:
- # We had both F and T
- stream.write(",%s,%s)"%(self.onfalse,self.ontrue))
- length = length + len(self.onfalse) + len(self.ontrue) + 3
- elif self.onfalse:
- # We only had F. We shan't "fake" the T jump, *just* in case
- # the user is defining a single tuple that they'll add the
- # T jump to later on (although that *is* a bit dodgy, I think)
- # [[The option would be to "fake" it if we're IN a block - I may
- # go for that approach later on]]
- stream.write(",%s)"%self.onfalse)
- length = length + len(self.onfalse) + 2
- else:
- # Neither F nor T - so don't write the defaults for either,
- # in case this is a top level tuple they're going to add to
- # later on...
- # [[Comments as for the case above, I think]]
- stream.write(")")
- length = length + 1
-
- if block and not self.is_last:
- stream.write(",")
- length = length + 1
-
- return length
-\f
-# ------------------------------------------------------------
-class TuplePlusLine(ContentLine):
- """A line containing a tuple "plus" (e.g., "fred + (+1,+1)").
-
- Contains:
-
- name -- the name/identifier
- ontrue -- what to do if true
- onfalse -- ditto false
- """
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate a TuplePlusLine.
-
- <identifier> + (onF,onT)
-
- The content of the tagtuple is:
-
- ('tupleplus',left,right,[
- ('identifier',left,right,None)
- ('onfalse',left,right,[ -- optional
- ('target',left,right,[
- ('tgt',left,right,None)
- ]),
- ('ontrue',left,right,[ -- optional
- ('target',left,right,[
- ('tgt',left,right,None)
- ])
- ])
- ])
- """
-
- ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
-
- self.unpack()
-
-
- def unpack(self):
- """Unpack our contents from our tagtuple."""
-
- # This is doubtless not the most efficient way of doing this,
- # but it IS relatively simple...
- dict = {}
- for key in ("identifier","onfalse","ontrue"):
- dict[key] = None
-
- tuples = self.tagtuple[SUBLIST]
- for item in tuples:
- name = item[OBJECT]
- if name == "onfalse" or name == "ontrue":
- # For these, we need to go "down one level" for our data
- tup = item[SUBLIST][0]
- dict[name] = (tup[LEFT],tup[RIGHT])
- else:
- dict[name] = (item[LEFT],item[RIGHT])
-
- # Start with the identifier
- left,right = dict["identifier"]
- self.name = self.text[left:right]
-
- # Actually, we don't want the F and T jumps explicit if not
- # given, since we mustn't output them for a single tuple if
- # they're not given (so they can be "added in" later on)
- if dict["onfalse"]:
- left,right = dict["onfalse"]
- self.onfalse = self.text[left:right]
- else:
- self.onfalse = None # "MatchFail"
- if dict["ontrue"]:
- left,right = dict["ontrue"]
- self.ontrue = self.text[left:right]
- else:
- self.ontrue = None # "next"
-
- def only_in_block(self):
- """Return true if we can only occur inside a block."""
- return 1
-
- def resolve_labels(self,block):
- """Called to resolve any labels use in this line.
-
- block -- the block that contains us
- """
- if self.onfalse:
- self.onfalse = block.translate_label(self.onfalse,self)
- if self.ontrue:
- self.ontrue = block.translate_label(self.ontrue,self)
-
- def _write_text(self,stream,block):
- """Write out the main tuple text.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
-
- It returns the number of characters written, or -1 if we had
- an error.
- """
-
- if not self.onfalse and not self.ontrue:
- stream.write("%s"%self.name)
- length = len(self.name)
- else:
- # Make a feeble attempt to cause successive such lines to
- # look neater, by aligning the "+" signs (if we output them)
- stream.write("%-15s + ("%(self.name))
- length = max(len(self.name),15) + 4
- if self.ontrue and self.onfalse:
- stream.write("%s,%s)"%(self.onfalse,self.ontrue))
- length = length + len(self.onfalse) + len(self.ontrue) + 2
- elif self.ontrue:
- stream.write("MatchFail,%s)"%(self.ontrue))
- length = length + len(self.ontrue) + 11
- else:
- # Don't forget that comma to make this a tuple!
- stream.write("%s,)"%(self.onfalse))
- length = length + len(self.onfalse) + 1
-
- if not self.is_last:
- stream.write(",")
- length = length + 1
-
- return length
-
-\f
-# ------------------------------------------------------------
-class JumpToLine(ContentLine):
- """A line containing "Jump To <label>"
-
- Contains:
-
- name -- the name/identifier
- onfalse -- the target (which is technically an "on false" jump)
- """
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate a JumpLine.
-
- Jump To <label>
-
- The content of the tagtuple is:
-
- ('jumpto',left,right,[
- ('target',left,right,[
- ('tgt',left,right,None)
- ]),
- ])
- """
-
- ContentLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
-
- tup = self.tagtuple[SUBLIST][0]
- self.onfalse = self.text[tup[LEFT]:tup[RIGHT]]
-
- def only_in_block(self):
- """Return true if we can only occur inside a block."""
- return 1
-
- def resolve_labels(self,block):
- """Called to resolve any labels use in this line.
-
- block -- the block that contains us
- """
- self.onfalse = block.translate_label(self.onfalse,self)
-
- def _write_text(self,stream,block):
- """Write out the main tuple text.
-
- stream -- an object with a "write" method, e.g., a file
- block -- used to pass the containing Block down to lines
- within a block, or None if we're not in a block
-
- It returns the number of characters written, or -1 if we had
- an error.
- """
-
- stream.write("(None,Jump,To,%s)"%(self.onfalse))
- length = len(self.onfalse) + 15
-
- if not self.is_last:
- stream.write(",")
- length = length + 1
-
- return length
-
-\f
-# ------------------------------------------------------------
-class BadTableBlockLine(TableBlockLine):
- """We think they MEANT this to be a table block line."""
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate a BadTableBlockLine.
-
- For instance:
-
- "fred" = Table:
- Table:
- """
- TableBlockLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
- self.error("Suspected missing 'is' before the colon\n"
- "pretending it's there")
-
-\f
-# ------------------------------------------------------------
-class BadTupleLine(TupleLine):
- """We think they MEANT this to be a tuple line."""
-
- def __init__(self,lineno,indent_str,tagtuple,comment,text):
- """Instantiate a BadTupleLine.
-
- For instance:
-
- "fred" = IsIn "abc"
- """
- TupleLine.__init__(self,lineno,indent_str,tagtuple,comment,text)
- self.error("Suspected missing '=' between tag object and command\n"
- "pretending it's there")
-
-\f
-# ------------------------------------------------------------
-class Block(ContentLine):
- """This class represents a "block".
-
- A "block" is a section of code which starts with a line ending in
- a colon (":"), with the next line and subsequent lines ("in" the
- block) having an extra indent. The block ends when a dedent is
- encountered.
-
- Each instance "eats" lines from the input until (if) it finds the first
- "sub" block. That then "eats" lines until it finds its own end, and
- then hands control back to the first instance, which does the same thing
- again, and so on.
-
- Note that we "pretend" to be a content line - it is convenient to
- look like a line class, so that line processing can cope with us,
- and indeed what we do is "pretend" to be a clone of our start line
- with some extra information...
-
- Contains:
- startline -- the line that "introduces" this block
- items -- a list of the lines and blocks within this block
- label_dict -- a dictionary of {label name : line index}
- inner_indent -- the indentation of our "inner" lines
- outer -- true if we are an "outer" block
- (i.e., not contained within another block)
- """
-
- def __init__(self,startline=None,outer=0,file=None):
- """Instantiate a new block.
-
- startline -- the line that introduces this block
- outer -- true if we are an outer block
- file -- the "file" we're reading lines from
- """
-
- # Pretend to be our own startline (as a generic)
- ContentLine.__init__(self,
- startline.lineno,startline.indent_str,
- startline.tagtuple,startline.comment,
- startline.text)
-
- # But also remember the specifics of the startline
- self.startline = startline
-
- # We "fudge" our class name
- self.class_name = self._block_class_name(startline)
-
- self.outer = outer
- self.file = file
-
- # If we're an outer table block, do we have a tagobj?
- if self.startline.class_name == "TableBlockLine" and outer:
- if not self.startline.got_tagobj():
- raise NoIdentifier,\
- "Tag table at line %d is not assigned to a variable"%\
- (self.lineno)
- elif self.startline.is_subtable:
- raise OutsideError,\
- "SubTable is not allowed outside a block at line %d"%\
- (self.lineno)
-
- self.items = [] # all lines within this block
- self.business = [] # just those that are "our business"
- self.label_dict = {} # remember our labels and their locations
- self.next_index = 0 # 'business' line indices
- self.inner_indent = None
-
- # Eat lines until we reach the end of our block...
- if DEBUGGING: print "%sStart %s"%(self.indent_str,self.class_name)
- self._eat_lines()
- self._end_block()
-
- def _block_class_name(self,startline):
- """Return a representation of the class name."""
-
- full_name = "%s"%self.__class__
- bits = string.split(full_name,".")
- return "%s/%s"%(bits[-1],startline.class_name)
-
- def _eat_lines(self):
- """Eat lines until we run out of block..."""
-
- while 1:
- try:
- nextline = self.file.next()
- except EOFError:
- return
-
- # Check the indentation makes sense...
- if self.inner_indent:
- # We already know how much our block is indented
- # - is this line part of the block?
- if nextline.indent < self.inner_indent:
- # Apparently a dedent - is it what we expect?
- if nextline.indent <= self.indent:
- # Unread that line - it isn't one of ours!
- self.file.unget()
- return
- else:
- raise IndentError,\
- "Line %d (%s) is indented less than the previous "\
- "line, but its indentation doesn't match the "\
- "start of the block at line %d"%\
- (nextline.lineno,nextline.class_name,self.lineno)
- elif nextline.indent > self.inner_indent:
- # A spurious indent
- # (note that doing this stops us from coping with,
- # for instance, things in (..), but then we also don't
- # cope with any form of continued line, or lots of other
- # things, so let's not worry too much for now!)
- raise IndentError,\
- "Line %d (%s) is indented more than the previous line"%\
- (nextline.lineno,nextline.class_name)
- else:
- # This is the first line of the (inside of) the block
- # - check its indentation makes sense...
- self.inner_indent = nextline.indent
- if self.inner_indent <= self.indent:
- raise IndentError,\
- "Line %d (%s) should be indented more than line %d (%s)"%\
- (nextline.lineno,nextline.class_name,
- self.lineno,self.startline.class_name)
-
- # Is it a line or the start of another block?
- if nextline.starts_block():
- # Heh - it's the start of an inner block - add it
- # (remember that instantiating it causes it to
- # "eat" the lines that belong to it)
- self.items.append(Block(startline=nextline,
- outer=0,file=self.file))
- else:
- self.items.append(nextline)
-
- def _end_block(self):
- """End our block"""
-
- if DEBUGGING: print "%sEnd %s"%(self.indent_str,self.class_name)
-
- # If we're a tuple block, we should only have one line...
- # (that is, one "business" line)
- if self.startline.class_name == "TupleBlockLine" and \
- len(self.items) > 1:
- # Are all but one of them not "our business"?
- count = 0
- for item in self.items:
- if item.our_business():
- count = count + 1
- if count > 1: break
- if count > 1:
- self.error("Tuple declaration can only contain one 'business'"
- " line, not %d\n"
- "Assuming it's a table instead (i.e.,"
- "'Table is:' instead of 'is:')"%len(self.items))
- # Can we correct this by "pretending" its a table?
- temp = TableBlockLine(self.startline.lineno,
- self.startline.indent_str,
- ("error",self.startline.name),
- self.startline.comment,
- self.text)
- self.startline = temp
-
- # We've now got all of our lines, and so we can go back over
- # them, expanding out any IF blocks (whose content is actually
- # within this block's scope, so who need to have their labels
- # (come from or go to) in that scope), working out the label
- # indices, and so on...
- # This uses "next_index" to calculate the indices of business
- # lines (needed for label calculation), and also populates the
- # "business" list with just the items that are "our_business()"
- if DEBUGGING:
- print "Expanding IF blocks, sorting out labels, etc."
-
- temp = self.items
- self.items = []
- for item in temp:
- if item.class_name == "Block/IfBlockLine":
- self._add(item.startline)
- for thing in item.items:
- self._add(thing)
- else:
- self._add(item)
-
- # Go back through our contents and resolve any labels
- if DEBUGGING:
- print "%s...processing labels (next_index=%d)"%(self.indent_str,
- self.next_index)
- self.startline.resolve_labels(self)
- # If we're an IF block, we mustn't try to resolve our component
- # lines' labels, as they're actually in our parent block's scope...
- if self.startline.class_name != "IfBlockLine":
- for item in self.items:
- item.resolve_labels(self)
-
- # If we're in a block that wants to suppress the comma at the
- # end of the last item in that block, tell the last item so...
- # (this is debatable for [Bad]TableBlockLine - it might be
- # better to leave the last comma there - so we have an option
- # to determine it...
- if self.startline.class_name == "TupleBlockLine" or \
- (not WANT_LAST_COMMA and \
- (self.startline.class_name == "TableBlockLine" or \
- self.startline.class_name == "BadTableBlockLine")):
- if len(self.business) > 0:
- self.business[-1].is_last = 1
-
- def _add(self,item):
- """Add a line or block to our list of items.
-
- item -- the Line or Block instance to add
-
- NB: Also adds it to our "business" list if it is our business
- (and not a label)
- """
-
- if item.class_name == "LabelLine":
- self.label_dict[item.label] = self.next_index
- if DEBUGGING:
- print "%sadd [%2d] %s"%(item.indent_str,self.next_index,item)
- # Might as well give it the index it is labelling
- item.index = self.next_index
- self.items.append(item)
- elif item.our_business():
- item.index = self.next_index
- self.items.append(item)
- self.business.append(item)
- if DEBUGGING:
- print "%sadd %2d %s"%(item.indent_str,
- self.next_index,item)
- self.next_index = self.next_index + 1
- else:
- # It's not something we can assign a sensible index to, so don't
- if DEBUGGING:
- print "%sadd xx %s"%(item.indent_str,item)
- self.items.append(item)
-
- def translate_label(self,label,line):
- """Given a label, return its translation.
-
- label -- either a string of the form "<...>" to look up in
- this block's label dictionary, or one of the special
- targets (e.g., next, MatchOk, etc.)
- line -- the line using this label
-
- Reports an error and just returns the original "label" if it
- can't translate it.
- """
- if self.label_dict.has_key(label):
- # How far do we have to jump?
- offset = self.label_dict[label] - line.index
- return "%+d"%offset
- elif label == "MatchOk":
- return "MatchOk"
- elif label == "MatchOK":
- line.warning("Label 'MatchOK' should be spelt 'MatchOk'"
- " (using 'MatchOk')")
- return "MatchOk"
- elif label == "MatchFail":
- return "MatchFail"
- elif label == "next":
- return "+1"
- elif label == "previous":
- return "-1"
- elif label == "repeat":
- return "0"
- else:
- line.error("Undefined label '%s'"%label)
- return label
-
- def expand(self,stream,block=None):
- """Write out the expanded equivalent of ourselves.
-
- stream -- an object with a "write" method, e.g., a file
- block -- if we're in a block, this is it, otherwise None
- """
-
- self.startline.expand(stream,block=block)
- for item in self.items[:-1]:
- item.expand(stream,block=self)
-
- self.items[-1].expand(stream,block=self)
-
- # Deal with closing any block parentheses
- if self.startline.class_name == "TableBlockLine" or \
- self.startline.class_name == "BadTableBlockLine":
- if DEBUGGING:
- stream.write("Line ...: ")
-
- stream.write(self.indent_str)
- if self.outer:
- # Outer block - just close it
- stream.write(")")
- else:
- # Inner block is a Table block, and we need to close both
- # the tuple-of-tuples, and also the tuple containing the
- # Table command...
- stream.write("))")
- if not self.is_last:
- stream.write(",")
- stream.write("\n")
-
-\f
-# ------------------------------------------------------------
-class File:
- """This is the class that holds our processed data
-
- Contains:
- lines -- a list of the line instances for each "line" in our text
- items -- a list of lines and BLOCKs
- """
-
- def __init__(self,tagtuples,text):
- """Instantiate a File
-
- tagtuples -- the list of mxTextTools tag tuples generated by
- parsing the data in "text"
- text -- the text we parsed
- """
-
- self.text = text
- self.tagtuples = tagtuples
-
- # Assemble our list of lines
- print "Pass 1: assembling lines"
- if DEBUGGING: print "~~~~~~~~~~~~~~~~~~~~~~~~"
- self.lines = []
- lineno = 0
- prevline = None
- for tagtuple in tagtuples:
- lineno = lineno + 1
- thisline = LineFactory(lineno,tagtuple,text)
-
- if prevline:
- prevline.next_indent = thisline.indent
-
- self.lines.append(thisline)
- prevline = thisline
-
- #if DEBUGGING: print
-
- # The indentation of an empty line is taken to be the same
- # as the indentation of the first following non-empty line
- # The easiest way to do that is to work backwards through
- # the list (is it better to take a copy and reverse THAT,
- # or to reverse our original list twice?)
- print "Pass 2: sorting out indentation of empty lines"
- if DEBUGGING: print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
- revlist = self.lines[:]
- revlist.reverse()
- indent = 0
- for line in revlist:
- if line.class_name == "EmptyLine":
- line.change_indent(indent)
- else:
- indent = line.indent
- del revlist
-
- if DEBUGGING:
- print "Pass 2.5 - the contents of those lines..."
- print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
- for line in self.lines:
- print "Line %d %s"%(line.lineno,line.class_name)
- #print_tuples([line.tagtuple],self.text," ")
- print
-
- # Now we need to assemble blocks
- print "Pass 3: assembling blocks"
- if DEBUGGING: print "~~~~~~~~~~~~~~~~~~~~~~~~~"
- self.reset()
- self.items = []
-
- while 1:
- try:
- item = self.next()
- except EOFError:
- break
-
- if DEBUGGING:
- print "%sTOP %s"%(item.indent_str,item)
- if item.starts_block():
- block = Block(startline=item,outer=1,file=self)
- self.items.append(block)
- block.is_last = 1 # Everything at outer level is "last"
- else:
- if item.only_in_block():
- item.error("This line is not allowed outside a block "
- "- continuing anyway")
- self.items.append(item)
- if item.our_business():
- item.is_last = 1 # Everything at outer level is "last"
-
- if DEBUGGING: print
-
-
- def reset(self):
- """Ensure that the next call of "nextline" returns the first line."""
- self.index = -1
-
- def unget(self):
- """Unread the current line."""
- self.index = self.index - 1
- if self.index < 0:
- self.index = 0
-
- def next(self):
- """Retrieve the next line from the list of lines in this "file".
-
- Raises EOFError if there is no next line (i.e., "end of file")
- """
- self.index = self.index + 1
- try:
- return self.lines[self.index]
- except IndexError:
- # leave the index off the end, so we get EOF again if
- # we're called again - but there's no point courting overflow...
- self.index = self.index -1
- raise EOFError
-
- def expand(self,stream):
- """Expand out the result."""
- for item in self.items:
- item.expand(stream)
-
-\f
-# ------------------------------------------------------------
-def print_tuples(tuples,text,indent=""):
- """Print out a list of tuples in a neat form
-
- tuples -- our tuple list
- text -- the text it tags
- indent -- our current indentation
- """
-
- # Tuples are of the form:
- # (object,left_index,right_index,sublist)
-
- for obj,left,right,sub in tuples:
- if sub:
- print "%s%s"%(indent,obj)
- print_tuples(sub,text,indent+" ")
- else:
- # Terminal node - show the actual text we've tagged!
- print "%s%s = %s"%(indent,obj,`text[left:right]`)
-
-\f
-# ------------------------------------------------------------
-def print_text(text):
- """Print out text with line numbers."""
- lines = string.split(text,"\n")
- lineno = 0
-
- print "Original text"
- print "============="
- for line in lines:
- lineno = lineno + 1
- print "%3d: %s"%(lineno,`line`)
-
-\f
-# ------------------------------------------------------------
-def print_usage(argv0):
- #script_name = string.split(argv0, os.sep)[-1]
- #print __doc__%(script_name)
- print argv0
- print __doc__
-
-\f
-# ------------------------------------------------------------
-def show_tup(indent,nn,tup):
- ll = []
- for item in tup:
- if type(item) == type((1,)) or type(item) == type([]):
- ll.append("(..)")
- else:
- ll.append(`item`)
-
- if nn:
- print "%s%d: (%s)"%(indent,nn,string.join(ll,","))
- else:
- print "%s(%s)"%(indent,string.join(ll,","))
-
-def comp_sub(indent,one,two):
- len1 = len(one)
- if len(two) != len(one):
- print "%sTuple lengths differ - 1:%d, 2:%d"%(indent,len1,len(two))
- show_tup(indent,1,one)
- show_tup(indent,2,two)
- # If this is all, let's try to continue...
- len1 = min(len1,len(two))
-
- for count in range(len1):
- a = one[count]
- b = two[count]
- if type(a) != type(b):
- print "%sValue types differ, item %d: 1:%s, 2:%s"%(indent,count,
- type(a),type(b))
- show_tupe(indent,1,one)
- show_tupe(indent2,two)
- return 0
- if type(a) == type((1,)) or type(a) == type([]):
- if not comp_sub(indent+" ",a,b):
- # They're the same at this level, so show only one...
- show_tup(indent,0,one)
- return 0
- else:
- if a != b:
- print "%sValues differ, item %d: 1:%s, 2:%s"%(indent,count,
- `a`,`b`)
- show_tup(indent,1,one)
- show_tup(indent,2,two)
- return 0
- return 1
-
-def compare_tagtables(one,two):
- # Each table is made up of tuples of the form
- # (tagobj,action,arg,onfalse,ontrue)
- # but if action is Table or SubTable then arg may be a tuple
- # itself...
- if comp_sub("",one,two):
- print "They appear to be the same"
-
-\f
-# ------------------------------------------------------------
-def main():
- """Used to test the module."""
-
- debug_pytag = DEFAULT_DEBUG
- use_pytag = DEFAULT_PYTAG
- use_stdout = 0
- import_tags = 0
- force_overwrite = 0
- compare_tables = 0
-
- if os.name == "posix":
- use_testdata = 0
- else:
- # At home...
- use_testdata = 1
- use_stdout = 1
- global DEBUGGING
- DEBUGGING = 0
-
- # Do we have command line arguments?
- arg_list = sys.argv[1:]
- args = []
-
- while 1:
- if len(arg_list) == 0:
- break
-
- word = arg_list[0]
-
- if word == "-pytag":
- use_pytag = 1
- elif word == "-debug":
- debug_pytag = 1
- elif word == "-stdout":
- use_stdout = 1
- elif word == "-force":
- force_overwrite = 1
- elif word == "-import":
- import_tags = 1
- elif word == "-compare":
- compare_tables = 1
- elif word == "-diag":
- global DEBUGGING
- DEBUGGING = 1
- elif word == "-test":
- use_testdata = 1
- use_stdout = 1
- elif word == "-help":
- print_usage(sys.argv[0])
- return
- elif word == "-version":
- print "Version:",__version__
- return
- elif word == "-history":
- print "History:"
- print __history__
- return
- else:
- args.append(word)
-
- arg_list = arg_list[1:]
- continue
-
- if compare_tables:
- from Translate_tags import t_file
- i_file = define_tagtable()
- print "Comparing internal table (1) against external (2)"
- compare_tagtables(i_file,t_file)
- return
-
- if not use_testdata and (not args or len(args) > 2):
- print_usage(sys.argv[0])
- return
-
- if not use_testdata:
- infile = args[0]
-
- if import_tags:
- print "Importing tag table definition"
- from Translate_tags import t_file
- else:
- print "Using internal tag table definition"
- t_file = define_tagtable()
-
- if use_stdout:
- outfile = "standard output"
- elif len(args) > 1:
- outfile = args[1]
- else:
- base,ext = os.path.splitext(infile)
- if ext != ".py":
- outfile = base + ".py"
- else:
- print "Input file has extension .py so won't guess"\
- " an output file"
- return
-
- if outfile != "standard output":
- if outfile == infile:
- print "The output file is the same as the input file"
- print "Refusing to overwrite %s"%outfile
- return
- elif os.path.exists(outfile):
- if force_overwrite:
- print "Output file %s already exists"\
- " - overwriting it"%outfile
- else:
- print "Output file %s already exists"%outfile
- return
-
- # Read the input file
- if use_testdata:
- if DEBUGGING: print
- print "Using test data"
- if DEBUGGING: print "==============="
- text = test_data
- else:
- if DEBUGGING: print
- print "Reading text from %s"%infile
- if DEBUGGING: print "=================="+"="*len(infile)
- file = open(infile,"r")
- text = file.read()
- file.close()
-
- # Show what we are trying to parse
- if DEBUGGING or use_testdata:
- print
- print_text(text)
-
- # Tag it
- print
- print "Tagging text"
- if DEBUGGING: print "============"
- if use_pytag:
- import pytag
- pytag.set_verbosity(0)
- if debug_pytag:
- pytag.set_verbosity(1)
- pytag.use_debugger()
- result,taglist,next = pytag.pytag(text,t_file)
- else:
- timer = TextTools._timer()
- timer.start()
- result, taglist, next = tag(text,t_file)
- #result, taglist, next = tag(text,t_file,0,len(text),taglist)
- print "Tagging took",timer.stop()[0],"seconds"
-
- # Now print out the result of the tagging
- print
- print "Manipulating tagged data"
- if DEBUGGING: print "========================"
- tagfile = File(taglist,text)
-
- print
- print "Writing translation to %s"%outfile
- if DEBUGGING: print "======================="+"="*len(outfile)
-
- # Open the output file, if necessary
- if use_stdout:
- file = sys.stdout
- else:
- file = open(outfile,"w")
-
- tagfile.expand(file)
-
-\f
-# ------------------------------------------------------------
-if __name__ == '__main__':
- main()
+++ /dev/null
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-try:
- import mx.TextTools
- import sys
- sys.modules['TextTools']=mx.TextTools
-except:
- # Le package mx n'est pas installé. On essaie d'importer
- # directement TextTools au cas ou
- try:
- import TextTools
- except:
- # Aucun des deux packages n'est installé
- #print """ Le package mx.TextTools ou TextTools doit etre
- #installé pour pouvoir relire des fichiers de commandes
- #au format Aster V5
- #voir : http://www.lemburg.com/python/mxExtensions.html
- #"""
- pass
+++ /dev/null
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-import sys,string
-try :
- import TextTools
-except :
- ""
-try :
- from tables import ERRORS
-except :
- ""
-
-#
-__version__="$Name: V7_main $"
-__Id__="$Id: conv.py,v 1.6.52.1 2013-01-24 14:25:23 pnoyret Exp $"
-#
-
-Keywords=('MAILLE_1','MAILLE_2','MAILLE_ESCL','MAILLE_FOND','MAILLE_MAIT','MAILLE_ORIG','MAILLE',
- 'NOEUD', 'NOEUD_1','NOEUD_2','NOEUD_INIT','NOEUD_FIN', 'NOEUD_ORIG','NOEUD_REFE','NOEUD_EXTR',
- 'NOEUD_I', 'NOEUD_J','NOEUD_CHOC','NOEUD_ANCRAGE','NOEUD_CENTRE','NOEUD_CMP','NOEUD_DOUBLE',
- 'NOEUD_ESCL','NOEUD_FOND','NOEUD_PARA','NOEUD_POIN_TANG',
- 'GROUP_MA', 'GROUP_MA_1','GROUP_MA_2','GROUP_MA_INT','GROUP_MA_EXT', 'GROUP_MA_ORIG',
- 'GROUP_MA_BORD','GROUP_MA_INTE','GROUP_MA_FLUIDE', 'GROUP_MA_INTERF','GROUP_MA_BETON',
- 'GROUP_MA_ESCL','GROUP_MA_FINAL','GROUP_MA_FLU_SOL','GROUP_MA_FLU_STR','GROUP_MA_FOND',
- 'GROUP_MA_MAIT','GROUP_MA_RADIER','GROUP_MA_SOL_SOL','GROUP_MA_INIT',
- 'GROUP_NO', 'GROUP_NO_1','GROUP_NO_2','GROUP_NO_EXT', 'GROUP_NO_ORIG','GROUP_NO_CHOC',
- 'GROUP_NO_ANCRAGE','GROUP_NO_CENTRE','GROUP_NO_ESCL','GROUP_NO_EXTR','GROUP_NO_FIN',
- 'GROUP_NO_FOND','GROUP_NO_INIT','GROUP_NO_POIN_TG','GROUP_NO_RADIER',
- 'NOM','NOM_GROUP_MA',
- 'SANS_NOEUD', 'SANS_GROUP_NO',
- 'INTERSEC', 'UNION','DIFFE',
- 'VECT_GRNO_ORIG','VECT_GRNO_EXTR',
- 'VALE_CO'
- )
-
-liste_macros=('MACRO_MATR_ASSE','MACRO_ELAS_MULT','MACR_ASCOUF_MAIL','MACR_ASCOUF_CALC','MACR_ASPIC_MAIL',
- 'MACR_ASPIC_CALC','MACRO_MATR_AJOU','MACRO_ELAS_MULT','MACRO_MODE_MECA','MACRO_PROJ_BASE',
- 'MACR_ADAP_MAIL',
- )
-liste_concepts_produits=[]
-commande_courante=''
-
-def text_nom_ope(text,tags,left,right):
- global commande_courante
- if len(tags) :
- tag,l,r,subtags=tags[0]
- commande_courante=text[left:l]
- return text[left:l]+'('+text[l:r]
- else :
- commande_courante=text[left:right]
- return text[left:right]+'('
-
-def text_reuse(text,tags):
- s=''
- for tag,l,r,subtags in tags:
- if tag == 'ident' :
- sd=text[l:r]
- s=s+ sd
- elif tag == 'nom_ope' : s=s+ '='+text_nom_ope(text,subtags,l,r)
- elif tag == 'affe' :
- s=s+ '='+text_affe(text,subtags)
- elif tag == 'comm' :
- if commande_courante in liste_macros:
- s=s+'reuse='+sd+','+text_macro(text,subtags)+')'
- else:
- s=s+'reuse='+sd+','+text_com(text,subtags)+')'
- else:pass
- s=s+'\n'
- return s
-
-def text_noreuse(text,tags):
- global commande_courante
- s=''
- for tag,l,r,subtags in tags:
- if tag == 'ident' :
- sd=text[l:r]
- s=s+ text[l:r]
- elif tag == 'nom_ope' :
- s=s+ '='+ text_nom_ope(text,subtags,l,r)
- elif tag == 'affe' :
- liste_concepts_produits.append(sd)
- s=s+ '='+text_affe(text,subtags)
- elif tag == 'comm' :
- if oldtag=='ident':
- if sd in liste_macros:
- s=s+'('+text_macro(text,subtags)+')'
- else:
- s=s+'('+text_com(text,subtags)+')'
- else:
- liste_concepts_produits.append(sd)
- if commande_courante in liste_macros:
- s=s+text_macro(text,subtags)+')'
- else:
- s=s+text_com(text,subtags)+')'
- else:pass
- oldtag=tag
- s=s+'\n'
- return s
-
-def list_mc(lmc,mcs):
- s=''
- for k in lmc:
- v=mcs[k]
- if len(v) ==1:
- va,c=v[0]
- s=s+c+k+'='+va+','
- elif len(v) > 1:
- s=s+k+'=('
- for va,c in v:
- s=s+string.join((c,va,','),'')
- s=s[:-1]+'),'
- s=s[:-1]
- return s
-
-def text_com(text,tags):
- mcs={}
- lmc=[]
- currid=None
- comment=''
- for tag,l,r,subtags in tags:
- if tag == 'ident' :
- currid=text[l:r]
- if not mcs.has_key(currid):
- mcs[currid]=[]
- lmc.append(currid)
- elif tag == 'mcf':
- ll=text_mcf(text,subtags)
- mcs[currid].append((ll,comment))
- comment=''
- elif tag == 'num' :
- a=string.replace(text[l:r],'D','E')
- mcs[currid].append((a,comment))
- comment=''
- elif tag == 'CPLX' :
- a=text_cplx(text,text[l:r],subtags)
- mcs[currid].append((a,comment))
- comment=''
- elif tag == 'arg' :
- a=''
- if currid in Keywords :
- # FR : (SGDG) il faut tester s'il n'y a pas déjà des cotes !!!
- if text[l]!="'" and text[r-1]!="'":
- a=a+"'"+text[l:r]+"'"
- else:
- a=a+text[l:r]
- else:
- a=a+text[l:r]
- mcs[currid].append((a,comment))
- comment=''
- elif tag == 'EVAL' :
- a=text_eval(text,subtags)
- mcs[currid].append((a,comment))
- comment=''
- elif tag == 'comment' :
- comment=comment + '#'+text[l+1:r]
- elif tag == 'comments' :
- comment=comment + text[l:r]
- elif tag == 'larg' :
- if currid in Keywords:mcs[currid].append((text_larg2(text,subtags),comment))
- else:mcs[currid].append((text_larg(text,subtags),comment))
- comment=''
- else :pass
- s=list_mc(lmc,mcs)
- if comment :s=s+comment
- return s
-
-def text_macro(text,tags):
- mcs={}
- lmc=[]
- currid=None
- comment=''
- for tag,l,r,subtags in tags:
- if tag == 'ident' :
- currid=text[l:r]
- if not mcs.has_key(currid):
- mcs[currid]=[]
- lmc.append(currid)
- elif tag == 'mcf':
- ll=text_macro_mcf(text,subtags)
- mcs[currid].append((ll,comment))
- comment=''
- elif tag == 'num' :
- a=string.replace(text[l:r],'D','E')
- mcs[currid].append((a,comment))
- comment=''
- elif tag == 'CPLX' :
- a=text_cplx(text,text[l:r],subtags)
- mcs[currid].append((a,comment))
- comment=''
- elif tag == 'arg' :
- a=''
- if text[l] == "'":
- # FR : (SGDG) il faut tester s'il n'y a pas déjà des cotes !!!
- a=a+text[l:r]
- elif currid in Keywords :
- a=a+"'"+text[l:r]+"'"
- else:
- sd=text[l:r]
- if sd not in liste_concepts_produits:
- # Il s agit d un concept produit par la macro mais situe à droite de =
- a=a+'CO("'+sd+'")'
- liste_concepts_produits.append(sd)
- else:
- a=a+sd
- mcs[currid].append((a,comment))
- comment=''
- elif tag == 'EVAL' :
- a=text_eval(text,subtags)
- mcs[currid].append((a,comment))
- comment=''
- elif tag == 'comment' :
- comment=comment + '#'+text[l+1:r]
- elif tag == 'comments' :
- comment=comment + text[l:r]
- elif tag == 'larg' :
- if currid in Keywords:mcs[currid].append((text_larg2(text,subtags),comment))
- else:mcs[currid].append((text_larg(text,subtags),comment))
- comment=''
- else :pass
- s=list_mc(lmc,mcs)
- if comment :s=s+comment
- return s
-
-def comments_text(text):
- l=string.replace(text,'%','#')
- return l
-
-def text_eval(text,tags):
- # on retourne l expression sans conversion dans un objet EVAL et entre quotes
- for tag,l,r,subtags in tags:
- if tag == 'vexpr':
- s='EVAL("""'+text[l:r]+'""")'
- return s
- return ''
-
-def text_mcf(text,tags):
- s='_F( '
- comment=''
- for tag,l,r,subtags in tags:
- if tag == 'ident' :
- s=s+comment
- comment=''
- currid=text[l:r]
- s=s+ currid +' = '
- elif tag == 'arg' :
- if currid in Keywords :
- # FR : (SGDG) il faut tester s'il n'y a pas déjà des cotes !!!
- if text[l]!="'" and text[r-1]!="'":
- s=s+"'"+text[l:r]+"',"
- else:
- s=s+text[l:r]+","
- else:s=s+text[l:r]+","
- elif tag == 'num' :
- s=s+string.replace(text[l:r],'D','E')+','
- elif tag == 'CPLX' :
- s=s+text_cplx(text,text[l:r],subtags)+','
- elif tag == 'EVAL' :
- s=s+text_eval(text,subtags)+','
- elif tag == 'larg' :
- if currid in Keywords:s=s+text_larg2(text,subtags)+','
- else: s=s+text_larg(text,subtags)+','
- elif tag == 'comments' :
- comment=comment+text[l:r]
- if comment != '':
- s=s+comment
- return s+')'
-
-def text_macro_mcf(text,tags):
- s='_F( '
- comment=''
- for tag,l,r,subtags in tags:
- if tag == 'ident' :
- s=s+comment
- currid=text[l:r]
- s=s+ currid +' = '
- elif tag == 'arg' :
- if text[l] == "'":
- # FR : (SGDG) il faut tester s'il n'y a pas déjà des cotes !!!
- s=s+text[l:r]+","
- elif currid in Keywords :
- s=s+"'"+text[l:r]+"',"
- else:
- sd=text[l:r]
- if sd not in liste_concepts_produits:
- # Il s agit d un concept produit par la macro mais situe à droite de =
- s=s+'CO("'+sd+'"),'
- liste_concepts_produits.append(sd)
- else:
- s=s+sd+','
- comment=''
- elif tag == 'num' :
- s=s+string.replace(text[l:r],'D','E')+','
- elif tag == 'CPLX' :
- s=s+text_cplx(text,text[l:r],subtags)+','
- comment=''
- elif tag == 'EVAL' :
- s=s+text_eval(text,subtags)+','
- comment=''
- elif tag == 'larg' :
- if currid in Keywords:s=s+text_larg2(text,subtags)+','
- else: s=s+text_larg(text,subtags)+','
- comment=''
- elif tag == 'comments' :
- comment=comment+text[l:r]
- return s[:-1]+')'
-
-def text_cplx(texte,text,tags):
- """ Retourne une chaîne de caractères représentant un complexe """
- s="('"+text[0:2]+"'," #text[0:2] = RI ou MP
- for tag,l,r,subtags in tags:
- if tag == 'num' :
- s=s+string.replace(texte[l:r],'D','E')+','
- s=s+')'
- return s
-
-def text_larg2(text,tags):
- """ Pareil que text_larg mais ajoute des cotes autour des arg """
- ll=[]
- for tag,l,r,subtags in tags:
- if tag == 'arg' :
- # FR : (SGDG) il faut tester le cas où les cotes sont déjà là !!!!
- if text[l] != "'" and text[r-1] != "'":
- ll.append( "'"+text[l:r]+"',")
- else:
- ll.append(text[l:r]+",")
- elif tag == 'num' :
- ll.append(string.replace(text[l:r],'D','E')+',')
- elif tag == 'CPLX' :
- ll.append(text_cplx(text,text[l:r],subtags)+',')
- elif tag == 'comments' :
- ll.append(text[l:r])
- return '('+string.join(ll,'')+')'
-
-def text_larg(text,tags):
- # Pour les listes d arguments il semble plus rapide de construire
- # une liste puis de faire join (ne pas exagerer : voir ajout ,)
- ll=[]
- for tag,l,r,subtags in tags:
- if tag == 'arg' :
- ll.append((text,l,r))
- ll.append(',')
- elif tag == 'num' :
- # cette facon de faire est un peu plus rapide que la suivante
- ll.append(string.replace(text[l:r],'D','E')+',')
- elif tag == 'comments' :
- ll.append((text,l,r))
- elif tag == 'EVAL' :
- ll.append(text_eval(text,subtags)+',')
- else:
- print "Argument ignore: ",text[l:r]
- return '('+TextTools.join(ll,'')+')'
-
-def comment_text(text):
- l=string.replace(text,'\n','\n#')
- if l[-1]=='#':return '#'+l[:-1]
- else:return '#'+l
-
-def text_affe(text,tags):
- s=''
- for tag,l,r,subtags in tags:
- if tag == 'arg' :
- s=s+text[l:r]
- elif tag == 'EVAL' :
- s=s+text_eval(text,subtags)
- elif tag == 'larg' :
- s=s+text_larg(text,subtags)
- elif tag == 'num' :
- s=s+string.replace(text[l:r],'D','E')
- elif tag == 'CPLX' :
- s=s+text_cplx(text,text[l:r],subtags)+','
- return s
-
-def text_commande(text,tags):
- """
- Convertit une taglist de type commande en une chaine de caracteres
- à la syntaxe Python représentative d'une commande
- """
- s=''
- for tag,l,r,subtags in tags:
- if tag == 'noreuse':
- s=s+text_noreuse(text,subtags)
- elif tag == 'reuse':s=s+text_reuse(text,subtags)
- return s
-
-def text_formule(text,tags):
- """
- Convertit une taglist de type formule en une chaine de caracteres
- à la syntaxe Python représentative d'une formule
- """
- s=''
- count=0
- typ=''
- for tag,l,r,subtags in tags:
- if tag == 'id':
- if count == 0:
- s=text[l:r]+' = FORMULE('+ty+'="""('
- else:
- if count > 1:s=s+','
- s=s+typ+text[l:r]
- typ=''
- count = count +1
- elif tag == 'typ':
- typ=text[l:r]
- elif tag == 'vexpr':
- s=s+ ') =\n'+text[l:r]
- elif tag == 'type':
- ty=text[l:r]
- return s +'""")\n'
-
-def text_comms(text,tags):
- """
- Convertit une taglist resultat d'un appel à TextTools.tag avec une table de type Aster
- en une chaine de caracteres à la syntaxe Python
- """
- # On met la liste globale des concepts produits à zero
- global liste_concepts_produits
- liste_concepts_produits=[]
-
- s=''
- for tag,l,r,subtags in tags:
- if tag == 'comment':
- s=s+ '#'+text[l+1:r]
- elif tag == 'Null':
- s=s+ '\n'
- elif tag == 'formule':
- s=s+ text_formule(text,subtags)
- elif tag == 'commande' :
- s=s+text_commande(text,subtags)
- else:
- s=s+ comment_text(text[l:r])
- return s
-
-def format_errs(text,tags):
- s=''
- warnings=''
- for tag,l,r,subtags in tags:
- if subtags:
- err,warn=format_errs(text,subtags)
- s=s+err
- warnings=warnings+warn
- if tag in ERRORS:
- s=s+ tag+" ligne : "+`TextTools.countlines(text[:l])`+" texte erroné : "+text[l-10:l]+'?'+text[l:r]+'\n'
- if tag == 'passline':
- warnings=warnings+ " ligne "+`TextTools.countlines(text[:l])`+" ignorée : " +text[l:r]+'\n'
- return s,warnings
-
-def conver(text):
- from tables import aster_script
- import re
- # On ajoute un '\n' en fin au cas ou il serait absent
- text=text+'\n'
- text=string.upper(text)
- result, taglist, next = TextTools.tag(text,aster_script)
- # Pour vérifier les résultats intermédiaires décommenter la ligne suivante
- #TextTools.print_tags(text,taglist)
- text=string.replace(text,'%','#')
- s_errors,warnings = format_errs(text,taglist)
- if s_errors:
- return None,s_errors,warnings
- else:
- ss=text_comms(text,taglist)
- return string.replace(ss,'\r\n','\n'),s_errors,warnings
-
-
-
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-"""
- Ce fichier définit une table de tags à utiliser avec le package
- mxTextTools pour décoder un fichier au format Asterv5.
-
- XXX Ce fichier doit etre corrigé pour incorporer deux modifications
- réalisées dans la version V1_1p1 d'EFICAS
-"""
-from TextTools import *
-
-#
-__version__="$Name: V7_main $"
-__Id__="$Id: tables.py,v 1.5.52.1 2013-01-24 14:25:23 pnoyret Exp $"
-#
-
-err0='ERR0 , erreur non identifiee : '
-err1='ERR1 , arguments commande errones : '
-err2='ERR2 , parenthese obligatoire : '
-err3='ERR3 , point virgule obligatoire : '
-err4='ERR4 , ":" obligatoire avant mot cle : '
-err5='ERR5 , mot cle facteur ou arg obligatoire : '
-err6='ERR6 , identificateur obligatoire : '
-err7='ERR7 , mot cle facteur errone : '
-err8='ERR8 , signe = ou ( attendu : '
-err9='ERR9 , ( attendue : '
-err10='ERR10 , vexpr attendue : '
-err11='ERR11 , ) attendue : '
-
-ERRORS=(err0,err1,err2,err3,err4,err5,err6,err7,err8,err9,
- err10,err11)
-
-white_set=set(whitespace)
-
-delim=" ();:=,!&*/%\n"
-
-whitespace = \
- (None,AllIn,' \t')
-
-opt_whitespace = \
- whitespace + (MatchOk,)
-
-t_opt_whitespace = \
- whitespace + (+1,)
-
-t_opt_whitenl = \
- (None,AllIn,' \t\n\r',+1)
-
-t_err = (
- (None,AllNotIn,';',+1),
- (None,Is,';'),
- (None,Skip,-1),
-)
-
-commespaces = \
- ('comments',Table,(
- (None,IsInSet,white_set,+1,+4),
- (None,Is,'%',MatchFail),
- # <comment>
- (None,AllNotIn,'\n\r',+1),
- (None,AllIn,'\n\r',+1),
- # <blancs>
- (None,AllInSet,white_set,+1),
- (None,Is,'%',MatchOk,-3),
- ))
-
-t_commespaces = (
- (None,IsInSet,white_set,+1,+4),
- (None,Is,'%',MatchFail),
- # <comment>
- (None,AllNotIn,'\n\r',+1),
- (None,AllIn,'\n\r',+1),
- # <blancs>
- (None,AllInSet,white_set,+1),
- (None,Is,'%',MatchOk,-3),
-)
-
-x_commespaces = \
- ('comments',Table,(
- # <debut>
- (None,Is,'%',+3,+1),
- (None,AllNotIn,'\n\r',+1),
- (None,AllIn,'\n\r',+1,-2),
- (None,AllInSet,white_set,+1,-3),
- ))
-
-t_ident = \
- ('ident',Table,(
- (None,IsIn,alpha+'_'),
- (None,AllIn,alpha+'_'+number,MatchOk),
- ))
-
-t_identificateur = (
- (None,IsIn,alpha+'_'),
- (None,AllIn,alpha+'_'+number,MatchOk),
-)
-
-t_identmc = (
- (None,IsIn,alpha+'_'),
- (None,AllIn,alpha+'_'+number,+1),
- (None,Table,t_commespaces,+1),
- (None,Is,':',MatchFail),
-)
-
-n_ident = \
- (None,Table,(
- (None,IsIn,alpha+'_'),
- (None,AllIn,alpha+'_'+number,MatchOk),
- ))
-
-n_string = \
- (None,Table,(
- (None,Is,"'"),
- # <loop>
- (None,AllNotIn,"'",+1),
- (None,Word,"''",+1,-1),
- (None,Is,"'",MatchFail,MatchOk),
- ))
-
-t_number = \
- ('num',Table,(
- (None,IsIn,'-+',+1),
- (None,Is,'.',+2),
- (None,IsIn,number,MatchFail,+4),
- # <entiere>
- (None,IsIn,number,MatchFail),
- (None,AllIn,number,+1),
- (None,Is,'.',+2),
- # <decimal>
- (None,AllIn,number,+1),
- # <exposant> # si pas exposant termine number trouve
- (None,IsIn,'deDE',MatchOk),
- (None,IsIn,'-+',+1),
- (None,AllIn,number,MatchFail,MatchOk),
- ))
-
-n_number = \
- (None,Table,(
- (None,IsIn,'-+',+1),
- (None,Is,'.',+2),
- (None,IsIn,number,MatchFail,+4),
- # <entiere>
- (None,IsIn,number,MatchFail),
- (None,AllIn,number,+1),
- (None,Is,'.',+2),
- # <decimal>
- (None,AllIn,number,+1),
- # <exposant> # si pas exposant termine number trouve
- (None,IsIn,'deDE',MatchOk),
- (None,IsIn,'-+',+1),
- (None,AllIn,number,MatchFail,MatchOk),
- ))
-
-t_complexe = \
- ('CPLX',Table,(
- ("RI",Word,'RI',+7),
- commespaces + (+1,),
- t_number + (MatchFail,), # ce n est pas un complexe
- commespaces + (+1,), # a partir d ici c est un complexe => produire erreurs
- (None,Is,',',+1),
- commespaces + (+1,),
- t_number + (MatchFail,MatchOk),
- # <mp>
- ("MP",Word,'MP',MatchFail),
- commespaces + (+1,),
- t_number + (MatchFail,), # ce n est pas un complexe
- commespaces + (+1,), # a partir d ici c est un complexe => produire erreurs
- (None,Is,',',+1),
- commespaces + (+1,),
- t_number + (MatchFail,MatchOk),
- # <err>
- (err7,Table,t_err,MatchFail,MatchOk),
- ))
-
-# Table pour identifier le keyword PI
-
-t_PI = \
- ('PI',Table,(
- (None,Word,'PI',MatchFail),
- (None,IsIn,alpha+'_'+number,MatchOk,+1),
- (None,Skip,-1),
- (None,Jump,To,MatchFail),
- ))
-
-t_vexpr = (
- ('par',Is,'(',+5,+1),
- commespaces + (+1,),
- ('vexpr',Table,ThisTable,+26),
- commespaces + (+1,),
- ('par2',Is,')',+25,+15),
- t_number + (+1,+14),
- t_complexe + (+1,+13),
- ('sign',IsIn,'+-',+3,+1),
- commespaces + (+1,),
- ('vexpr',Table,ThisTable,+19,+10),
- t_PI + (+1,+9),
- t_ident + (MatchFail,),
- commespaces + (+1,),
- ('listpar',Is,'(',+6,+1), # on peut avoir une liste de parametres
- # <params>
- commespaces + (+1,),
- ('param',Table,ThisTable,+13),
- commespaces + (+1,),
- (None,Is,',',+1,-3),
- ('finlist',Is,')',+11),
- # <op>
- commespaces + (+1,),
- ('exp',Word,'**',+3,+1),
- commespaces + (+1,),
- ('vexpr',Table,ThisTable,+6,MatchOk),
- ('op',IsIn,'+-*/',+3,+1),
- commespaces + (+1,),
- ('vexpr',Table,ThisTable,+3,MatchOk),
- (None,Jump,To,MatchOk),
- # <err>
- (err0,Table,t_err,MatchFail,MatchOk),
- # <err10>
- (err10,Table,t_err,MatchFail,MatchOk),
- # <err9>
- (err9,Table,t_err,MatchFail,MatchOk),
-)
-
-t_liste_param = \
- ('liste',Table,(
- t_ident,
- commespaces + (+1,),
- (None,Is,'('),
- commespaces + (+1,),
- t_vexpr + (MatchFail,),
- # <suite>
- commespaces + (+1,),
- (None,Is,',',+3),
- commespaces + (+1,),
- t_vexpr + (+3,-3),
- # <fin>
- commespaces + (+1,),
- (None,Is,')',+1,MatchOk),
- # <err>
- (err7,Table,t_err,MatchFail,MatchOk),
- ))
-
-t_eval_expr = \
- ('EVAL',Table,(
- (None,Word,'EVAL'),
- commespaces + (+1,),
- (None,Is,'(',+5),
- commespaces + (+1,),
- ('vexpr',Table,t_vexpr,+3),
- commespaces + (+1,),
- (None,Is,')',+1,MatchOk),
- # <err>
- (err7,Table,t_err,MatchFail,MatchOk),
- ))
-
-t_entier = \
- ('entier',Table,(
- (None,IsIn,number),
- (None,AllIn,number,+1),
- (None,IsIn,delim,MatchFail,+1),
- (None,Skip,-1),
- ))
-
-t_comment = \
- ('comment',Table,(
- (None,Is,'%'),
- (None,AllNotIn,'\n\r',+1),
- (None,AllIn,'\n\r',MatchOk),
- ))
-
-t_nullline = \
- ('Null',AllIn,' ;\t\n\r')
-
-t_passline = \
- ('passline',Table,(
- (None,AllNotIn,newline,+1),
- (None,IsIn,newline),
- ))
-
-t_reste = \
- ('reste',Table,(
- (None,AllNotIn,';',+1),
- ))
-
-t_rest2 = \
- ('reste',Table,(
- (None,AllNotIn,';',+1),
- (None,Is,';'),
- (None,AllNotIn,'\n',+1),
- (None,Is,'\n',MatchOk,MatchOk),
- ))
-
-t_formule = \
- ('formule',Table,(
- commespaces + (+1,),
- (None,Word,'!FORMULE'),
- commespaces + (+1,),
- (None,Is,'(',+32),
- commespaces + (+1,),
- ('type',Table,t_identificateur,+29),
- commespaces + (+1,),
- (None,Is,':',+27),
- commespaces + (+1,),
- (None,Is,'(',+26),
- commespaces + (+1,),
- ('id',Table,t_identificateur,+23),
- commespaces + (+1,),
- (None,Is,'(',+22),
- # <params>
- commespaces + (+1,),
- ('typ',Table,t_identmc,+1),
- commespaces + (+1,),
- ('id',Table,t_identificateur,+17),
- commespaces + (+1,),
- (None,Is,',',+1,-5),
- commespaces + (+1,),
- (None,Is,')',-7),
- commespaces + (+1,),
- (None,Is,'=',+11),
- commespaces + (+1,),
- ('vexpr',Table,t_vexpr,+9),
- commespaces + (+1,),
- (None,Is,')',+9),
- commespaces + (+1,),
- (None,Is,')',+7),
- commespaces + (+1,),
- (None,Is,';',+3),
- (None,AllNotIn,'\n',+1),
- (None,Is,'\n',MatchOk,MatchOk),
- # <err>
- (err0,Table,t_err,MatchFail,MatchOk),
- # <err9>
- (err9,Table,t_err,MatchFail,MatchOk),
- # <err11>
- (err11,Table,t_err,MatchFail,MatchOk),
- ))
-
-t_nom_ope = \
- ('nom_ope',Table,(
- (None,Word,'EVAL',+1,MatchFail), # EVAL n est pas un nom d operateur, il est reserve
- (None,IsIn,alpha+'_'),
- (None,AllIn,alpha+'_'+number,+1),
- commespaces + (+1,),
- (None,Is,'(',MatchFail),
- (None,Skip,-1),
- ))
-
-t_arg = \
- ('arg',Table,(
- n_string + (+1,MatchOk),
- n_ident,
- ))
-
-t_larg = \
- ('larg',Table,(
- (None,Is,'(',MatchFail),
- # <arg>
- commespaces + (+1,),
- t_complexe + (+1,+4),
- t_number + (+1,+3),
- t_eval_expr + (+1,+2),
- t_arg + (MatchFail,+1),
- # <suite>
- commespaces + (+1,),
- (None,Is,',',+1),
- (None,Is,')',-7,MatchOk),
- ))
-
-t_mcf = \
- ('mcf',Table,(
- (None,Is,'(',MatchFail),
- ("comments",Table,t_commespaces,+1),
- (None,Is,')',+1,MatchOk),
- t_ident + (MatchFail,),
- ("comments",Table,t_commespaces,+1),
- (None,Is,':',MatchFail), # a partir d ici on est dans un mot cle facteur (erreurs eventuelles)
- # <args>
- ("comments",Table,t_commespaces,+1),
- t_larg + (+1,+5),
- t_complexe + (+1,+4),
- t_number + (+1,+3),
- t_eval_expr + (+1,+2),
- t_arg + (+8,),
- # <suite>
- ("comments",Table,t_commespaces,+1),
- (None,Is,',',+1),
- ("comments",Table,t_commespaces,+1),
- (None,Is,')',+1,MatchOk),
- t_ident + (+3,),
- ("comments",Table,t_commespaces,+1),
- (None,Is,':',+1,-12),
- # <err>
- (err7,Table,t_err,MatchFail,MatchOk),
- ))
-
-t_comm = \
- ('comm',Table,( # on attend les arguments entre () sinon erreur
- (None,Is,'(',+21),
- commespaces + (+1,),
- (None,Is,')',+1,MatchOk),
- # <call>
- t_ident + (+18,),
- commespaces + (+1,),
- (None,Is,':',+16),
- commespaces + (+1,),
- t_mcf + (+5,),
- # <mcfsuite>
- commespaces + (+1,),
- (None,Is,',',+1),
- commespaces + (+1,),
- t_mcf + (+7,-3),
- # <args>
- t_larg + (+1,+5),
- t_complexe + (+1,+4),
- t_number + (+1,+3),
- t_eval_expr + (+1,+2),
- t_arg + (+5,),
- # <suite>
- commespaces + (+1,),
- # <sep>
- (None,Is,',',+1),
- commespaces + (+1,),
- (None,Is,')',-17,MatchOk),
- # <err>
- (err1,Table,t_err,MatchFail,MatchOk),
- ))
-
-t_affe = \
- ('affe',Table,(
- commespaces + (+1,),
- t_larg + (+1,+6),
- t_complexe + (+1,+5),
- t_number + (+1,+4),
- t_eval_expr + (+1,+3),
- t_arg + (+1,+2),
- (None,Jump,To,+2),
- # <suite>
- (None,Jump,To,MatchOk),
- # <err>
- (err0,Table,t_err,MatchFail,MatchOk),
- ))
-
-t_reuse = \
- ('reuse',Table,(
- t_opt_whitespace,
- t_ident,
- t_opt_whitespace,
- (None,Is,'=',+5),
- t_opt_whitespace,
- t_nom_ope + (+2,+1),
- # <comm>
- t_comm + (MatchFail,MatchOk),
- # <affe>
- t_affe + (MatchFail,MatchOk),
- # <err>
- (err8,Table,t_err,MatchFail,MatchOk),
- ))
-
-t_noreuse = \
- ('noreuse',Table,(
- t_opt_whitespace,
- t_ident,
- t_opt_whitenl,
- (None,Is,'=',+3,+1), # on a affaire a un operateur ou une affectation
- t_opt_whitespace,
- t_nom_ope + (+4,+3),
- (None,Is,'(',+5,+1),
- (None,Skip,-1),
- # <comm>
- t_comm + (+2,MatchOk),
- # <affe>
- t_affe + (+1,MatchOk),
- # <err>
- (err0,Table,t_err,MatchFail,MatchOk),
- # <err8>
- (err8,Table,t_err,MatchFail,MatchOk),
- ))
-
-t_fin = \
- ('commande',Table,(
- ('noreuse',Table,(
- t_opt_whitespace,
- ('ident',Word,"FIN"),
- t_opt_whitenl,
- (None,Is,'(',MatchFail), # On est vraiment sur d avoir la commande FIN apres avoir identifie (
- # On recule d un caractere pour identifier les arguments entre parenthèses
- (None,Skip,-1),
- t_comm + (+1,MatchOk),
- (err0,Table,t_err,MatchFail,MatchOk),
- )),
- commespaces + (+1,),
- (None,Is,';',+1,MatchOk),
- # <err>
- (err0,Table,t_err,MatchFail,MatchOk),
- ))
-
-t_commande = \
- ('commande',Table,(
- t_opt_whitespace,
- (None,Is,'&',+2,+1),
- t_reuse + (MatchFail,+2),
- t_noreuse + (MatchFail,),
- # <fin>
- commespaces + (+1,),
- (None,Is,';',+1,MatchOk),
- # <err>
- (err0,Table,t_err,MatchFail,MatchOk),
- ))
-
-aster_script = (
- # <top>
- t_nullline + (+1,+0),
- t_comment + (+1,-1),
- t_formule + (+1,-2),
- t_fin + (+1,+4),
- t_commande + (+1,-4),
- t_passline + (+1,-5),
- (None,EOF,Here,-6),
- # <AfterFin>
- t_nullline + (+1,+0),
- t_passline + (+1,-1),
- (None,EOF,Here,-2),
-)
-
-
-
+++ /dev/null
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-"""
- Ce fichier définit une table de tags à utiliser avec le package
- mxTextTools pour décoder un fichier au format Asterv5.
-
- XXX Ce fichier doit etre corrigé pour incorporer deux modifications
- réalisées dans la version V1_1p1 d'EFICAS
-"""
-from TextTools import *
-
-#
-__version__="$Name: V7_main $"
-__Id__="$Id: tables.tag,v 1.2.62.1 2013-01-24 14:25:23 pnoyret Exp $"
-#
-
-err0='ERR0 , erreur non identifiee : '
-err1='ERR1 , arguments commande errones : '
-err2='ERR2 , parenthese obligatoire : '
-err3='ERR3 , point virgule obligatoire : '
-err4='ERR4 , ":" obligatoire avant mot cle : '
-err5='ERR5 , mot cle facteur ou arg obligatoire : '
-err6='ERR6 , identificateur obligatoire : '
-err7='ERR7 , mot cle facteur errone : '
-err8='ERR8 , signe = ou ( attendu : '
-err9='ERR9 , ( attendue : '
-err10='ERR10 , vexpr attendue : '
-err11='ERR11 , ) attendue : '
-
-ERRORS=(err0,err1,err2,err3,err4,err5,err6,err7,err8,err9,
- err10,err11)
-
-white_set=set(whitespace)
-
-delim=" ();:=,!&*/%\n"
-
-whitespace is:
- AllIn ' \t'
-
-opt_whitespace is:
- whitespace F:MatchOk
-
-t_opt_whitespace is:
- whitespace F:next
-
-t_opt_whitenl is:
- AllIn ' \t\n\r' F:next
-
-t_err = Table is:
- AllNotIn ';' F:next
- Is ';'
- Skip back
-
-commespaces is:
- 'comments' = Table is:
- IsInSet white_set F:next T:<blancs>
- Is '%' F:MatchFail
- <comment>
- AllNotIn '\n\r' F:next
- AllIn '\n\r' F:next
- <blancs>
- AllInSet white_set F:next
- Is '%' F:MatchOk T:<comment>
-
-t_commespaces = Table is:
- IsInSet white_set F:next T:<blancs>
- Is '%' F:MatchFail
- <comment>
- AllNotIn '\n\r' F:next
- AllIn '\n\r' F:next
- <blancs>
- AllInSet white_set F:next
- Is '%' F:MatchOk T:<comment>
-
-x_commespaces is:
- 'comments' = Table is:
- <debut>
- Is '%':
- AllNotIn '\n\r' F:next
- AllIn '\n\r' F:next T:<debut>
- AllInSet white_set F:next T:<debut>
-
-t_ident is:
- 'ident' = Table is:
- IsIn alpha+'_'
- AllIn alpha+'_'+number F:MatchOk
-
-t_identificateur = Table is:
- IsIn alpha+'_'
- AllIn alpha+'_'+number F:MatchOk
-
-t_identmc = Table is:
- IsIn alpha+'_'
- AllIn alpha+'_'+number F:next
- None = Table t_commespaces F:next
- Is ':' F:MatchFail
-
-n_ident is:
- None = Table is:
- IsIn alpha+'_'
- AllIn alpha+'_'+number F:MatchOk
-
-n_string is:
- None = Table is:
- Is "'"
- <loop>
- AllNotIn "'" F:next
- Word "''" F:next T:<loop>
- Is "'" F:MatchFail T:MatchOk
-
-t_number is:
- 'num' = Table is:
- IsIn '-+' F:next
- Is '.' F:<entiere>
- IsIn number F:MatchFail T:<decimal>
- <entiere>
- IsIn number F:MatchFail
- AllIn number F:next
- Is '.' F:<exposant>
- <decimal>
- AllIn number F:next
- <exposant> # si pas exposant termine number trouve
- IsIn 'deDE' F:MatchOk
- IsIn '-+' F:next
- AllIn number F:MatchFail T:MatchOk
-
-n_number is:
- None = Table is:
- IsIn '-+' F:next
- Is '.' F:<entiere>
- IsIn number F:MatchFail T:<decimal>
- <entiere>
- IsIn number F:MatchFail
- AllIn number F:next
- Is '.' F:<exposant>
- <decimal>
- AllIn number F:next
- <exposant> # si pas exposant termine number trouve
- IsIn 'deDE' F:MatchOk
- IsIn '-+' F:next
- AllIn number F:MatchFail T:MatchOk
-
-t_complexe is:
- 'CPLX' = Table is:
- "RI" = Word 'RI' F:<mp>
- commespaces F:next
- t_number F:MatchFail # ce n est pas un complexe
- commespaces F:next # a partir d ici c est un complexe => produire erreurs
- Is ',' F:next
- commespaces F:next
- t_number F:MatchFail T:MatchOk
- <mp>
- "MP" = Word 'MP' F:MatchFail
- commespaces F:next
- t_number F:MatchFail # ce n est pas un complexe
- commespaces F:next # a partir d ici c est un complexe => produire erreurs
- Is ',' F:next
- commespaces F:next
- t_number F:MatchFail T:MatchOk
- <err>
- err7 = Table t_err F:MatchFail T:MatchOk
-
-# Table pour identifier le keyword PI
-
-t_PI is:
- 'PI' = Table is:
- Word 'PI' F:MatchFail
- IsIn alpha+'_'+number F:MatchOk T:next
- Skip back
- Jump To MatchFail
-
-t_vexpr = Table is:
- 'par' = Is '(':
- commespaces F:next
- 'vexpr' = Table ThisTable F:<err10>
- commespaces F:next
- 'par2' = Is ')' F:<err9> T:<op>
- t_number F:next T:<op>
- t_complexe F:next T:<op>
- 'sign' = IsIn '+-':
- commespaces F:next
- 'vexpr' = Table ThisTable F:<err10> T:<op>
- t_PI F:next T:<op>
- t_ident F:MatchFail
- commespaces F:next
- 'listpar' = Is '(': # on peut avoir une liste de parametres
- <params>
- commespaces F:next
- 'param' = Table ThisTable F:<err10>
- commespaces F:next
- Is ',' F:next T:<params>
- 'finlist' = Is ')' F:<err9>
- <op>
- commespaces F:next
- 'exp' = Word '**':
- commespaces F:next
- 'vexpr' = Table ThisTable F:<err10> T:MatchOk
- 'op' = IsIn '+-*/':
- commespaces F:next
- 'vexpr' = Table ThisTable F:<err10> T:MatchOk
- Jump To MatchOk
- <err>
- err0 = Table t_err F:MatchFail T:MatchOk
- <err10>
- err10 = Table t_err F:MatchFail T:MatchOk
- <err9>
- err9 = Table t_err F:MatchFail T:MatchOk
-
-t_liste_param is:
- 'liste' = Table is:
- t_ident
- commespaces F:next
- Is '('
- commespaces F:next
- t_vexpr F:MatchFail
- <suite>
- commespaces F:next
- Is ',' F:<fin>
- commespaces F:next
- t_vexpr F:<err> T:<suite>
- <fin>
- commespaces F:next
- Is ')' F:<err> T:MatchOk
- <err>
- err7 = Table t_err F:MatchFail T:MatchOk
-
-t_eval_expr is:
- 'EVAL' = Table is:
- Word 'EVAL'
- commespaces F:next
- Is '(' F:<err>
- commespaces F:next
- 'vexpr' = Table t_vexpr F:<err>
- commespaces F:next
- Is ')' F:<err> T:MatchOk
- <err>
- err7 = Table t_err F:MatchFail T:MatchOk
-
-t_entier is:
- 'entier' = Table is:
- IsIn number
- AllIn number F:next
- IsIn delim T:next
- Skip back
-
-t_comment is:
- 'comment' = Table is:
- Is '%'
- AllNotIn '\n\r' F:next
- AllIn '\n\r' F:MatchOk
-
-t_nullline is:
- 'Null' = AllIn ' ;\t\n\r'
-
-t_passline is:
- 'passline' = Table is:
- AllNotIn newline F:next
- IsIn newline
-
-t_reste is:
- 'reste' = Table is:
- AllNotIn ';' F:next
-
-t_rest2 is:
- 'reste' = Table is:
- AllNotIn ';' F:next
- Is ';'
- AllNotIn '\n' F:next
- Is '\n' F:MatchOk T:MatchOk
-
-t_formule is:
- 'formule' = Table is:
- commespaces F:next
- Word '!FORMULE'
- commespaces F:next
- Is '(' F:<err9>
- commespaces F:next
- 'type' = Table t_identificateur F:<err>
- commespaces F:next
- Is ':' F:<err>
- commespaces F:next
- Is '(' F:<err9>
- commespaces F:next
- 'id' = Table t_identificateur F:<err>
- commespaces F:next
- Is '(' F:<err9>
- <params>
- commespaces F:next
- 'typ' = Table t_identmc F:next
- commespaces F:next
- 'id' = Table t_identificateur F:<err>
- commespaces F:next
- Is ',' F:next T:<params>
- commespaces F:next
- Is ')' F:<params>
- commespaces F:next
- Is '=' F:<err>
- commespaces F:next
- 'vexpr' = Table t_vexpr F:<err>
- commespaces F:next
- Is ')' F:<err11>
- commespaces F:next
- Is ')' F:<err11>
- commespaces F:next
- Is ';' F:<err>
- AllNotIn '\n' F:next
- Is '\n' F:MatchOk T:MatchOk
- <err>
- err0 = Table t_err F:MatchFail T:MatchOk
- <err9>
- err9 = Table t_err F:MatchFail T:MatchOk
- <err11>
- err11 = Table t_err F:MatchFail T:MatchOk
-
-t_nom_ope is:
- 'nom_ope' = Table is:
- Word 'EVAL' F:next T:MatchFail # EVAL n est pas un nom d operateur, il est reserve
- IsIn alpha+'_'
- AllIn alpha+'_'+number F:next
- commespaces F:next
- Is '(' F:MatchFail
- Skip back
-
-t_arg is:
- 'arg' = Table is:
- n_string F:next T:MatchOk
- n_ident
-
-t_larg is:
- 'larg' = Table is:
- Is '(' F:MatchFail
- <arg>
- commespaces F:next
- t_complexe F:next T:<suite>
- t_number F:next T:<suite>
- t_eval_expr F:next T:<suite>
- t_arg F:MatchFail T:<suite>
- <suite>
- commespaces F:next
- Is ',' F:next
- Is ')' F:<arg> T:MatchOk
-
-t_mcf is:
- 'mcf' = Table is:
- Is '(' F:MatchFail
- "comments" = Table t_commespaces F:next
- Is ')' F:next T:MatchOk
- t_ident F:MatchFail
- "comments" = Table t_commespaces F:next
- Is ':' F:MatchFail # a partir d ici on est dans un mot cle facteur (erreurs eventuelles)
- <args>
- "comments" = Table t_commespaces F:next
- t_larg F:next T:<suite>
- t_complexe F:next T:<suite>
- t_number F:next T:<suite>
- t_eval_expr F:next T:<suite>
- t_arg F:<err>
- <suite>
- "comments" = Table t_commespaces F:next
- Is ',' F:next
- "comments" = Table t_commespaces F:next
- Is ')' F:next T:MatchOk
- t_ident F:<err>
- "comments" = Table t_commespaces F:next
- Is ':' F:<err> T:<args>
- <err>
- err7 = Table t_err F:MatchFail T:MatchOk
-
-t_comm is:
- 'comm' = Table is: # on attend les arguments entre () sinon erreur
- Is '(' F:<err>
- commespaces F:next
- Is ')' F:<call> T:MatchOk
- <call>
- t_ident F:<err>
- commespaces F:next
- Is ':' F:<err>
- commespaces F:next
- t_mcf F:<args>
- <mcfsuite>
- commespaces F:next
- Is ',' F:next
- commespaces F:next
- t_mcf F:<sep> T:<mcfsuite>
- <args>
- t_larg F:next T:<suite>
- t_complexe F:next T:<suite>
- t_number F:next T:<suite>
- t_eval_expr F:next T:<suite>
- t_arg F:<err>
- <suite>
- commespaces F:next
- <sep>
- Is ',' F:next
- commespaces F:next
- Is ')' F:<call> T:MatchOk
- <err>
- err1 = Table t_err F:MatchFail T:MatchOk
-
-t_affe is:
- 'affe' = Table is:
- commespaces F:next
- t_larg F:next T:<suite>
- t_complexe F:next T:<suite>
- t_number F:next T:<suite>
- t_eval_expr F:next T:<suite>
- t_arg F:next T:<suite>
- Jump To <err>
- <suite>
- Jump To MatchOk
- <err>
- err0 = Table t_err F:MatchFail T:MatchOk
-
-t_reuse is:
- 'reuse' = Table is:
- t_opt_whitespace
- t_ident
- t_opt_whitespace
- Is '=' F:<err>
- t_opt_whitespace
- t_nom_ope F:<affe> T:<comm>
- <comm>
- t_comm F:MatchFail T:MatchOk
- <affe>
- t_affe F:MatchFail T:MatchOk
- <err>
- err8 = Table t_err F:MatchFail T:MatchOk
-
-t_noreuse is:
- 'noreuse' = Table is:
- t_opt_whitespace
- t_ident
- t_opt_whitenl
- Is '=': # on a affaire a un operateur ou une affectation
- t_opt_whitespace
- t_nom_ope F:<affe> T:<comm>
- Is '(' F:<err8> T:next
- Skip back
- <comm>
- t_comm F:<err> T:MatchOk
- <affe>
- t_affe F:<err> T:MatchOk
- <err>
- err0 = Table t_err F:MatchFail T:MatchOk
- <err8>
- err8 = Table t_err F:MatchFail T:MatchOk
-
-t_fin is:
- 'commande' = Table is:
- 'noreuse' = Table is:
- t_opt_whitespace
- 'ident' = Word "FIN"
- t_opt_whitenl
- Is '(' F:MatchFail # On est vraiment sur d avoir la commande FIN apres avoir identifie (
- # On recule d un caractere pour identifier les arguments entre parenthèses
- Skip back
- t_comm F:next T:MatchOk
- err0 = Table t_err F:MatchFail T:MatchOk
- commespaces F:next
- Is ';' F:<err> T:MatchOk
- <err>
- err0 = Table t_err F:MatchFail T:MatchOk
-
-t_commande is:
- 'commande' = Table is:
- t_opt_whitespace
- Is '&':
- t_reuse F:MatchFail T:<fin>
- t_noreuse F:MatchFail
- <fin>
- commespaces F:next
- Is ';' F:<err> T:MatchOk
- <err>
- err0 = Table t_err F:MatchFail T:MatchOk
-
-aster_script = Table is:
- <top>
- t_nullline F:next T:<top>
- t_comment F:next T:<top>
- t_formule F:next T:<top>
- t_fin F:next T:<AfterFin>
- t_commande F:next T:<top>
- t_passline F:next T:<top>
- EOF Here F:<top>
- <AfterFin>
- t_nullline F:next T:<AfterFin>
- t_passline F:next T:<AfterFin>
- EOF Here F:<AfterFin>
-
-
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-from __future__ import absolute_import
-from __future__ import print_function
-
-try:
- standard_library.install_aliases()
-except:
- pass
-try:
- from builtins import str
-except:
- pass
-from builtins import object
-import sys, re, tokenize
-import io
-
-
-class ENTITE_JDC(object):
- def __init__(self):
- self.texte = ""
-
- def setText(self, texte):
- self.texte = texte
-
- def appendText(self, texte):
- """ """
- self.texte = self.texte + texte
-
-
-class COMMENTAIRE(ENTITE_JDC):
- def __str__(self):
- """
- Retourne une chaine de caracteres representant self
- sous une forme interpretable par EFICAS
- """
- t = repr(self.texte)
- return "COMMENTAIRE(u" + t + ")\n"
-
- def appendText(self, texte):
- """
- Ajoute texte a self.texte en enlevant le # initial
- """
- if texte[0] == "#":
- self.texte = self.texte + texte[1:]
- else:
- # le diese n'est pas sur le premier caractere
- amont, aval = texte.split(
- "#", 1
- ) # on decoupe suivant la premiere occurrence de #
- self.texte = self.texte + amont + aval
-
-
-class AFFECTATION(ENTITE_JDC):
- def appendText(self, texte):
- """
- Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
- """
- self.texte = self.texte + texte
-
- def __str__(self):
- """
- Retourne une expression de l'affectation comprehensible par ACCAS
- et exploitable par EFICAS
- """
- # t=repr(self.texte)
- t = self.texte
- return "PARAMETRE(nom='" + self.name + "',valeur=" + t + ")"
-
-
-class COMMANDE_COMMENTARISEE(ENTITE_JDC):
- def appendText(self, texte):
- """
- Ajoute texte a self.texte en enlevant les doubles commentaires
- """
- texte = texte.strip()
- texte = texte[2:].strip()
- self.texte = self.texte + (len(self.texte) > 0) * "\n" + texte
-
- def __str__(self):
- """
- Retourne une expression de la commande commentarisee comprehensible par ACCAS
- et exploitable par EFICAS
- """
- return "COMMANDE_COMM(texte=" + repr(self.texte) + ")\n"
-
-
-next = {}
-next["if"] = next["elif"] = "elif", "else", "end"
-next["while"] = next["for"] = "else", "end"
-next["try"] = "except", "finally"
-next["except"] = "except", "else", "end"
-next["else"] = next["finally"] = next["def"] = next["class"] = "end"
-next["end"] = ()
-start = "if", "while", "for", "try", "def", "class"
-
-
-class PARSEUR_PYTHON(object):
- """
- Cette classe sert a creer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
- representant un JDC Python en distinguant :
- - les commentaires inter commandes
- - les affectations
- - les commandes
- """
-
- # au moins 1 caractere non blanc ou non tabulation
- # pattern_ligne_non_blanche = re.compile(r'^[\w\t]+')
- pattern_ligne_non_blanche = re.compile(r"[^ \t]+")
- kwprog = re.compile(r"^\s*(?P<kw>[a-z]+)" r"(\s+(?P<id>[a-zA-Z_]\w*))?" r"[^\w]")
- endprog = re.compile(
- r"^\s*#?\s*end\s+(?P<kw>[a-z]+)" r"(\s+(?P<id>[a-zA-Z_]\w*))?" r"[^\w]"
- )
- wsprog = re.compile(r"^[ \t]*")
- optionprog = re.compile(r'#\s*parse:\s*([^\n\'"]*)$')
-
- def __init__(self, texte):
- # on verifie que le texte fourni se compile correctement
- compile(texte, "<string>", "exec")
- self.texte = io.StringIO(texte)
- self.line = ""
- self.out = ""
- self.lastcol = 0
- self.lastrow = 1
- self.please_indent = 1
- self.indent_list = []
- self.indentation = 0
- self.paren_level = 0
- self.affectation = 0
- self.indent_list = [""]
- self.objet_courant = None
- self.affectation_flag = 1
- self.comment_flag = 1
- self.buffer = []
- self.buffer_indent = ""
-
- def getOptions(self):
- m = self.optionprog.match(self.line)
- if m:
- option = m.group(1)
- name = option[1:]
- flag = option[0] == "+"
- if name == "affectation":
- self.affectation_flag = flag
- if name == "comment":
- self.comment_flag = flag
- if name == "all":
- self.comment_flag = flag
- self.affectation_flag = flag
-
- def readline(self):
- self.line = self.texte.readline()
- # print "line:",self.line
- # option ?
- self.getOptions()
- return self.line
-
- def getTexte(self, appliEficas=None):
- """
- Retourne le texte issu de l'analyse
- """
- for tk in tokenize.generate_tokens(self.readline):
- self.processToken(tk)
- return self.out
-
- def processToken(self, tk):
- """ """
- ttype, tstring, spos, epos, line = tk
- thisrow, thiscol = spos
- # print spos, epos,tokenize.tok_name[ttype],self.lastrow, self.lastcol
-
- if thisrow > self.lastrow:
- # si plusieurs lignes (>1)
- self.out = self.out + "\n" * (thisrow - self.lastrow - 1)
- self.lastcol = 0
-
- # if thiscol > self.lastcol :
- # self.out=self.out+ " " * (thiscol - self.lastcol)
- # self.please_indent = None
-
- self.thiscol = thiscol
- # self.nextrow, self.nextcol = epos
-
- try:
- fn = getattr(self, tokenize.tok_name[ttype])
- except AttributeError:
- print("No match!", tokenize.tok_name[ttype], tstring)
- return
-
- if ttype != tokenize.DEDENT and ttype != tokenize.INDENT and self.please_indent:
- self.doIndent()
-
- fn(tstring)
- self.lastrow, self.lastcol = epos
-
- def output(self, tstring):
- # print "output",tstring
-
- if self.thiscol > self.lastcol:
- # print self.thiscol,self.lastcol
- self.out = self.out + " " * (self.thiscol - self.lastcol)
- self.lastcol = self.thiscol
-
- self.out = self.out + tstring
-
- def outputCom(self, tstring):
- self.out = self.out + tstring
-
- def updateIndent(self):
- # print "updateIndent",len(self.indent_list[-1]),len(self.buffer_indent)
- if len(self.indent_list[-1]) > len(self.buffer_indent):
- self.out = (
- self.out + (len(self.indent_list[-1]) - len(self.buffer_indent)) * " "
- )
- self.buffer_indent = self.indent_list[-1]
-
- def doIndent(self):
- # print "indentation dans doIndent",len(self.indent_list)
-
- self.out = self.out + self.indent_list[-1]
- self.buffer_indent = self.indent_list[-1]
- if self.lastcol + len(self.indent_list[-1]) > self.thiscol:
- self.lastcol = self.thiscol
- else:
- self.lastcol = self.lastcol + len(self.indent_list[-1])
- self.please_indent = None
-
- def flush_buffer(self):
- # if self.buffer:
- # print len(self.indent_list),self.please_indent
- for ob in self.buffer:
- self.out = self.out + str(ob)
- self.doIndent()
- self.buffer = []
- self.objet_courant = None
-
- def NL(self, tstring):
- if self.affectation:
- if self.paren_level == 0:
- # affectation en cours mais complete
- self.out = self.out + str(self.affectation_courante)
- self.affectation_courante = None
- self.please_indent = 1
- self.affectation = 0
- else:
- # affectation en cours, on ajoute
- if self.thiscol > self.lastcol:
- self.affectation_courante.appendText(
- (self.thiscol - self.lastcol) * " "
- )
- self.affectation_courante.appendText(tstring)
- return
-
- if self.objet_courant:
- self.objet_courant = None
- self.buffer.append(tstring)
- # self.please_indent = None
- return
- self.output(tstring)
- self.please_indent = 1
-
- def COMMENT(self, tstring):
- liste = string.split(self.line, "##", 1)
- if len(liste) > 1:
- # On a trouve un double commentaire
- before, after = liste
- if self.affectation:
- # affectation en cours, on ignore
- pass
- elif self.paren_level > 0:
- self.output(tstring)
- elif self.comment_flag and not self.pattern_ligne_non_blanche.search(
- before
- ):
- # il s'agit d'une commande commentarisee
- if self.objet_courant == None:
- if not self.buffer:
- self.buffer_indent = self.indent_list[-1]
- self.objet_courant = COMMANDE_COMMENTARISEE()
- self.buffer.append(self.objet_courant)
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- elif isinstance(self.objet_courant, COMMENTAIRE):
- self.objet_courant = COMMANDE_COMMENTARISEE()
- self.buffer.append(self.objet_courant)
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- else:
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- else:
- # commentaire inline
- self.output(tstring)
- self.please_indent = 1
- return
-
- else:
- # On a un commentaire simple
- new_line = self.line.split("#")[0]
- if self.affectation:
- # affectation en cours, on ignore
- pass
- elif self.paren_level > 0:
- self.output(tstring)
- elif self.comment_flag and not self.pattern_ligne_non_blanche.search(
- new_line
- ):
- # commentaire precede de blancs
- if self.objet_courant == None:
- if not self.buffer:
- self.buffer_indent = self.indent_list[-1]
- self.objet_courant = COMMENTAIRE()
- self.buffer.append(self.objet_courant)
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- elif isinstance(self.objet_courant, COMMANDE_COMMENTARISEE):
- self.objet_courant = COMMENTAIRE()
- self.buffer.append(self.objet_courant)
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- else:
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- else:
- # commentaire inline
- self.output(tstring)
- self.please_indent = 1
- return
-
- def ERRORTOKEN(self, tstring):
- print("ERRORTOKEN", tstring)
-
- def NAME(self, tstring):
- if self.buffer:
- self.updateIndent()
- self.flush_buffer()
-
- if self.affectation == 1:
- # on a une expression du type NAME=NAME
- # on ne veut pas des expressions qui commencent par NAME=NAME(NAME=
- # on en prend le chemin : on met affectation a 3 pour le signaler
- # on attend d'en savoir plus
- if self.thiscol > self.lastcol:
- self.affectation_courante.appendText(
- (self.thiscol - self.lastcol) * " "
- )
- self.affectation_courante.appendText(tstring)
- self.affectation = 3
- return
- elif self.affectation == 4:
- # on a une expression qui commence par NAME=NAME(NAME
- # il s'agit tres probablement d'une commande
- # on annule l'affectation en cours
- if self.thiscol > self.lastcol:
- self.affectation_courante.appendText(
- (self.thiscol - self.lastcol) * " "
- )
- self.affectation_courante.appendText(tstring)
- self.affectation = 5
- return
- elif self.affectation == 2:
- # affectation en cours, on ajoute
- if self.thiscol > self.lastcol:
- self.affectation_courante.appendText(
- (self.thiscol - self.lastcol) * " "
- )
- self.affectation_courante.appendText(tstring)
- self.affectation = 2
- return
- self.affectation = 0
- self.name = None
- if self.paren_level == 0 and self.affectation_flag:
- # si on est en dehors de parentheses et en mode transformation d'affectation
- # on initialise l'attribut name qui indique une affectation en cours
- self.name = tstring
- self.output(tstring)
-
- def ident(self, tstring):
- self.flush_buffer()
- self.affectation = 0
- self.output(tstring)
-
- def NUMBER(self, tstring):
- self.flush_buffer()
- if self.affectation >= 1:
- # affectation en cours, on ajoute
- if self.thiscol > self.lastcol:
- self.affectation_courante.appendText(
- (self.thiscol - self.lastcol) * " "
- )
- self.affectation_courante.appendText(tstring)
- self.affectation = 2
- return
- self.output(tstring)
-
- def OP(self, tstring):
- self.flush_buffer()
- if tstring in ("(", "[", "{"):
- self.paren_level = self.paren_level + 1
- if tstring in (")", "]", "}"):
- self.paren_level = self.paren_level - 1
-
- if tstring == "=" and self.affectation == 5:
- # on a une expression qui commence par NAME=NAME(NAME=)
- # il peut s'agir d'une commande
- # on annule l'affectation en cours
- self.out = self.out + self.affectation_courante.texte
- self.affectation_courante = None
- self.name = None
- self.affectation = 0
- elif tstring == ")" and self.affectation == 4:
- # on a une expression qui commence par NAME=NAME()
- # il peut s'agir d'une commande
- # on annule l'affectation en cours
- self.out = self.out + self.affectation_courante.texte
- self.affectation_courante = None
- self.affectation = 0
- elif tstring == "(" and self.affectation == 3:
- # on a deja trouve NAME=NAME
- # on passe affectation a 4
- if self.thiscol > self.lastcol:
- self.affectation_courante.appendText(
- (self.thiscol - self.lastcol) * " "
- )
- self.affectation_courante.appendText(tstring)
- self.affectation = 4
- return
- elif tstring == ";" and self.affectation >= 1:
- # l'affectation est terminee
- self.out = self.out + str(self.affectation_courante)
- self.affectation_courante = None
- self.please_indent = 1
- self.affectation = 0
- elif self.affectation >= 1:
- # on complete l'affectation
- if self.thiscol > self.lastcol:
- self.affectation_courante.appendText(
- (self.thiscol - self.lastcol) * " "
- )
- self.affectation_courante.appendText(tstring)
- self.affectation = 2
- return
-
- self.affectation = 0
- if self.name and tstring == "=":
- self.affectation = 1
- self.affectation_courante = AFFECTATION()
- self.affectation_courante.name = self.name
- self.output(tstring)
-
- ENDMARKER = ident
- NEWLINE = NL
-
- def INDENT(self, tstring):
- # tstring=str(len(self.indent_list))*len(tstring)
- self.indent_list.append(tstring)
- # print "indentation dans INDENT",len(self.indent_list),len(tstring)
- self.affectation = 0
- if self.buffer:
- self.updateIndent()
- self.flush_buffer()
-
- def DEDENT(self, tstring):
- # print "DEDENT",tstring,len(tstring)
- if self.buffer:
- self.out = self.out + str(self.buffer[0])
- if len(self.buffer) > 1:
- for ob in self.buffer[1:]:
- self.doIndent()
- self.out = self.out + str(ob)
- self.buffer = []
- self.objet_courant = None
- self.please_indent = 1
-
- self.affectation = 0
- self.indent_list = self.indent_list[:-1]
- # print "indentation dans DEDENT",len(self.indent_list)
-
- def STRING(self, tstring):
- self.flush_buffer()
- if self.affectation >= 1:
- # affectation en cours, on ajoute
- if self.thiscol > self.lastcol:
- self.affectation_courante.appendText(
- (self.thiscol - self.lastcol) * " "
- )
- self.affectation_courante.appendText(tstring)
- self.affectation = 2
- return
- self.output(tstring)
-
-
-if __name__ == "__main__":
- import sys
- import io
-
- text = """
-#
-# comment
-# comment
-# comment
-#
-
-import sys,os
-
-# commentaire
-# commentaire
-# commentaire
-
-DEBUT();
-##toto = FORMULE(REEL='(REEL:A) = A',);
-
-x=2*cos(90.)/34.
-
-a=1.
-if a != 0:
- a=+1
-
-b=2.
-c=a+b
-#if 1:
-# d=3
-# e=5
-#try:
-# a=1/2
-#except KeyError:
-# pass
-
-if 1:
- a=2
- b=3
- # commenta
-else:
- # commen
- # commen
- a=3
- #qqqqqqqqqqqqqqqqqqqqqqqq
- c=5
-
-b=5
- # commentaire
-toto = FORMULE(REEL='(REEL:A) = A',);
-titi = FORMULE(REEL='(REEL:A) = A',) # commentaire inline
-tutu = FORMULE(REEL='(REEL:A) = A',) ## commentaire inline
-
-TEST_TABLE( TABLE=RELV[k],
- FILTRE=(
- _F( NOM_PARA = 'QUANTITE',
- VALE_K = 'MAXIMUM'),),
- # commentaire
- NOM_PARA='VMIS', # comm
- VALE=1.9669824189084E9,
- REFERENCE='NON_REGRESSION',
- VERSION='8.1.0' )
-
-if 1:
- a=fff(a=1,
- b=2)
-if 1:
- a=2
- b=3
- # commenta
-else:
- # commen
- # commen
- a=3
-
-for k in range(1,10):
-
- # Appel a GMSH pour le maillage
-
- f=open("coque.geo","w")
-
-
-a = 1.
-b=3
-c= 3 * 5
-d= 4 + \
- 5 \
- -4
-e=toto(a=1)
-x=(1,2)
-y=[3,
-#comme
-4]
-z="a"
-zz='v'
-u='''aaaa
-bbbb'''
-if 1:
- a=45
-else:
- a=5.6
-d={"a":0}
-e={"a":0,
-#comme
-"d":4}
-a==1
-x=a==1
-s="-"*80
-fmt_raison='-'*80+'''
-
- Exception erreur_Fatale interceptee
- Raison : %s
-
-'''+'-'*80+'xxxxxxxxxxxxxxxx'
-q=30*cos(12)
-f=cos(12)
-#commen'''
-#commen'''
-y=a[1]
-y=["x"]*10
-
-##toto = FORMULE(REEL='(REEL:A) = A',
-## X=2
-## );
-#
-# comment
-# comment
-# comment
-#
-zz=8.9;
-zz=8.9;aa=10
-P1 = 9.8;
-
-P2 = 8.8;
-
-P3 = 7;
-
-P5 = P3*P1;
-
-P6 = P1-3;
-
-P4 = [2,3,4];
-
-P7=P4[1]
-MA=LIRE_MAILLAGE()
-MA=LIRE_MAILLAGE(#comment
-)
-xyz=cos(10)
-MA=LIRE_MAILLAGE(INFO=1)
-MA=LIRE_MAILLAGE(
- NFO=1)
-MA=LIRE_MAILLAGE(#comme
- NFO=1)
-MA=\
-LIRE_MAILLAGE(INFO=1)
-MA= LIRE_MAILLAGE()
-TFIN = 1.790 # Temps fin pour le calcul
-
-PAS = 0.001 # pas de temps du calcul
-# parse: -affectation
-DS1=[None]*5
-DS2=[None]*5
-DS3=[None]*5
-DS4=[None]*5
-CHS1=[None]*5
-CHS2=[None]*5
-MO=AFFE_MODELE( MAILLAGE=MA,
- #test de validateur GEOM (typ=grma) avec grma derive de GEOM
- AFFE=(_F(GROUP_MA = ('LI1'),
- PHENOMENE = 'MECANIQUE',
- MODELISATION = 'DIS_TR'),
- ),
- INFO=2,);
-
-for k in range(1,5):
- DS1[k] = CREA_CHAMP( OPERATION='EXTR', TYPE_CHAM='NOEU_DEPL_R',
- RESULTAT= MODESTA1, NUME_ORDRE=k, NOM_CHAM = 'DEPL');
-
-# parse: +affectation
-ff=23 # parametre bidon
-
-# parse: -all
-a=45
-#commment1
-##toto = FORMULE(REEL='(REEL:A) = A',
-## X=2
-## );
-# parse: +all
-b=45
-#commment2
-##toto = FORMULE(REEL='(REEL:A) = A',
-## X=2
-## );
-# parse: -comment
-c=45
-#commment3
-##toto = FORMULE(REEL='(REEL:A) = A',
-## X=2
-## );
-# parse: +comment
-d=45
-#commment5
-##toto = FORMULE(REEL='(REEL:A) = A',
-## X=2
-## );
-p=sin(ff)
-
-e=toto(a=1)
-e=toto(a=1,b=3)
-e=toto(1,b=3)
-e=toto(a,b=3)
-e=toto()
-sensible=[2.1E11, 0.3, 1.E-6, 1.E-6, ]
-
-n=len(sensible)
-# parse: -affectation
-
-PS=[None]*n
-
-for i in range(n):
- PS[i]=DEFI_PARA_SENSI(VALE=sensible[i])
-# parse: +affectation
-
-TEST_RESU(RESU=(_F(RESULTAT = U3L,
- INST = 1.0,
- NOM_CHAM = 'DEPL',
- GROUP_NO = 'PPA',
- NOM_CMP = 'DX',
- VALE = 2.86E-5,
- PRECISION = 5.E-2,
- REFERENCE = 'AUTRE_ASTER',
- VERSION = '7.1.11',
- ),
- )
- )#
-#
-FIN()
-#
-
-TEST_RESU(RESU=(_F(RESULTAT = U3L,
- INST = 1.0,
- NOM_CHAM = 'DEPL',
- GROUP_NO = 'PPA',
- NOM_CMP = 'DX',
- VALE = 2.86E-5,
- PRECISION = 5.E-2,
- REFERENCE = 'AUTRE_ASTER',
- VERSION = '7.1.11',
- ),
- )
- ) #a
-
-titi = FORMULE(REEL='(REEL:A) = A',
-) # commentaire inline
-titi = FORMULE(REEL='(REEL:A) = A',
- ) # commentaire inline
-
-def f(x):return x
-#comment
-def f(x):
-#comment
- for i in range(10): s=0
-
-#com1
-#com2
-
-#com3
-a=1
-##commendcomm
-for k in range(1,10):
-
- # Appel a GMSH pour le maillage
-
- f=open("coque.geo","w")
-#comm
- if a==1:
-
- #comm
-
- for i in x:
-#comm
-##commendcomm
-#comm
-##commendcomm
-#comm
- if x==3:
-#comm
- r=1
- if w==4:
-#comm
-
- if k:
-
-#comm
- if g:
-
-#comm
-
- if t:
- a=5
-#comm
-if 1:
- a=2
- b=3
- # commenta
-else:
- # commen
- # commen
- a=3
- # qqqqqqqqqqqqqqqq
- c=5
-
-b=5
-
-if 1:
- a=2
- # commenta
-else:
- a=3
-if 1:
- if 2:
- if 3:
- a=1
- elif 4:
- b=1
- else:
- c=5
- elif 3:
- x=1
- else:
- y=4
-elif 4:
- s=1
-else:
- t=9
-#com1
-#com2
-
-#com3
-a=1
-##commendcomm
-for k in range(1,10):
-
- # Appel a GMSH pour le maillage
-
- f=open("coque.geo","w")
-#comm
- if 1:
- if 2:
- if 3:
- a=1
- else:
- a=6
-a=1
-##commendcomm
-for k in range(1,10):
-
- # Appel a GMSH pour le maillage
-
- f=open("coque.geo","w")
-#comm
-
- if a==1:
-
- #comm
-
- for i in x:
-#comm
-##commendcomm
-#comm
-##commendcomm
-#comm
- if x==3:
-#comm
- r=1
-
- if 1:
- if 2:
- if 3:
- a=1
- else:
- a=6
-
-if 1:
- if 2:
- if 3:
- r=1
- # comm
- else:
- x=7
- toto(a=1,
-b=3)
-SUP_=dict([(grand,0.) for grand in grand_obs])
-
-for k in range(1,ns+1):
- x=toto(a=1,b=2)
-# comm
- if 1:
- #com
-
- #com
- x=1
- #com
-
- #com
- ##com
- elif 3:
- ##com
- x=1
- else:
- y=3
-
-def f():
- return
-########################################################################
-
-########################################################################
-# macro commande de post-traitement (ex POST_GOUJ2E)
-# calcul des reactions cumulees suivant les filets
-
-def POST_GOUJ_ops(self,TABLE):
- ier=0
-
-"""
- if len(sys.argv) == 2:
- progname, input = sys.argv
- f = open(input)
- t = f.read()
- f.close()
- else:
- t = text
- txt = PARSEUR_PYTHON(t).getTexte()
- print(txt)
- compile(txt, "<string>", "exec")
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
-"""
-
-from __future__ import absolute_import
-from .convert_python import Pythonparser
-
-
-def entryPoint():
- """
- 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": Pythonparser,
- }
+++ /dev/null
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-import re
-from convert_python import Pythonparser
-
-
-def entryPoint():
- """
- Return a dictionary containing the description needed to load the plugin
- """
- return {"name": "openturns_study", "factory": OTStudyparser}
-
-
-class OTStudyparser(Pythonparser):
- """
- This converter works like Pythonparser, except that it also initializes all
- model variables to None in order to avoid Python syntax errors when loading
- a file with a different or inexistent definition of variables.
- """
-
- # We look for pattern "ModelVariable=NOMVAR,"
- pattern_model_variable = re.compile(r"ModelVariable\s*=\s*(\w+)\s*,")
-
- def convert(self, outformat, appli=None):
- text = Pythonparser.convert(self, outformat, appli)
- varnames = self.pattern_model_variable.findall(text)
- newtext = ""
- for var in varnames:
- newtext += "%s = None\n" % var
- newtext += text
- return newtext
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
-"""
-
-import parseur_python
-from convert_python import *
-
-def entryPoint():
- """
- Retourne les informations nécessaires pour le chargeur de plugins
- Ces informations sont retournées dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'openturns_wrapper',
- # La factory pour créer une instance du plugin
- 'factory' : Pythonparser,
- }
-
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin convertisseur de fichier
- au format python pour EFICAS.
-
- Un plugin convertisseur doit fournir deux attributs de classe :
- extensions et formats et deux methodes : readfile,convert.
-
- L'attribut de classe extensions est une liste d'extensions
- de fichiers preconisees pour ce type de format. Cette information
- est seulement indicative.
-
- L'attribut de classe formats est une liste de formats de sortie
- supportes par le convertisseur. Les formats possibles sont :
- eval, dict ou exec.
- Le format eval est un texte source Python qui peut etre evalue. Le
- resultat de l'evaluation est un objet Python quelconque.
- Le format dict est un dictionnaire Python.
- Le format exec est un texte source Python qui peut etre execute.
-
- La methode readfile a pour fonction de lire un fichier dont le
- nom est passe en argument de la fonction.
- - convertisseur.readfile(nom_fichier)
-
- La methode convert a pour fonction de convertir le fichier
- prealablement lu dans un objet du format passe en argument.
- - objet=convertisseur.convert(outformat)
-
- Ce convertisseur supporte le format de sortie dict
-
-"""
-from __future__ import absolute_import
-
-try:
- from builtins import str
- from builtins import object
-except:
- pass
-
-import sys, traceback
-
-from Noyau import N_CR
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
-
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- "name": "pyth",
- # La factory pour creer une instance du plugin
- "factory": Pythparser,
- }
-
-
-class Pythparser(object):
- """
- Ce convertisseur lit un fichier au format pyth avec la
- methode readfile : convertisseur.readfile(nom_fichier)
- et retourne le texte au format outformat avec la
- methode convertisseur.convert(outformat)
-
- Ses caracteristiques principales sont exposees dans 2 attributs
- de classe :
- - extensions : qui donne une liste d'extensions de fichier preconisees
- - formats : qui donne une liste de formats de sortie supportes
- """
-
- # Les extensions de fichier preconisees
- extensions = (".pyth",)
- # Les formats de sortie supportes (eval dict ou exec)
- formats = ("dict",)
-
- 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 convertisseur format pyth", fin="fin CR format pyth"
- )
- self.g = {}
-
- def readfile(self, filename):
- self.filename = filename
- try:
- with open(filename) as fd:
- self.text = fd.read()
- except:
- self.cr.fatal(tr("Impossible d'ouvrir le fichier : %s", str(filename)))
- return
- self.g = {}
- try:
- exec(self.text, self.g)
- except EficasException as e:
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
- )
- s = "".join(l[2:])
- s = s.replace('"<string>"', '"<%s>"' % self.filename)
- self.cr.fatal(tr("Erreur a l'evaluation :\n %s", s))
-
- def convert(self, outformat, appliEficas=None):
- if outformat == "dict":
- return self.getdict()
- else:
- raise EficasException(tr("Format de sortie : %s, non supporte", outformat))
-
- def getdict(self):
- d = {}
- for k, v in list(self.g.items()):
- if k[0] != "_":
- d[k] = v
- return d
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-import sys, string, re
-import traceback
-from Extensions.i18n import tr
-
-escapedQuotesRE = re.compile(r"(\\\\|\\\"|\\\')")
-stringsAndCommentsRE = re.compile(
- "(\"\"\".*?\"\"\"|'''.*?'''|\"[^\"]*\"|'[^']*'|#.*?\n)", re.DOTALL
-)
-# stringsAndCommentsRE = \
-# re.compile(u"(\"\"\".*\"\"\"|'''.*'''|\"[^\"]*\"|\'[^\']*\'|#.*\n)", re.DOTALL)
-allchars = bytes.maketrans(b"", b"")
-allcharsExceptNewline = (
- allchars[: allchars.index(b"\n")] + allchars[allchars.index(b"\n") + 1 :]
-)
-allcharsExceptNewlineTranstable = bytes.maketrans(
- allcharsExceptNewline, b"*" * len(allcharsExceptNewline)
-)
-
-
-def maskStringsAndComments(src):
- """Masque tous les caracteres de src contenus dans des commentaires ou des strings multilignes (triples
- quotes et guillemets.
- Le masquage est realise en remplacant les caracteres par des *
- Attention : cette fonction doit etre utilisee sur un texte complet et pas ligne par ligne
- """
- # remplace les \\, les \" les \' par **
- # supprime toutes les chaines ou commentaires ,y compris multiligne i
- # entre 3 ou 1 simples ou doubles quotes (ouvrantes fermantes) ou #
- # laisse les non fermantes ou non ouvrantes
- # on prend 1 sur 2 en raison du split qui donne python, commentaire, python, commentaire...
-
- src = escapedQuotesRE.sub("**", src)
- allstrings = stringsAndCommentsRE.split(src)
-
- # on a une liste d elements constituee successivement de (string, comment)
- for i in range(1, len(allstrings), 2):
- if allstrings[i].startswith("'''") or allstrings[i].startswith('"""'):
- allstrings[i] = (
- allstrings[i][:3]
- + allstrings[i][3:-3].translate(allcharsExceptNewlineTranstable)
- + allstrings[i][-3:]
- )
- else:
- allstrings[i] = (
- allstrings[i][0]
- + allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable)
- + allstrings[i][-1]
- )
-
- return "".join(allstrings)
-
-
-implicitContinuationChars = (("(", ")"), ("[", "]"), ("{", "}"))
-linecontinueRE = re.compile(r"\\\s*(#.*)?$")
-emptyHangingBraces = [0, 0, 0, 0, 0]
-
-
-class parserException(Exception):
- pass
-
-
-class FatalError(Exception):
- pass
-
-
-# commentaire double precede d'un nombre quelconque de blancs (pas multiligne)
-pattern_2comments = re.compile(r"^\s*##.*")
-pattern_finComments = re.compile("^\s*##Fin Commentaire")
-# commentaire standard precede d'un nombre quelconque de blancs (pas multiligne)
-pattern_comment = re.compile(r"^\s*#.*")
-# fin de ligne ; suivi d'un nombre quelconque de blancs (pas multiligne)
-pattern_fin = re.compile(r"; *$")
-# pattern pour supprimer les blancs, tabulations et fins de ligne
-pattern_blancs = re.compile(r"[ \t\r\f\v]")
-# pattern_blancs = re.compile(r"[\s\n]")
-number_kw_pattern = re.compile(
- r"""
-(
- #groupe nombre decimal
- (?:
- #signe : on ignore le signe +
- [-]?
- #groupe (avec ?: n'apparait pas en tant que groupe dans le resultat)
- (?:
- #mantisse forme entiere.fractionnaire
- \d+(?:\.\d*)?
- |
- #ou forme .fractionnaire
- \.\d+
- )
- (?:[eE][+-]?\d+)?
- )
- |
- #argument keyword
- [a-zA-Z_]\w*=
-)
-""",
- re.VERBOSE | re.MULTILINE,
-)
-
-
-def construitGenea(texte, listeMc):
- """
- Retourne un dictionnaire dont les cles sont des reels et les valeurs sont leurs representations textuelles.
-
- Realise un filtrage sur les reels :
-
- - Ne garde que les reels pour lesquels str ne donne pas une bonne representation.
- - Ne garde que les reels derriere un argument keyword dont le nom est dans listeMc
-
- >>> s = '''a=+21.3e-5*85,b=-.1234,c=81.6 , d= -8 , e=_F(x=342.67,y=-1), f=+1.1, g=(1.3,-5,1.54E-3),
- ... #POMPE_PRIMA._BOUCLE_N._2_ELEMENT_NUMERO:0239
- ... h=_F(x=34.6,y=-1)'''
- >>> construitGenea(s,['a','x'])
- {0.000213: '21.3e-5'}
- """
- d = {}
- mot = ""
- # on masque les strings et commentaires pour ne pas identifier de faux reels
- for m in number_kw_pattern.findall(maskStringsAndComments(texte)):
- if m[-1] == "=":
- # argument keyword
- mot = m[:-1]
- else:
- if mot not in listeMc:
- continue
- # valeur
- key = eval(m)
- if str(key) != m:
- d[key] = m
- return d
-
-
-class ENTITE_JDC(object):
- """Classe de base pour tous les objets crees lors de la conversion
- Tout objet derive est enregistre aupres de son pere a sa creation
- """
-
- def __init__(self, pere):
- self.texte = ""
- pere.l_objets.append(self)
-
- def setText(self, texte):
- self.texte = texte
-
- def appendText(self, texte):
- """
- Ajoute texte a self.texte en mettant un retour chariot a la fin de texte
- """
- texte = texte + "\n"
- self.texte = self.texte + texte
-
- def __str__(self):
- return self.texte
-
-
-class COMMENTAIRE(ENTITE_JDC):
- def __str__(self):
- """
- Retourne une chaine de caracteres representants self
- sous une forme interpretable par EFICAS
- """
- t = repr(self.texte)
- return "COMMENTAIRE(u" + t + ")\n"
-
- # s='COMMENTAIRE(u"""'+self.texte+'""")\n\n'
- # return s
-
- def appendText(self, texte):
- """
- Ajoute texte a self.texte en enlevant le # initial
- """
- texte = texte + "\n"
- if texte[0] == "#":
- self.texte = self.texte + texte[1:]
- else:
- # le diese n'est pas sur le premier caractere
- amont, aval = texte.split(
- "#", 1
- ) # on decoupe suivant la premiere occurrence de #
- self.texte = self.texte + amont + aval
-
-
-class COMMANDE(ENTITE_JDC):
- def __str__(self):
- """
- Retourne self.texte
- """
- return self.texte + "\n"
-
- def getNbPar(self):
- """
- Retourne la difference entre le nombre de parentheses ouvrantes
- et le nombre de parentheses fermantes presentes dans self.texte
- Peut donc retourner un entier negatif
- """
- # faire attention aux commentaires contenus dans self.texte
- # qui peuvent eux-memes contenir des parentheses !!!!
- l_lignes = self.texte.split("\n")
- nb = 0
- for ligne in l_lignes:
- ligne = ligne.split("#")[0]
- # nb = nb + (string.count(ligne,'(')-string.count(ligne,')'))
-
- nb = nb + (ligne.count("(") - ligne.count(")"))
- return nb
-
-
-class AFFECTATION(ENTITE_JDC):
- def appendText(self, texte):
- """
- Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
- PN et tout commentaire
- """
- if texte[-1] == "\n":
- texte = texte[0:-1].rstrip()
- if texte[-1] == ";":
- texte = texte[0:-1].rstrip()
- self.texte = self.texte + texte + "\n"
-
- def __str__(self):
- """
- Retourne une expression de l'affectation comprehensible par ACCAS
- et exploitable par EFICAS
- """
- nom, valeur = self.texte.split("=", 1)
- n = nom.rstrip()
- nom = n.lstrip()
- if valeur[-1] == "\n":
- valeur = valeur[:-1]
- return n + " = PARAMETRE(nom='" + nom + "',valeur=" + valeur + ")\n"
-
-
-class COMMANDE_COMMENTARISEE(ENTITE_JDC):
- def appendText(self, texte):
- """
- Ajoute texte a self.texte en enlevant les doubles commentaires
- """
- texte = texte.strip()
- texte = texte[2:].strip()
- self.texte = self.texte + (len(self.texte) > 0) * "\n" + texte
-
- def __str__(self):
- """
- Retourne une expression de la commande commentarisee comprehensible par ACCAS
- et exploitable par EFICAS
- """
- return "COMMANDE_COMM(texte=" + repr(self.texte) + ")\n"
- # return "COMMANDE_COMM(texte='''"+self.texte+"''')\n"
-
-
-class AFFECTATION_EVAL(ENTITE_JDC):
- def appendText(self, texte):
- """
- Ajoute texte a self.texte en enlevant tout retour chariot
- """
- if texte[-1] == "\n":
- texte = texte[1:-1]
- self.texte = self.texte + texte
-
- def __str__(self):
- """
- Retourne une expression du parametre EVAL comprehensible par ACCAS
- et exploitable par EFICAS
- """
- nom, valeur = self.texte.split("=", 1)
- nom = nom.strip()
- if valeur[-1] == "\n":
- valeur = valeur[:-1]
- valeur = valeur.strip()
- return nom + " = PARAMETRE_EVAL(nom='" + nom + "',valeur='" + valeur + "')\n\n"
-
-
-class PARSEUR_PYTHON(object):
- """
- Cette classe sert a generer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
- representant un JDC Python en distinguant :
- - les commentaires inter commandes
- - les affectations
- - les commandes
- """
-
- pattern_commande = re.compile(r"^([A-Z][a-zA-Z0-9_]+)([ \t\r\f\v]*)\(([\w\W]*)")
- pattern_eval = re.compile(r"^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)")
- pattern_ligne_vide = re.compile(r"^[\t\r\f\v\n]+")
- pattern_name = re.compile(r"[a-zA-Z_]\w*")
-
- def __init__(self, texte):
- self.texte = texte
- self.l_objets = None
- self.appliEficas = None
-
- def isAffectation(self, texte):
- """
- Methode booleenne qui retourne :
- 1 si le texte est celui d'une affectation dans un jeu de commandes
- 0 sinon
- """
- if "=" not in texte:
- return 0
- if self.pattern_commande.match(texte):
- # cas d'une procedure ...
- return 0
- amont, aval = texte.split("=", 1)
- aval = aval.strip()
-
- if self.pattern_commande.match(aval):
- return 0
- else:
- s = amont.strip()
- m = self.pattern_name.match(s)
- if m is None:
- return 0
- if m.start() != 0:
- return 0
- if m.end() != len(s):
- return 0
- return 1
-
- def isEval(self, texte):
- """
- Methode booleenne qui retourne 1 si le texte est celui d'une affectation de type EVAL
- dans un jeu de commandes Aster, 0 sinon
- """
- if "=" not in texte:
- return 0
- if self.pattern_commande.match(texte):
- # cas d'une procedure ...
- return 0
- amont, aval = texte.split("=", 1)
- aval = aval.strip()
- if not self.pattern_commande.match(aval):
- return 0
- if self.pattern_eval.match(aval):
- return 1
- else:
- return 0
-
- def isCommande(self, texte):
- """
- Methode booleenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
- Aster, 0 sinon
- """
- if self.pattern_commande.match(texte):
- # cas d'une procedure ...
- return 1
- # A ce stade il faut avoir un OPER ou une MACRO, bref un '=' !
- if "=" not in texte:
- return 0
- # on a un texte de la forme xxxx = yyyyy
- # --> reste a analyser yyyy
- amont, aval = texte.split("=", 1)
- aval = aval.strip()
- if self.pattern_commande.match(aval):
- return 1
- else:
- return 0
-
- def isModificationCatalogue(self, texte):
- if self.pattern_commande.match(texte):
- return 1
-
- def analyse(self):
- """
- Eclate la chaine self.texte en self.l_objets une liste lignes d'instructions
- et de commentaires (parmi lesquels des instructions "commentarisees").
- """
- l_lignes = self.texte.split("\n")
- commentaire_courant = None
- commande_courante = None
- affectation_courante = None
- commande_commentarisee_courante = None
- self.l_objets = []
-
- # initialisation du nombre de parentheses non fermees et de commentaires non termines
- # Attention a reinitialiser en fin de ligne logique
- # Une ligne logique peut s'etendre sur plusieurs lignes physiques avec des caracteres de continuation
- # explicites ou implicites
- hangingBraces = list(emptyHangingBraces)
- hangingComments = 0
-
- # Masquage des commentaires et strings multilignes
- srcMasked = maskStringsAndComments("\n".join(l_lignes))
- masked_lines = srcMasked.split("\n")
- lineno = 0
-
- for ligne in l_lignes:
- line = masked_lines[lineno]
- lineno = lineno + 1
- # print ("ligne:",line)
- # mise a jour du nombre total de parentheses ouvertes (non fermees)
- # et du nombre de commentaires non termines
- for i in range(len(implicitContinuationChars)):
- contchar = implicitContinuationChars[i]
- numHanging = hangingBraces[i]
- hangingBraces[i] = (
- numHanging + line.count(contchar[0]) - line.count(contchar[1])
- )
-
- hangingComments ^= line.count('"""') % 2
- hangingComments ^= line.count("'''") % 2
- # print (hangingComments,hangingBraces)
- if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0:
- raise parserException()
-
- if ligne.strip() == "":
- # il s'agit d'un saut de ligne
- # --> on l'ignore
- continue
-
- if pattern_2comments.match(ligne):
- # on a trouve une commande commentarisee : double commentaire sans rien devant a part des blancs
- if commentaire_courant:
- # Si un commentaire ordinaire est en cours on le termine
- commentaire_courant = None
-
- if commande_courante:
- # on a un objet commentarise a l'interieur d'une commande
- # --> non traite pour l'instant : on l'ajoute simplement a la commande courante comme
- # un commentaire ordinaire
- commande_courante.appendText(ligne)
- elif commande_commentarisee_courante:
- # commande_commentarisee en cours : on ajoute la ligne
- commande_commentarisee_courante.appendText(ligne)
- # on a 2 commandes commentarisees de suite
- if pattern_finComments.match(ligne):
- commande_commentarisee_courante = None
- else:
- # debut de commande commentarisee : on cree un objet commande_commentarisee_courante
- commande_commentarisee_courante = COMMANDE_COMMENTARISEE(self)
- commande_commentarisee_courante.appendText(ligne)
-
- # on passe a la ligne suivante
- continue
-
- if pattern_comment.match(ligne):
- # commentaire ordinaire avec seulement des blancs devant
- if commande_commentarisee_courante:
- # commande_commentarisee en cours : on la clot
- commande_commentarisee_courante = None
-
- if commande_courante:
- # il s'agit d'un commentaire a l'interieur d'une commande --> on ne fait rien de special
- # on l'ajoute au texte de la commande
- commande_courante.appendText(ligne)
- elif commentaire_courant:
- # il s'agit de la nieme ligne d'un commentaire entre deux commandes
- # --> on ajoute cette ligne au commentaire courant
- commentaire_courant.appendText(ligne)
- else:
- # il s'agit d'un nouveau commentaire entre deux commandes
- # --> on le cree et il devient le commentaire courant
- commentaire_courant = COMMENTAIRE(self)
- commentaire_courant.appendText(ligne)
-
- # on passe a la ligne suivante
- continue
-
- # la ligne contient des donnees autre qu'un eventuel commentaire
- if commentaire_courant:
- # on clot un eventuel commentaire courant
- commentaire_courant = None
-
- if commande_commentarisee_courante:
- # on clot une eventuelle commande commentarisee courante
- commande_commentarisee_courante = None
-
- if commande_courante:
- # on a une commande en cours. On l'enrichit ou on la termine
- commande_courante.appendText(ligne)
- if (
- not linecontinueRE.search(line)
- and (hangingBraces == emptyHangingBraces)
- and not hangingComments
- ):
- # la commande est terminee
- self.analyseReel(commande_courante.texte)
- commande_courante = None
-
- # on passe a la ligne suivante
- continue
-
- if affectation_courante != None:
- # poursuite d'une affectation
- affectation_courante.appendText(ligne)
- if (
- not linecontinueRE.search(line)
- and (hangingBraces == emptyHangingBraces)
- and not hangingComments
- ):
- # L'affectation est terminee
- affectation_courante = None
- # on passe a la ligne suivante
- continue
-
- # il peut s'agir d'une commande ou d'une affectation ...
- # ou d'un EVAL !!!
- if self.isEval(ligne):
- # --> affectation de type EVAL
- if affectation_courante:
- affectation_courante = None
- affectation = AFFECTATION_EVAL(self)
- affectation.appendText(ligne)
- # on passe a la ligne suivante
- continue
-
- if self.isAffectation(ligne):
- # print( '--> affectation')
- text = ligne
- # traitement des commentaires en fin de ligne
- compos = line.find("#")
- if compos > 2:
- # commentaire en fin de ligne
- # on cree un nouveau commentaire avant le parametre
- COMMENTAIRE(self).appendText(ligne[compos:])
- text = ligne[:compos]
- # si plusieurs instructions separees par des ; sur la meme ligne
- inspos = line.find(";")
- if inspos > 2:
- # on garde seulement la premiere partie de la ligne
- # si on a que des blancs apres le point virgule
- if text[inspos:].strip() == ";":
- text = text[:inspos]
- else:
- raise FatalError(
- tr(
- "Eficas ne peut pas traiter plusieurs instructions \
- sur la meme ligne : %s",
- ligne,
- )
- )
-
- affectation_courante = AFFECTATION(self)
- affectation_courante.appendText(text)
- if (
- not linecontinueRE.search(line)
- and (hangingBraces == emptyHangingBraces)
- and not hangingComments
- ):
- # L'affectation est terminee
- affectation_courante = None
- # on passe a la ligne suivante
- continue
-
- if self.isCommande(ligne):
- # --> nouvelle commande
- affectation_courante = None
- commande_courante = COMMANDE(self)
- commande_courante.appendText(ligne)
- # si la commande est complete, on la termine
- if (
- not linecontinueRE.search(line)
- and (hangingBraces == emptyHangingBraces)
- and not hangingComments
- ):
- # la commande est terminee
- self.analyseReel(commande_courante.texte)
- commande_courante = None
- # on passe a la ligne suivante
- continue
-
- def enleve(self, texte):
- """Supprime de texte tous les caracteres blancs, fins de ligne, tabulations
- Le nouveau texte est retourne
- """
- i = 0
- chaine = ""
- while i < len(texte):
- if texte[i] == " " or texte[i] == "\n" or texte[i] == "\t":
- i = i + 1
- else:
- chaine = chaine + texte[i]
- i = i + 1
- return chaine
-
- def construitGenea(self, texte):
- indiceC = 0
- mot = ""
- dict_reel_concept = {}
-
- # traitement pour chaque caractere
- while indiceC < len(texte):
- c = texte[indiceC]
- if c == "," or c == "(u" or c == ")":
- mot = ""
- elif c == "=":
- # on doit trouver derriere soit une valeur soit une parenthese
- valeur = ""
- nouvelindice = indiceC + 1
- if texte[nouvelindice] != "(u":
- # pas de parenthese ouvrante derriere un signe =, on a une valeur.
- while texte[nouvelindice] != "," and texte[nouvelindice] != ")":
- valeur = valeur + texte[nouvelindice]
- nouvelindice = nouvelindice + 1
- if nouvelindice == len(texte):
- nouvelindice = nouvelindice - 1
- break
- if mot in self.appliEficas.liste_simp_reel:
- if valeur[0] != "'":
- try:
- clef = eval(valeur)
- if str(clef) != str(valeur):
- dict_reel_concept[clef] = valeur
- except:
- pass
- mot = ""
- indiceC = nouvelindice
- else:
- # parenthese ouvrante derriere un signe =, on a un tuple de valeur ou de mots cles facteurs.
- # s agit -il d un tuple
- if texte[nouvelindice + 1] != "(u":
- # le suivant n'est pas une parenthese ouvrante : on a un tuple de valeurs ou un mot cle facteur
- tuple = False
- # on avance jusqu'a la fin du tuple de valeurs ou jusqu'a la fin du premier mot cle simple
- # contenu dans le mot cle facteur
- while texte[nouvelindice] != "=":
- if texte[nouvelindice] == ")":
- tuple = True
- break
- else:
- nouvelindice = nouvelindice + 1
- if nouvelindice == len(texte):
- nouvelindice = nouvelindice - 1
- break
- if tuple:
- # cas du tuple de valeurs
- valeur = texte[indiceC + 1 : nouvelindice + 1]
- indiceC = nouvelindice + 1
- if mot in self.appliEficas.liste_simp_reel:
- valeur = valeur[1:-1]
- for val in valeur.split(","):
- # Attention la derniere valeur est""
- try:
- if val[0] != "'":
- clef = eval(val)
- if str(clef) != str(val):
- dict_reel_concept[clef] = val
- except:
- pass
- mot = ""
- # ou de ( imbriquees
- else:
- # cas du mocle facteur simple ou
- mot = ""
- else:
- mot = mot + texte[indiceC]
- indiceC = indiceC + 1
- # traitement du dernier inutile
- # c est un ;
- return dict_reel_concept
-
- def analyseReel(self, commande):
- nomConcept = None
- # On verifie qu on a bien un OPER
- # et pas une MACRO
- if commande.find("=") > commande.find("(u"):
- return
- if commande.find("=") > 0:
- # epure1=self.enleve(commande)
- epure1 = pattern_blancs.sub("", commande)
- nomConcept, corps = epure1.split("=", 1)
- epure2 = corps.replace("_F(u", "(u")
- # nomConcept=epure1.split(u"=")[0]
- # index=epure1.find(u"=")
- # epure2=epure1[index+1:len(epure1)].replace(u"_F(u","(u")
- # dict_reel_concept=self.construitGenea(epure2)
- if self.appliEficas:
- dict_reel_concept = construitGenea(
- epure2, self.appliEficas.liste_simp_reel
- )
- else:
- dict_reel_concept = {}
- if nomConcept == "sansnom":
- nomConcept = ""
- if nomConcept != None:
- if len(dict_reel_concept) != 0:
- self.appliEficas.dict_reels[nomConcept] = dict_reel_concept
-
- def getTexte(self, appliEficas=None):
- """
- Retourne le texte issu de l'analyse
- """
- self.appliEficas = appliEficas
- try:
- # if 1:
- if not self.l_objets:
- self.analyse()
- txt = ""
- for obj in self.l_objets:
- txt = txt + str(obj)
- # else :
- except parserException:
- # Impossible de convertir le texte, on le retourne tel que
- txt = self.texte
- return txt
-
-
-def test():
- # import parseur_python
- import doctest
-
- doctest.testmod(parseur_python)
-
-
-if __name__ == "__main__":
- import time
-
- # fichier = 'D:/Eficas_dev/Tests/zzzz100a.comm'
- # fichier = 'U:/Eficas_dev/Tests/test_eval.comm'
- with open(fichier) as fd:
- texte = fd.read()
-
- class appliEficas(object):
- dict_reels = {}
- liste_simp_reel = ["VALE", "VALE_C", "GROUP_MA", "RAYON"]
-
- a = appliEficas()
-
- compile(txt, "<string>", "exec")
- print((a.dict_reels))
+++ /dev/null
-# -*- coding: utf-8 -*-
-import raw.cata_map_genere as mdm
-mdm.pyxb.GlobalValidationConfig._setContentInfluencesGeneration(mdm.pyxb.GlobalValidationConfig.ALWAYS)
-mdm.pyxb.GlobalValidationConfig._setInvalidElementInContent(mdm.pyxb.GlobalValidationConfig.RAISE_EXCEPTION)
-mdm.pyxb.GlobalValidationConfig._setOrphanElementInContent(mdm.pyxb.GlobalValidationConfig.RAISE_EXCEPTION)
-
-
-print dir(mdm)
+++ /dev/null
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2024 EDF R&D
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-
-install ( FILES __init__.py generator_python.py Formatage.py generator_aplat.py
- generator_dicoImbrique.py generator_dico.py generator_modification.py generator_vers3DSalome.py
- generator_TELEMAC.py generator_map.py generator_GroupMA.py
- DESTINATION ${CMAKE_INSTALL_PREFIX}/generator
- )
-
-
-
-# Installation des fichiers : CARMEL
-if (WITH_CARMEL)
- install ( FILES generator_CARMEL3D_frequentiel.py generator_CARMEL3D_temporel.py
- DESTINATION ${CMAKE_INSTALL_PREFIX}/generator
- )
-endif (WITH_CARMEL)
-
-
-
-
-### Local Variables:
-### mode: cmake
-### End:
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient la classe Formatage qui permet le formatage d'une
- liste de chaines de caractères dans une syntaxe représentative d'un
- jeu de commandes en un texte présentable
-"""
-from builtins import object
-import types, re
-from Extensions.i18n import tr
-
-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
-
- 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
- + ("\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é 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)
- 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(("\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 + ","
-
- 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
-
-
-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
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce package contient tous les generateurs de formats de sortie
- a partir des objets d' EFICAS.
-
- Ces generateurs sont implementes sous forme de plugins
-"""
-
-from Extensions import pluginloader
-
-import generator
-
-plugins = pluginloader.PluginLoader(generator)
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-import traceback
-from Extensions.i18n import tr
-from generator.generator_python import PythonGenerator
-
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- # name: Le nom du plugin
- # factory: La factory pour creer une instance du plugin
- """
- return {
- "name": "5CRequeteSelection",
- "factory": RequeteSelectionGenerator,
- }
-
-
-class RequeteSelectionGenerator(PythonGenerator):
- """
- Ce generateur parcourt un etapeSelectionet de type JDC et produit
- un texte pour requeter la base
- """
-
- # Les extensions de fichier permis?
- pass
- extensions = (".comm",)
-
- # ----------------------------------------------------------------------------------------
- def genereRequeteSelection(self, jdc):
- debug = 0
-
- texteRequete = "select id from JobPerformance where "
- etapeSelection = jdc.etapes[0]
- if debug:
- print("appelle genereRequeteSelection avec jdc", jdc)
- if debug:
- print("etapeSelection", etapeSelection)
-
- # L etapeSelection n est pas valide : Tout est obligatoire or tout n est pas rempli
- # On se contente de verifier les regles d afficher les regles non valides
- # en enelvant les motclefs invalides
- listeRegles = etapeSelection.getRegles()
- dictObjPresents = etapeSelection.dictMcPresents(restreint="oui")
- dictObjPresentsValides = {}
-
- for nomObj, obj in dictObjPresents.items():
- if obj.isValid():
- dictObjPresentsValides[nomObj] = obj
- if debug:
- print("dictObjPresentsValides", dictObjPresentsValides)
-
- commentaire = "Les données sont insuffisantes pour générer les requetes : \n"
- reglesOk = 1
- texteErreurs = []
- if len(listeRegles) > 0:
- for regle in listeRegles:
- if debug:
- print(regle)
- texteRegle = regle.getText()
- texteMauvais, test = regle.verif(dictObjPresentsValides)
- if debug:
- print(texteMauvais, test)
- if not test:
- reglesOk = 0
- texteErreurs.append(texteMauvais)
- if not reglesOk:
- return 0, commentaire, "".join(texteErreurs)
-
- separateur = ""
- for nomObj, obj in dictObjPresentsValides.items():
- texteRequete += separateur
- texteRequete += nomObj
- if nomObj.startswith("Debut"):
- operateur = ">"
- elif nomObj.endswith("Fin"):
- operateur = "<"
- else:
- operateur = "="
- texteRequete += operateur
- lesTypes = obj.getType()
- if "TXM" in lesTypes:
- texteRequete += "'"
- texteRequete += str(obj.valeur)
- if "TXM" in lesTypes:
- texteRequete += "'"
- separateur = " and "
- return 1, "requete generee : ", texteRequete
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur d une liste des GroupNo et GroupMA
-"""
-import traceback
-import types, re
-
-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": "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
-
- """
-
- # Les extensions de fichier preconisees
- extensions = (".comm",)
-
- 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 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
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-from builtins import str
-
-import traceback
-import types, re, os
-from Extensions.i18n import tr
-from .generator_python import PythonGenerator
-
-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,
- }
-
-
-class TELEMACGenerator(PythonGenerator):
- """
- 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
-
- # ----------------------------------------------------------------------------------------
- # initialisations
- # ----------------------------------------------------------------------------------------
-
- 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 = ""
-
- # ----------------------------------------------------------------------------------------
- # 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()
-
- # ----------------------------------------------------------------------------------------
- # ecriture de Leger
- # ----------------------------------------------------------------------------------------
-
- 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):
- if not self.commentaireAvant or self.texteCom.find(obj.nom) < 0:
- self.texteDico += (
- "/------------------------------------------------------------------/\n"
- )
- self.texteDico += "/\t\t\t" + obj.nom + "\n"
- self.texteDico += (
- "/------------------------------------------------------------------/\n"
- )
- self.commentaireAvant = False
- self.texteCom = ""
- s = PythonGenerator.generPROC_ETAPE(self, obj)
- if obj.nom in TELEMACGenerator.__dict__:
- TELEMACGenerator.__dict__[obj.nom](*(self, obj))
-
- return s
-
- def generMCSIMP(self, obj):
- """recuperation de l objet MCSIMP"""
- s = PythonGenerator.generMCSIMP(self, obj)
-
- # Attention pas sur --> ds certains cas non traite par MCFACT ?
- # 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
-
- # nomMajuscule=obj.nom.upper()
- # nom=nomMajuscule.replace('_',' ')
- # if nom in listeSupprime or s == "" : return s
- 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 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 self.langue == "fr":
- s1 = str(sTelemac).replace("True", "OUI")
- s2 = s1.replace("False", "NON")
- else:
- 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 s3 != "" and s3[0] == "(":
- try:
- s3 = s3[1:-1] # cas de liste vide
- except:
- s3 = " "
-
- # LIQUID_BOUNDARIES
- # if obj.nom in ('PRESCRIBED_FLOWRATES','PRESCRIBED_VELOCITIES','PRESCRIBED_ELEVATIONS') :
- # return s
-
- # cas des Tuples
- if obj.waitTuple() and s3 != "" and s3 != "None":
- s3 = s
- if s3[-1] == ",":
- s3 = s3[:-1]
-
- if obj.nom not in self.dicoCataToCas:
- 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",
- "VARIABLES FOR 3D GRAPHIC PRINTOUTS",
- "VARIABLES POUR LES SORTIES GRAPHIQUES 3D",
- "VARIABLES POUR LES SORTIES GRAPHIQUES 2D",
- "VARIABLES FOR 2D GRAPHIC PRINTOUTS",
- "C_VSM_PRINTOUT_SELECTION",
- ]:
- if s3 != "" and s3 != "None":
- s3 = s3.replace(";", ",")
- s3 = "'" + s3 + "'"
- else:
- s3 = "''"
- if nom in ["COUPLING WITH", "COUPLAGE AVEC"]:
- s3 = (
- s3.strip()
- .replace("\n", "")
- .replace(" ", "")
- .replace("\t", "")
- .replace("';'", ",")
- )
- 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.0, 1.0, 1.0, 1.0]
- 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)
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- UQ pour EFICAS.
-
-"""
-from builtins import str
-
-import traceback
-import types, re, os
-import Accas
-
-from .generator_python import PythonGenerator
-
-# texteUranie present dans le banc Reacteur Numerique
-# textePresalys present hors le banc Reacteur Numerique
-try:
- from .texteUranie import SCRIPT_URANIE
-except:
- pass
-
-try:
- from .textePersalys import (
- headerScriptPersalys,
- fonctionPersalys,
- etudeScript,
- codePersalys,
- )
- from .textePersalys import mainPersalys, inputHeaderPersalys, outputHeaderPersalys
- from .textePersalys import getResultCall, getResultCallAvoidPersalysBug
- from .textePersalys import centralTendencyTaylor, resultTaylor
- from .textePersalys import optionalResultTaylor, optionalPrintResultTaylor
- from .textePersalys import centralTendencyMC, resultMC
- from .textePersalys import critereArretMC, advancedParameterMC
- from .textePersalys import optionalResultMC, optionalPrintResultMC
- from .textePersalys import printResultMC, printResultTaylor
- from .textePersalys import (
- yacsJobParameters,
- yacsJobClusterParameters,
- yacsJobClusterMultiJob,
- )
-
- genereScriptPersalys = True
-except:
- genereScriptPersalys = False
-
-genereScriptPersalys = False
-
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
-
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- "name": "UQ",
- # La factory pour creer une instance du plugin
- "factory": UQGenerator,
- }
-
-
-class UQGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas 'normal'
- un texte au format eficas avec balise
- un script python permettant de piloter Persalys
-
- """
-
- def gener(self, jdc, format="beautifie"):
- self.indent1 = " "
-
- # On remet a jour les MCPath
- self.jdc = jdc
- self.recalculeMCPath()
- if jdc.nature != "JDC" or not jdc.isValid():
- ret, commentaire = self.sauveUniquementCommEt_UQComm(jdc)
- if not ret:
- return (ret, commentaire)
- self.commentaire = "Le JDC doit etre valide pour generer le script de lancement et le fichier à balises\n"
- self.commentaire += (
- "Seuls les fichiers _det.comm et .comm ont été sauvegardés"
- )
- return 2
- ret, commentaire = self.analyseIncertitude()
- if not ret:
- self.commentaire = commentaire
- return ret
- self.inGenerUQ = True
- self.generDeterministe = False
- self.textUQ = PythonGenerator.gener(self, jdc, format)
- self.inGenerUQ = False
- self.generDeterministe = True
- self.text = PythonGenerator.gener(self, jdc, format)
- return self.text
-
- def creeNomsFichiers(self, fichier):
- self.cheminFichierComm = os.path.abspath(os.path.dirname(fichier))
- if fichier.endswith(".xml"):
- self.fichierSansSuffixe = os.path.basename(fichier[:-5])
- elif fichier.endswith(".comm"):
- self.fichierSansSuffixe = os.path.basename(fichier[:-5])
- else:
- self.commentaire = "Le nom du fichier doit finir par .comm ou .xml\n"
- return (
- 0,
- "le fichier jeux de données |"
- + fichier
- + "| doit être suffixé par .comm",
- )
- self.fichierComm = self.fichierSansSuffixe + ".comm"
- self.fichierDetComm = self.fichierSansSuffixe + "_det.comm"
- self.fichierBalise = self.fichierSansSuffixe + "_@det.comm"
- self.fichierUQExe = self.fichierSansSuffixe + "_UQ.py"
- self.fichierUQModule = os.path.basename(self.fichierUQExe)[:-3]
- return (1, "")
-
- def sauveUniquementCommEt_UQComm(self, jdc):
- self.inGenerUQ = False
- self.generDeterministe = True
- self.text = PythonGenerator.gener(self, jdc, "beautifie")
- fichierDetComm = os.path.join(self.cheminFichierComm, self.fichierDetComm)
- if not self.writeFile(fichierDetComm):
- return (0, "impossible de sauvegarder le _det.comm")
- self.generDeterministe = False
- self.text = PythonGenerator.gener(self, jdc, "beautifie")
- fichierComm = os.path.join(self.cheminFichierComm, self.fichierComm)
- if not self.writeFile(fichierComm):
- return (0, "impossible de sauvegarder le .comm")
- return (1, "")
-
- def writeUQ(self, fichier):
- # il manque le checksum
- fichierBalise = os.path.join(self.cheminFichierComm, self.fichierBalise)
- fichierUQExe = os.path.join(self.cheminFichierComm, self.fichierUQExe)
- try:
- with open(fichierBalise, "w") as fp:
- fp.write(self.textUQ)
- except:
- return (0, "impossible de sauvegarder le _@det.py")
- try:
- # if 1 :
- with open(fichierUQExe, "w") as fp:
- fp.write(self.txtScript)
- except:
- if self.txtScript != "":
- return (0, "impossible de sauvegarder le .py")
- # a reecrire pour ne pas appeler trop de fois le gener
- retour, commentaire = self.sauveUniquementCommEt_UQComm(self.jdc)
- if not retour:
- return (retour, commentaire)
- return (1, None)
-
- def generPROC_ETAPE(self, obj):
- if not self.inGenerUQ:
- return PythonGenerator.generPROC_ETAPE(self, obj)
- if obj.nom == "ExpressionIncertitude" and self.inGenerUQ:
- return ""
- else:
- return PythonGenerator.generPROC_ETAPE(self, obj)
- # il faut remplacer @xxx@
- # DU coup qu est ce que xxx
-
- def generMCSIMP(self, obj):
- # inutile tant que FACT et BLOC ne sont pas surcharges
- if obj.nom == "Consigne":
- return
- if not self.inGenerUQ:
- return PythonGenerator.generMCSIMP(self, obj)
- if not obj in self.mcIncertains:
- return PythonGenerator.generMCSIMP(self, obj)
- else:
- # a refaire si on decide que les incertains sont sous des fact multiples
- # ce qui ne me parait pas possible mais ?
- if obj.etape.nature == "OPERATEUR":
- return "@ " + obj.etape.sd.nom + "__" + obj.nom + " @,"
- else:
- return "@ " + obj.nom + " @,"
-
- def recalculeMCPath(self):
- etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude")
- if len(etapeIncertitude) != 1:
- return
- etapeIncertitude = etapeIncertitude[0]
- self.lesVariablesInput = etapeIncertitude.getChild("Input")[
- 0
- ].getChildOrChildInBloc("VariableProbabiliste")
- index = 0
- for mc in self.lesVariablesInput.data:
- itemMCPath = mc.getChild("MCPath")
- itemMCPath.setValeur(mc.variableDeterministe.getMCPath())
-
- def analyseIncertitude(self):
- from functools import reduce as reduce
-
- self.txtScriptPersalys = ""
- self.txtScript = ""
- etapeScenarioData = self.jdc.getEtapesByName("Scenario_data")
- if etapeScenarioData == []:
- return (
- 0,
- "il faut au moins un mot-clef Scenario_data",
- ) # TODO : à Résorber après modification du catalogue
- if len(etapeScenarioData) != 1:
- return (
- 0,
- "il faut au plus un mot-clef Scenario_data",
- ) # TODO : à Résorber après modification du catalogue
- etapeScenarioData = etapeScenarioData[0]
- self.ScenarioType = etapeScenarioData.getChildOrChildInBloc(
- "scenario_type"
- ).valeur
-
- etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude")
- if etapeIncertitude == []:
- return (0, "il faut au moins un mot-clef ExpressionIncertitude")
- if len(etapeIncertitude) != 1:
- return (0, "il faut au plus un mot-clef ExpressionIncertitude")
- etapeIncertitude = etapeIncertitude[0]
-
- incertitudeInput = etapeIncertitude.getChildOrChildInBloc("Input")
- self.lesVariablesInput = incertitudeInput[0].getChildOrChildInBloc(
- "VariableProbabiliste"
- )
- self.mcIncertains = []
- self.nomsDesVariablesInput = []
- self.chaineDesVariablesInput = ""
- for mc in self.lesVariablesInput:
- if mc.variableDeterministe.etape.nature == "OPERATEUR":
- self.chaineDesVariablesInput += (
- mc.variableDeterministe.etape.sd.nom
- + "__"
- + mc.variableDeterministe.nom
- + ", "
- )
- self.nomsDesVariablesInput.append(
- mc.variableDeterministe.etape.sd.nom
- + "__"
- + mc.variableDeterministe.nom
- )
- else:
- self.chaineDesVariablesInput += mc.variableDeterministe.nom + ", "
- self.nomsDesVariablesInput.append(mc.variableDeterministe.nom)
- self.mcIncertains.append(mc.variableDeterministe)
-
- sectionOutput = etapeIncertitude.getChildOrChildInBloc("Output")[0]
- self.ScriptPosttraitement = sectionOutput.getChildOrChildInBloc(
- "ScriptPosttraitement"
- )
- # dans le cas du catalogue UQ gere dans le banc RN, ScriptPosttraitement n existe pas
- if self.ScriptPosttraitement:
- self.ScriptPosttraitement = sectionOutput.getChildOrChildInBloc(
- "ScriptPosttraitement"
- ).valeur
- if isinstance(self.ScriptPosttraitement, Accas.PARAMETRE):
- self.ScriptPosttraitement = self.ScriptPosttraitement.valeur
- self.chaineDesVariablesInput = self.chaineDesVariablesInput[0:-2]
-
- # Cas RN OpenTurns ScriptPosttraitement = None
- # on ne fait pas le return : la suite du traitement est necessaire a uranie
- sectionPropagation = etapeIncertitude.getChildOrChildInBloc("Propagation")[0]
- self.Methode = sectionPropagation.getChildOrChildInBloc("Methode").valeur
- if not sectionPropagation.getChildOrChildInBloc("Result"):
- self.Result = None
- else:
- self.Result = sectionPropagation.getChildOrChildInBloc("Result")[0]
- if self.Methode == "MonteCarlo":
- self.critereArret = sectionPropagation.getChildOrChildInBloc(
- "CritereArret"
- )[0]
- if sectionPropagation.getChildOrChildInBloc("EvaluationParameter"):
- sectionEvaluationParameter = sectionPropagation.getChildOrChildInBloc(
- "EvaluationParameter"
- )[0]
- self.Blocksize = sectionEvaluationParameter.getChildOrChildInBloc(
- "BlockSize"
- ).valeur
- self.advancedParameter = sectionPropagation.getChildOrChildInBloc(
- "AdvancedParameter"
- )
- if self.advancedParameter != None:
- self.advancedParameter = self.advancedParameter[0]
- # self.ComputeConfidenceIntervalAt = self.advancedParameter.getChildOrChildInBloc('ComputeConfidenceIntervalAt')[0]
- # self.Seed = self.advancedParameter.getChildOrChildInBloc('Seed')[0]
- self.lesVariablesOutput = sectionOutput.getChildOrChildInBloc(
- "VariableDeSortie"
- )
- self.chaineDesVariablesOutputEncodee = ""
- self.txtOutputVariableInitList = ""
- self.txtGetAllResults = ""
- # TODO? from cata_UQ import FonctionDAggregationDict
- fctAggPy = {
- "valeur à t=O": "vInitialTime",
- "valeur à mi-temps": "vHalfTime",
- "valeur à t final": "vFinalTime",
- "valeur moyenne": "vMean",
- "valeur cumulée": "vSum",
- "valeur minimale": "vMin",
- "valeur maximale": "vMax",
- }
-
- index = 0
- self.resultSkList = [0]
- for mc in self.lesVariablesOutput:
- nomShortVariableOutputList = ""
- nomFctAggPyList = ""
- nomOutputList = ""
- nomVar = mc.getChildOrChildInBloc("VariablePhysique").valeur
- nomVarEncode = nomVar.replace(" ", "__") # TODO : function
- nomVarPostraite = mc.getChildOrChildInBloc(
- "VariablePosttraiteeAssociee"
- ).valeur
- nomFctAggList = mc.getChildOrChildInBloc("FonctionDAggregation").valeur
- for nomFctAgg in nomFctAggList:
- nomFctAggPy = fctAggPy[nomFctAgg]
- nomFctAggPyList += nomFctAggPy + ", "
- nomOutput = nomVarEncode + "_" + nomFctAggPy
- nomOutputList += nomOutput + ", "
- self.chaineDesVariablesOutputEncodee += nomOutput + ", "
- variablesOutputDesc = (
- '("' + nomFctAgg + '","' + nomVarPostraite + '")'
- ) # TODO : Interdire ',' dans FctAgg et nomVarPost
- nomShortVariableOutputList += (
- "a" + str(index) + ", "
- ) # Avoid a Persalys Bug
- index += 1
- self.txtOutputVariableInitList += (
- self.indent1
- + nomOutput
- + " = persalys.Output('"
- + nomVar
- + " ("
- + nomFctAgg
- + ")"
- + "', '"
- + variablesOutputDesc
- + "')\n"
- )
- # tmpGetResultCall = getResultCall.format(
- tmpGetResultCall = (
- getResultCallAvoidPersalysBug.format( # Avoid a Persalys Bug
- variableOutputList=nomOutputList[0:-2],
- nomVarPostraite=nomVarPostraite,
- fonctionAggregationList=nomFctAggPyList[0:-2],
- shortVariableOutputList=nomShortVariableOutputList[
- 0:-2
- ], # Avoid a Persalys Bug
- )
- )
- self.txtGetAllResults += tmpGetResultCall
- self.resultSkList.append(index)
-
- self.chaineDesVariablesOutputEncodee = self.chaineDesVariablesOutputEncodee[
- 0:-2
- ]
- self.chaineDesShortVariablesOutput = reduce(
- lambda x, y: x + y, ["a" + str(i) + ", " for i in range(index)]
- )[0:-2]
-
- sectionExecution = etapeIncertitude.getChildOrChildInBloc("Execution")[0]
- if (
- etapeIncertitude.getChildOrChildInBloc("UncertaintyTool").valeur
- == "Persalys"
- ):
- self.NbDeBranches = sectionExecution.getChildOrChildInBloc(
- "NbDeBranches"
- ).valeur
- if genereScriptPersalys:
- if sectionExecution.getChildOrChildInBloc("ExecutionMode") != None:
- self.ExecutionMode = sectionExecution.getChildOrChildInBloc(
- "ExecutionMode"
- ).valeur
- self.JobName = sectionExecution.getChildOrChildInBloc("JobName").valeur
- self.ResourceName = sectionExecution.getChildOrChildInBloc(
- "ResourceName"
- ).valeur
- self.Login = sectionExecution.getChildOrChildInBloc("Login").valeur
- self.WorkDirectory = sectionExecution.getChildOrChildInBloc(
- "WorkDirectory"
- ).valeur
- self.ResultDirectory = sectionExecution.getChildOrChildInBloc(
- "ResultDirectory"
- ).valeur
- self.UncertaintyScript = sectionExecution.getChildOrChildInBloc(
- "UncertaintyScript"
- ).valeur
- if isinstance(self.UncertaintyScript, Accas.PARAMETRE):
- self.UncertaintyScript = self.UncertaintyScript.valeur
- print("self.UncertaintyScript : ", self.UncertaintyScript)
- NbOfProcs = sectionExecution.getChildOrChildInBloc(
- "NbOfProcs"
- ) # None si 'desktop', vérification à faire ds jobmanager
- MultiJobStudy = sectionExecution.getChildOrChildInBloc(
- "MultiJobStudy"
- ) # None si 'desktop'
- if NbOfProcs != None:
- self.NbOfProcs = NbOfProcs.valeur
- else:
- self.NbOfProcs = None
- if MultiJobStudy != None:
- self.MultiJobStudy = MultiJobStudy.valeur
- else:
- self.MultiJobStudy = None
- self.creeScriptPersalys()
- if etapeIncertitude.getChildOrChildInBloc("UncertaintyTool").valeur == "Uranie":
- if (
- sectionExecution.getChildOrChildInBloc("ExecutionMode").valeur
- == "desktop"
- ):
- self.ExecutionMode = sectionExecution.getChildOrChildInBloc(
- "ExecutionMode"
- ).valeur
- self.visualization = sectionExecution.getChildOrChildInBloc(
- "visualization"
- ).valeur
- self.sample_size = sectionExecution.getChildOrChildInBloc(
- "sample_size"
- ).valeur
- self.launcher_type = sectionExecution.getChildOrChildInBloc(
- "launcher_type"
- ).valeur
- if self.launcher_type == "distrib":
- self.parallel_execs = sectionExecution.getChildOrChildInBloc(
- "parallel_executions"
- ).valeur
- self.WorkDirectory = sectionExecution.getChildOrChildInBloc(
- "UWorkDirectory"
- ).valeur
- self.ResultDirectory = sectionExecution.getChildOrChildInBloc(
- "UResultDirectory"
- ).valeur
- self.cree_script_uranie()
-
- elif (
- sectionExecution.getChildOrChildInBloc("ExecutionMode").valeur
- == "cluster"
- ):
- self.ExecutionMode = sectionExecution.getChildOrChildInBloc(
- "ExecutionMode"
- ).valeur
- self.sample_size = sectionExecution.getChildOrChildInBloc(
- "sample_size"
- ).valeur
- self.parallel_execs = sectionExecution.getChildOrChildInBloc(
- "parallel_executions"
- ).valeur
- self.WorkDirectory = sectionExecution.getChildOrChildInBloc(
- "UWorkDirectory"
- ).valeur
- self.ResultDirectory = sectionExecution.getChildOrChildInBloc(
- "UResultDirectory"
- ).valeur
- self.nb_of_tasks = sectionExecution.getChildOrChildInBloc(
- "nb_of_tasks"
- ).valeur
- self.nb_of_cpu_per_task = sectionExecution.getChildOrChildInBloc(
- "nb_of_cpu_per_task"
- ).valeur
- self.memory_per_cpu = sectionExecution.getChildOrChildInBloc(
- "memory_per_cpu"
- ).valeur
- self.partitions = sectionExecution.getChildOrChildInBloc(
- "partitions"
- ).valeur
- self.qos = sectionExecution.getChildOrChildInBloc("qos").valeur
- self.account = sectionExecution.getChildOrChildInBloc("account").valeur
- self.walltime = sectionExecution.getChildOrChildInBloc(
- "walltime"
- ).valeur
- self.job_name = sectionExecution.getChildOrChildInBloc(
- "job_name"
- ).valeur
- self.output_file = sectionExecution.getChildOrChildInBloc(
- "output_file"
- ).valeur
- self.error_file = sectionExecution.getChildOrChildInBloc(
- "error_file"
- ).valeur
- self.email = sectionExecution.getChildOrChildInBloc("email").valeur
- self.email_type = sectionExecution.getChildOrChildInBloc(
- "email_type"
- ).valeur
- self.liste_of_nodes = sectionExecution.getChildOrChildInBloc(
- "liste_of_nodes"
- ).valeur
- self.myscript_to_launch = sectionExecution.getChildOrChildInBloc(
- "myscript_to_launch"
- ).valeur
- self.cree_script_uranie()
-
- return (1, "")
-
- def cree_script_uranie(self, debug: bool = False):
- import pickle
- import logging
- import shutil
- import uranie_interface.uncertainty_data as uncertainty_data
- import uranie_interface.serialize_data as serialize_data
-
- if debug:
- print("def cree_script_uranie(self, debug = True):")
-
- generatorDir = os.path.abspath(os.path.dirname(__file__))
- if debug:
- print("generatorDir: ", generatorDir)
-
- ## inputs ##
- u_inputs = uncertainty_data.Inputs()
- for mc in self.lesVariablesInput:
- if mc.variableDeterministe.etape.nature == "OPERATEUR":
- name = (
- mc.variableDeterministe.etape.sd.nom
- + "__"
- + mc.variableDeterministe.nom
- )
- else:
- name = mc.variableDeterministe.nom
- balise = " @" + name + "@ "
- object_name = mc.variableDeterministe.etape.sd.nom
- model_variable = mc.variableDeterministe.nom
-
- distribution_info = u_inputs.Distribution()
- distribution = mc.getChildOrChildInBloc("Distribution").valeur
- if distribution == "Uniform":
- lower_bound = mc.getChildOrChildInBloc("A").valeur
- upper_bound = mc.getChildOrChildInBloc("B").valeur
- distribution_info.add_distribution_uniform(
- distribution, lower_bound, upper_bound
- )
- elif distribution == "TruncatedNormal":
- lower_bound = mc.getChildOrChildInBloc("A").valeur
- upper_bound = mc.getChildOrChildInBloc("B").valeur
- standard_deviation = mc.getChildOrChildInBloc("SigmaN").valeur
- mean = mc.getChildOrChildInBloc("MuN").valeur
- distribution_info.add_distribution_truncated_normal(
- distribution, lower_bound, upper_bound, mean, standard_deviation
- )
- else:
- values = mc.getChildOrChildInBloc("Values").valeur
- distribution_info.add_distribution_user_defined(distribution, values)
-
- if debug:
- print("balise = ", balise)
- flag = balise.replace(" ", "")
- if debug:
- print("flag = ", flag)
- u_inputs.add_input(
- balise,
- object_name,
- model_variable,
- distribution_info.distribution_info,
- flag,
- )
-
- if debug:
- print("len(u_inputs.inputs) = ", len(u_inputs.inputs))
- for i in range(0, len(u_inputs.inputs)):
- print(f"u_inputs.inputs[{i}].balise = {u_inputs.inputs[i].balise}")
- print(
- f"u_inputs.inputs[{i}].balise_flag = {u_inputs.inputs[i].balise_flag}"
- )
- print(
- f"u_inputs.inputs[{i}].object_name = {u_inputs.inputs[i].object_name}"
- )
- print(
- f"u_inputs.inputs[{i}].model_variable = {u_inputs.inputs[i].model_variable}"
- )
- if u_inputs.inputs[i].distribution_info[0].distribution == "Uniform":
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].distribution = "
- f"{u_inputs.inputs[i].distribution_info[0].distribution}"
- )
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].lower_bound = "
- f"{u_inputs.inputs[i].distribution_info[0].lower_bound}"
- )
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].upper_bound = "
- f"{u_inputs.inputs[i].distribution_info[0].upper_bound}"
- )
- elif (
- u_inputs.inputs[i].distribution_info[0].distribution
- == "TruncatedNormal"
- ):
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].distribution = "
- f"{u_inputs.inputs[i].distribution_info[0].distribution}"
- )
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].lower_bound = "
- f"{u_inputs.inputs[i].distribution_info[0].lower_bound}"
- )
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].upper_bound = "
- f"{u_inputs.inputs[i].distribution_info[0].upper_bound}"
- )
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].standard_deviation = "
- f"{u_inputs.inputs[i].distribution_info[0].standard_deviation}"
- )
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].mean = "
- f"{u_inputs.inputs[i].distribution_info[0].mean}"
- )
- elif (
- u_inputs.inputs[i].distribution_info[0].distribution
- == "UserDefined"
- ):
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].distribution = "
- f"{u_inputs.inputs[i].distribution_info[0].distribution}"
- )
- print(
- f"u_inputs.inputs[{i}].distribution_info[0].values = "
- f"{u_inputs.inputs[i].distribution_info[0].values}"
- )
-
- file_balise_dot_comm = self.fichierBalise
- u_inputs.add_file_balise_dot_comm(file_balise_dot_comm)
- if debug:
- print("u_inputs.file_balise_dot_comm = ", u_inputs.file_balise_dot_comm)
-
- ## propagation ##
- u_propagation = uncertainty_data.Propagation()
- u_propagation.set_sampling_method(self.Methode)
- if debug:
- print("u_propagation.sampling_method = ", self.Methode)
-
- ## outputs ##
- u_outputs = uncertainty_data.Outputs()
- aggregation_functions = u_outputs.AggregationFunction()
- agg_fct_py = {
- "valeur_a_t=0": "vInitialTime",
- "valeur_a_mi_temps": "vHalfTime",
- "valeur_a_t_final": "vFinalTime",
- "valeur_moyenne": "vMean",
- "valeur_cumulee": "vSum",
- "valeur_minimale": "vMin",
- "valeur_maximale": "vMax",
- }
- if debug:
- print(
- "GENERATOR_UQ.PY: self.lesVariablesOutput = ", self.lesVariablesOutput
- ) # self.lesVariablesOutput.valeur
- for mc in self.lesVariablesOutput:
- type_of_physics = mc.getChildOrChildInBloc("Physique").valeur
- variable_physics = mc.getChildOrChildInBloc("VariablePhysique").valeur
- var_post_processed = mc.getChildOrChildInBloc(
- "VariablePosttraiteeAssociee"
- ).valeur
- nom_agg_fct_list = mc.getChildOrChildInBloc("FonctionDAggregation").valeur
- if debug:
- print("GENERATOR_UQ.PY: nom_agg_fct_list = ", nom_agg_fct_list)
- for nom_agg_fct in nom_agg_fct_list:
- nom_agg_fct = nom_agg_fct.replace(" ", "_")
- nom_agg_fct = nom_agg_fct.replace("-", "_")
- nom_agg_fct = nom_agg_fct.replace("O", "0")
- nom_agg_fct = nom_agg_fct.replace("à", "a")
- nom_agg_fct = nom_agg_fct.replace("é", "e")
- aggregation_functions.add_aggregation_function(
- nom_agg_fct, agg_fct_py[nom_agg_fct]
- )
- if debug:
- print("GENERATOR_UQ.PY: nom_agg_fct_list = ", nom_agg_fct_list)
-
- u_outputs.add_output(
- type_of_physics,
- variable_physics,
- var_post_processed,
- aggregation_functions.aggregation_functions,
- )
- if debug:
- for i in range(0, len(u_outputs.outputs)):
- print(
- f"u_outputs.outputs[{i}].type_of_physics = "
- f"{u_outputs.outputs[i].type_of_physics}"
- )
- print(
- f"u_outputs.outputs[{i}].variable_physics = "
- f"{u_outputs.outputs[i].variable_physics}"
- )
- print(
- f"u_outputs.outputs[{i}].var_post_processed = "
- f"{u_outputs.outputs[i].var_post_processed}"
- )
- print(
- f"u_outputs.outputs[{i}].aggregation_functions = "
- f"{u_outputs.outputs[i].aggregation_functions}"
- )
- for cle, valeur in u_outputs.outputs[
- i
- ].aggregation_functions.items():
- print(
- "nom_agg_fct = ", cle, ", aggregation_function = ", valeur
- )
-
- ## execution ##
- u_execution = uncertainty_data.Execution()
- u_execution.set_execution_mode(self.ExecutionMode)
- if self.ExecutionMode == "desktop":
- u_execution.set_visualization(self.visualization)
- u_execution.set_sample_size(self.sample_size)
- u_execution.set_launcher_type(self.launcher_type)
- if self.launcher_type == "distrib":
- u_execution.set_parallel_execs(self.parallel_execs)
- u_execution.set_work_dir_name(self.WorkDirectory)
- u_execution.set_output_dir_name(self.ResultDirectory)
-
- elif self.ExecutionMode == "cluster":
- u_execution.set_sample_size(self.sample_size)
- u_execution.set_parallel_execs(self.parallel_execs)
- u_execution.set_work_dir_name(self.WorkDirectory)
- u_execution.set_output_dir_name(self.ResultDirectory)
- u_execution.set_nb_of_tasks(self.nb_of_tasks)
- u_execution.set_nb_of_cpu_per_task(self.nb_of_cpu_per_task)
- u_execution.set_memory_per_cpu(self.memory_per_cpu)
- u_execution.set_partitions(self.partitions)
- u_execution.set_qos(self.qos)
- u_execution.set_account(self.account)
- u_execution.set_walltime(self.walltime)
- u_execution.set_job_name(self.job_name)
- u_execution.set_output_file(self.output_file)
- u_execution.set_error_file(self.error_file)
- u_execution.set_email(self.email)
- u_execution.set_email_type(self.email_type)
- u_execution.set_liste_of_nodes(self.liste_of_nodes)
- u_execution.set_myscript_to_launch(self.myscript_to_launch)
-
- if debug:
- if self.ExecutionMode == "desktop":
- print("u_execution.visualization = ", u_execution.visualization)
- print("u_execution.sample_size = ", u_execution.sample_size)
- print("u_execution.launcher_type = ", u_execution.launcher_type)
- if self.launcher_type == "distrib":
- print("u_execution.parallel_execs = ", u_execution.parallel_execs)
- print("u_execution.work_dir_name = ", u_execution.work_dir_name)
- print("u_execution.output_dir_name = ", u_execution.output_dir_name)
-
- elif self.ExecutionMode == "cluster":
- print("u_execution.sample_size = ", u_execution.sample_size)
- print("u_execution.parallel_execs = ", u_execution.parallel_execs)
- print("u_execution.work_dir_name = ", u_execution.work_dir_name)
- print(
- "u_execution.output_dir_name = ", u_execution.output_dir_name
- )
- print("u_execution.nb_of_tasks = ", u_execution.nb_of_tasks)
- print(
- "u_execution.nb_of_cpu_per_task = ",
- u_execution.nb_of_cpu_per_task,
- )
- print("u_execution.memory_per_cpu = ", u_execution.memory_per_cpu)
- print("u_execution.partitions = ", u_execution.partitions)
- print("u_execution.qos = ", u_execution.qos)
- print("u_execution.account = ", u_execution.account)
- print("u_execution.walltime = ", u_execution.walltime)
- print("u_execution.job_name = ", u_execution.job_name)
- print("u_execution.output_file = ", u_execution.output_file)
- print("u_execution.error_file = ", u_execution.error_file)
- print("u_execution.email = ", u_execution.email)
- print("u_execution.email_type = ", u_execution.email_type)
- print("u_execution.liste_of_nodes = ", u_execution.liste_of_nodes)
- print(
- "u_execution.myscript_to_launch = ",
- u_execution.myscript_to_launch,
- )
-
- # Creat the pickle_dir_name directory
- pickle_dir_name = "." + u_execution.output_dir_name + "_uncertainty_parameters"
- pickle_dir_name_path = os.path.join(u_execution.work_dir_name, pickle_dir_name)
- print("pickle_dir_name_path = ", pickle_dir_name_path)
- if os.path.exists(pickle_dir_name_path):
- choice = input(
- f"The output directory '{pickle_dir_name_path}' already exist."
- f" Do you want to overwrite it ? (y/n): "
- ).lower()
- yess = ["y", "yes"]
- nos = ["n", "no"]
- while choice not in yess and choice not in nos:
- choice = input("Please choose 'y' (yes) or 'n' (no)")
- if choice in yess:
- shutil.rmtree(pickle_dir_name_path)
- os.makedirs(pickle_dir_name_path, exist_ok=True)
- print("Overwriting of the directory... Done !")
- else:
- logging.log(
- logging.WARNING, "Execution terminated. Directory is not removed."
- )
- return 1
- else:
- os.makedirs(pickle_dir_name_path, exist_ok=True)
- print("Writing of the directory... Done !")
-
- serialize_data.save(
- pickle_dir_name_path, u_inputs, u_propagation, u_outputs, u_execution
- )
-
- self.txtScript = SCRIPT_URANIE.format(pickle_dir=pickle_dir_name_path)
-
- def parseMcInputVariable(self, mc, indent):
- if mc.variableDeterministe.etape.nature == "OPERATEUR":
- nom = (
- mc.variableDeterministe.etape.sd.nom
- + "__"
- + mc.variableDeterministe.nom
- )
- else:
- nom = mc.variableDeterministe.nom
- loiDistribution = mc.getChildOrChildInBloc("Distribution").valeur
-
- # on cherche le bloc qui contient ce qui est necessaire a la loi
- # on est confiant !!!! sur l adequation du catalogue et des attributs des lois persalys
- # reflechir a cela
- chaineArgs = ""
- leBlocDesArgs = None
- for mc in mc.mcListe:
- if (mc.nom).find("b_Model_Variable_") == 0:
- for mcFils in mc.mcListe:
- if mcFils.nom.find(loiDistribution) > 1:
- leBlocDesArgs = mcFils
- break
- if not leBlocDesArgs:
- print("souci pour dumper la loi")
- return ""
- for mcFils in leBlocDesArgs.mcListe:
- chaineArgs += str(mcFils.valeur) + ", "
-
- return nom, loiDistribution, chaineArgs[0:-2]
-
- def creeTexteInputVariables(self, indent):
- texte = ""
- for v in self.lesVariablesInput:
- nomVariableInput, loiDistribution, chaineArgs = self.parseMcInputVariable(
- v, indent
- )
- texte += "{}{} = persalys.Input('{}', ot.{}(".format(
- indent, nomVariableInput, nomVariableInput, loiDistribution
- )
- texte += chaineArgs + "))\n"
-
- return texte
-
- def creeTexteInputVariablesSummary(self, indent):
- texte = ""
- for v in self.lesVariablesInput:
- nomVariableInput, loiDistribution, chaineArgs = self.parseMcInputVariable(
- v, indent
- )
- texte += "{}'{}{} : {}({})\\n'\n".format(
- 2 * indent, indent, nomVariableInput, loiDistribution, chaineArgs
- )
- # texte+=chaineArgs[0:-2]+'))\n'
- # texte+='\n'
-
- return texte[0:-1]
-
- def creeScriptPersalys(self, debug=True):
- from functools import reduce
-
- # chaineDesVariablesInput=reduce(lambda x,y:x+','+y,l)
- def getStrVarList(l, sep=","):
- return reduce(lambda x, y: str(x) + sep + str(y), l)
-
- def getStrVarStrList(l, sep=","):
- return reduce(
- lambda x, y: x + sep + y, map(lambda x: "'" + str(x) + "'", l)
- )
-
- def getStrInitList(l):
- return getStrVarList(
- map(lambda x: "self.{} = {}".format(x, x), l), "\n" + 2 * self.indent1
- )
-
- def getStrReplaceVarList(l):
- return getStrVarList(
- map(lambda x: "'@ {} @': repr(self.{})".format(x, x), l), ","
- )
-
- def getStrSelfVarList(l):
- return getStrVarList(map(lambda x: "self.{}".format(x), l), ",")
-
- generatorDir = os.path.abspath(os.path.dirname(__file__))
- nomEtude = "monEtude" # TODO
- if debug:
- print("nomEtude : ", nomEtude, "generatorDir :", generatorDir)
-
- self.txtScriptPersalys += headerScriptPersalys
-
- # TODO: Résorber le cas particulier du HLO en mettant les options de lancement ds le catalog
- if self.ScenarioType == "HLO":
- txtUncertaintyScriptParameters = (
- self.fichierComm + " --cocagne-thermo-solver\ FaSTT"
- )
- else:
- txtUncertaintyScriptParameters = self.fichierComm
-
- print("self.nomsDesVariablesInput :", self.nomsDesVariablesInput)
- self.txtScriptPersalys += etudeScript.format(
- chaineDesVariablesInput=self.chaineDesVariablesInput,
- chaineSelfDesVariablesInput=getStrSelfVarList(self.nomsDesVariablesInput),
- chaineInitDesVariablesInput=getStrInitList(self.nomsDesVariablesInput),
- commFileBalise=self.fichierBalise,
- commFile=self.fichierComm,
- nproc=self.NbOfProcs, # En local le nombre de procs est inutile
- # sauf si lancement mpi externe au script applicatif
- # auquel cas != NbOfTasks du jobmanager car
- # on ne compte pas les threads
- replaceDataList=getStrReplaceVarList(self.nomsDesVariablesInput),
- uncertaintyScript=os.path.basename(self.UncertaintyScript),
- uncertaintyScriptParameters=txtUncertaintyScriptParameters,
- workDirectory=self.WorkDirectory,
- )
-
- txtFonctionPersalys = fonctionPersalys.format(
- currentFile=self.fichierUQModule,
- chaineDesVariablesInput=self.chaineDesVariablesInput,
- getAllResults=self.txtGetAllResults,
- # chaineDesVariablesOutput = self.chaineDesVariablesOutputEncodee
- chaineDesVariablesOutput=self.chaineDesShortVariablesOutput, # Avoid a Persalys Bug until v9.9
- )
- self.txtScriptPersalys += codePersalys.format(
- fonctionPersalys=txtFonctionPersalys
- )
-
- ## Propagation des incertitudes :
- ## Choix de la méthode, de ses paramètres, et des résultats attendus
- if self.Methode == "Taylor":
- txtCentralTendencyPersalys = centralTendencyTaylor
- optionalResult = optionalResultTaylor
- optionalPrintResult = optionalPrintResultTaylor
- printResult = printResultTaylor
- txtResultCT = resultTaylor
- elif self.Methode == "MonteCarlo":
- critereArret = ""
- for mc in self.critereArret.mcListe:
- critereArret += (
- self.indent1
- + critereArretMC[mc.nom].format(**{mc.nom: mc.valeur})
- + "\n"
- )
-
- txtAdvancedParameterMC = ""
- advancedParameter = ""
- if self.advancedParameter != None:
- for mc in self.advancedParameter.mcListe:
- advancedParameter += (
- self.indent1
- + advancedParameterMC[mc.nom].format(**{mc.nom: mc.valeur})
- + "\n"
- )
-
- txtCentralTendencyPersalys = centralTendencyMC.format(
- critereArretMC=critereArret,
- advancedParameterMC=advancedParameter,
- BlockSize=self.Blocksize,
- )
- optionalResult = optionalResultMC
- optionalPrintResult = optionalPrintResultMC
- printResult = printResultMC
- txtResultCT = resultMC
- else:
- return (0, "Impossible de gérer la méthode :", self.Methode)
-
- result = ""
- optionalResultNames = []
- if self.Result:
- for mc in self.Result.mcListe:
- # print('mc : ',mc)
- # print('mc.nature : ',mc.nature)
- # print('mc.valeur : ',mc.valeur)
- if mc.nom == "EmpiricalQuantile" and mc.valeur == "yes":
- mc_nom = (
- mc.nom[0].lower() + mc.nom[1:]
- ) ##TODO: Utiliser un nv dict commun des symboles avec optionalResult
- optionalResultNames.append(mc_nom)
- empiricalQuantile_Order = self.Result.getChildOrChildInBloc(
- "EmpiricalQuantile_Order"
- )
- result += (
- self.indent1
- + optionalResult[mc.nom].format(
- **{
- empiricalQuantile_Order.nom: empiricalQuantile_Order.valeur
- }
- )
- + "\n"
- )
- result += (
- self.indent1
- + optionalPrintResult["EmpiricalQuantile_Order"]
- + "\n"
- )
- result += self.indent1 + optionalPrintResult[mc.nom] + "\n"
- elif mc.nature == "MCSIMP" and mc.valeur == "yes":
- mc_nom = (
- mc.nom[0].lower() + mc.nom[1:]
- ) ##TODO: Utiliser un nv dict commun des symboles avec optionalResult
- optionalResultNames.append(mc_nom)
- result += self.indent1 + optionalResult[mc.nom] + "\n"
- # result+= self.indent1+optionalPrintResult[mc.nom] + '\n'
-
- # print('result:',result)
- # print('txtResultCT:',txtResultCT)
- optionalResultList = getStrVarList(optionalResultNames)
- optionalResultStrList = getStrVarStrList(optionalResultNames)
- post_csv_rnScript = os.path.basename(self.ScriptPosttraitement).split(".")[0]
- post_csv_rnPath = os.path.dirname(self.ScriptPosttraitement)
- print(post_csv_rnScript)
- print(post_csv_rnPath)
- txtPrintResult = printResult.format(
- post_csv_rnScript=post_csv_rnScript,
- post_csv_rnPath=post_csv_rnPath,
- optionalResultList=optionalResultList,
- optionalResultStrList=optionalResultStrList,
- resultSkList=getStrVarList(self.resultSkList),
- Uncertain_inputs=self.creeTexteInputVariablesSummary(self.indent1),
- )
- txtResult = txtResultCT.format(optionalResult=result)
- txtResult += txtPrintResult
-
- # TODO ;: Tester si Cluster== Gaia, ajouter les champs suivants
- # resourceName = 'gaia'
- # login='C65845'
- # workDirectory = '/scratch/'+login+'/workingdir/persalys_light' #TODO: path.join
- # resultDirectory = '/tmp/result_0'
- wckey = "P11N0:SALOME"
-
- inFiles = []
- inFiles.append(os.path.join(generatorDir, "incertainty_tools.py"))
- pyFile = self.fichierUQExe
- inFiles.append(os.path.join(self.cheminFichierComm, pyFile))
- pyFile = self.fichierBalise
- inFiles.append(os.path.join(self.cheminFichierComm, pyFile))
- scriptFile = os.path.abspath(self.UncertaintyScript)
- inFiles.append(scriptFile)
- postFile = os.path.abspath(self.ScriptPosttraitement)
- inFiles.append(postFile)
-
- if self.ExecutionMode == "cluster":
- txtYacsJobClusterParameters = yacsJobClusterParameters.format(
- nprocs=self.NbOfProcs, wckey=wckey
- )
- else:
- txtYacsJobClusterParameters = ""
-
- txtYacsJobParameters = yacsJobParameters.format(
- nomEtude=self.JobName,
- workDirectory=self.WorkDirectory,
- resultDirectory=self.ResultDirectory,
- resourceName=self.ResourceName,
- nbBranches=self.NbDeBranches,
- inFiles=repr(inFiles),
- )
- txtYacsJobParameters += txtYacsJobClusterParameters
- if self.MultiJobStudy != None and self.MultiJobStudy == True:
- txtYacsJobParameters += yacsJobClusterMultiJob
-
- self.txtScriptPersalys += mainPersalys.format(
- nomEtude=nomEtude,
- inputVariableInitList=self.creeTexteInputVariables(self.indent1),
- outputVariableInitList=self.txtOutputVariableInitList,
- # outputVariableInitList = '#Not yet implemented',
- inputHeaderPersalys=inputHeaderPersalys.format(indent=self.indent1),
- chaineDesVariablesInput=self.chaineDesVariablesInput,
- outputHeaderPersalys=outputHeaderPersalys.format(indent=self.indent1),
- chaineDesVariablesOutput=self.chaineDesVariablesOutputEncodee,
- yacsJobParameters=txtYacsJobParameters,
- centralTendencyPersalys=txtCentralTendencyPersalys,
- scenarioType=self.ScenarioType,
- resultPersalys=txtResult,
- )
- self.txtScript = self.txtScriptPersalys
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-from builtins import str
-
-import traceback
-import types, re, os
-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,
- }
-
-
-class XMLGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
-
- """
-
- # Les extensions de fichier permis?
- extensions = (".comm",)
-
- # ----------------------------------------------------------------------------------------
- def gener(
- self, obj, format="brut", config=None, appliEficas=None, uniteAsAttribut=False
- ):
- # try :
- if 1:
- self.texteXML = obj.toXml()
- # except :
- # self.texteXML='Erreur a la generation du fichier XML'
- # 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):
- if self.texteXML == "Erreur a la generation du fichier XML":
- print(self.texteXML)
- return 0
- fileXML = fn[: fn.rfind(".")] + ".xml"
- # filePyxb = fn[:fn.rfind(".")] + '.py'
- fileBase = os.path.basename(fileXML)
- fileBase = fileBase[: fileBase.rfind(".")] + ".py"
- filePyxb = "/tmp/example_" + 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")
- self.textePourAide = 'txt=""' + "\n" + self.textePourAide
- self.textePourAide = self.textePourAide + "print (txt)" + "\n"
- f.write(str(self.textePourAide))
- f.close()
- return 1
-
- def generMCSIMP(self, obj):
- if obj.nom != "Consigne":
- 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
- if obj.definition.avecBlancs:
- self.textePourAide += (
- nomUtil + " = vimmpCase." + obj.getNomDsXML() + ".s\n"
- )
- else:
- self.textePourAide += (
- nomUtil + " = vimmpCase." + obj.getNomDsXML() + "\n"
- )
- self.textePourAide += (
- 'txt += "' + nomUtil + '" + " = " +str( ' + nomUtil + ')+"\\n"' + "\n"
- )
-
- s = PythonGenerator.generMCSIMP(self, obj)
- return s
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- aplat pour EFICAS.
-
-"""
-try:
- from builtins import str
- from builtins import object
-except:
- pass
-
-import traceback
-import types, re
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
-
-from Noyau import N_CR
-from Noyau.N_utils import repr_float
-from Accas import ETAPE, PROC_ETAPE, MACRO_ETAPE, ETAPE_NIVEAU, JDC, FORM_ETAPE
-from Accas import MCSIMP, MCFACT, MCBLOC, MCList, EVAL
-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
-
- 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.lNiveaux == ():
- # 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
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-from builtins import str
-
-import traceback
-import types, re, os
-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,
- }
-
-
-class DicoGenerator(PythonGenerator):
- """
- 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",)
-
- # ----------------------------------------------------------------------------------------
- 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 generDico(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.dicoComm
-
- # ----------------------------------------------------------------------------------------
- # initialisations
- # ----------------------------------------------------------------------------------------
-
- def initDico(self):
- self.dicoComm = {}
- self.rang = 0
-
- # ----------------------------------------------------------------------------------------
- # ecriture
- # ----------------------------------------------------------------------------------------
-
- def writeDefault(self, fn):
- fileDico = fn[: fn.rfind(".")] + ".py"
- f = open(str(fileDico), "w")
- f.write("dicoComm = " + str(self.dicoComm))
- f.close()
-
- # ----------------------------------------------------------------------------------------
- # analyse de chaque noeud de l'arbre
- # ----------------------------------------------------------------------------------------
-
- def generMCSIMP(self, obj):
- """recuperation de l objet MCSIMP"""
- s = PythonGenerator.generMCSIMP(self, obj)
- listeParents = []
- objTraite = obj
- while hasattr(objTraite, "parent") and objTraite.parent != None:
- objTraite = objTraite.parent
- if objTraite.nature == "JDC":
- break
- if objTraite.nature == "BLOC":
- continue
- if objTraite.nature == "OPERATEUR" or objTraite.nature == "PROCEDURE":
- listeParents.insert(0, objTraite)
- elif objTraite.nature == "MCList":
- if len(objTraite.data > 1):
- monRang = objTraite.data.index(objTraite)
- listeParents.insert(0, objTraite.nom + "_" + str(monRang))
- else:
- listeParents.insert(0, objTraite.nom)
- else:
- listeParents.insert(0, objTraite.nom)
- courant = self.dicoComm
- # On traite l etape pour ajouter le rang et la classe
- etape = listeParents[0]
- ordreId = etape.parent.etapes.index(etape)
- if etape.nature == "OPERATEUR":
- if not etape.sd.nom in courant.keys():
- courant[etape.sd.nom] = {}
- courant[etape.sd.nom]["@classeAccas"] = etape.nom
- courant[etape.sd.nom]["@ordreAccas"] = ordreId
- courant = courant[etape.sd.nom]
- else:
- if not etape.nom in courant.keys():
- courant[etape.nom] = {}
- courant[etape.nom]["@classeAccas"] = etape.nom
- courant[etape.nom]["@ordreAccas"] = ordreId
- courant = courant[etape.nom]
- else:
- if not (isinstance(courant[etape.nom], list)):
- laListe = [
- courant[etape.nom],
- ]
- courant[etape.nom] = laListe
- newDict = {}
- newDict["@classeAccas"] = etape.nom
- newDict["@ordreAccas"] = ordreId
- courant[etape.nom].append(newDict)
- courant = newDict
- for p in listeParents[1:]:
- if not (p in courant.keys()):
- courant[p] = {}
- courant = courant[p]
- # on transforme les concepts en nom
- laValeur = self.transformeObjInRef(obj)
- courant[obj.nom] = laValeur
- return s
-
- def transformeObjInRef(self, obj):
- # cas d une matrice d ASSD
- for ssType in obj.definition.type:
- if hasattr(ssType, "typElt"):
- if ssType.typElt not in ("R", "I", "C", "TXM"):
- # on a une matrice d ASSD
- listeLigne = []
- for ligne in obj.val:
- col = []
- for elt in ligne:
- col.append(elt.nom)
- listeLigne.append(col)
- return listeLigne
- waitASSDTuple = 0
- if type(obj.valeur) in (tuple, list):
- for ss_type in obj.definition.type:
- if repr(ss_type).find("Tuple") != -1:
- if hasattr(ssType, "typeDesTuples"):
- for t in ssType.typeDesTuples:
- if t not in ("R", "I", "C", "TXM"):
- waitASSDTuple = 1
- break
- elif ss_type not in ("R", "I", "C", "TXM"):
- waitASSDTuple = 1
- if waitASSDTuple:
- listeRetour = []
- for elt in obj.val:
- if hasattr(elt, "nom"):
- listeRetour.append(elt.nom)
- else:
- listeRetour.append(elt)
- return listeRetour
-
- if hasattr(obj.val, "nom"):
- listeRetour.append(obj.val.nom)
- return obj.val
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-from builtins import str
-
-import traceback
-import types, re, os
-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,
- }
-
-
-class DicoImbriqueGenerator(PythonGenerator):
- """
- 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",)
-
- # ----------------------------------------------------------------------------------------
- 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 = ""
-
- # ----------------------------------------------------------------------------------------
- # ecriture
- # ----------------------------------------------------------------------------------------
-
- def writeDefault(self, fn):
- fileDico = fn[: fn.rfind(".")] + ".py"
- f = open(str(fileDico), "w")
-
- f.write("Dico =" + str(self.Dico))
- # f.write( self.Entete + "Dico =" + str(self.Dico) )
- f.close()
-
- # ----------------------------------------------------------------------------------------
- # analyse de chaque noeud de l'arbre
- # ----------------------------------------------------------------------------------------
-
- 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
-
- 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 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 hasattr(obj.valeur, "nom"):
- dicoCourant[nomFeuille] = obj.valeur.nom
- 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
- self.Dico[nom] = dicoCourant
-
- return s
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module sert pour charger les parametres de configuration d'EFICAS
-"""
-# Modules Python
-from builtins import str
-from builtins import object
-
-import os, sys, types, re
-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"
- )
-
- return texteModification
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- python pour EFICAS.
-
-"""
-from builtins import str
-from builtins import object
-from builtins import range
-
-import traceback
-import types, re
-
-from Noyau import N_CR
-from Noyau.N_utils import repr_float
-import Accas
-import Extensions
-from Extensions.parametre import ITEM_PARAMETRE
-from generator.Formatage import Formatage
-from generator.Formatage import FormatageLigne
-from Extensions.param2 import Formula
-from Extensions.eficas_exception import EficasException
-from Extensions.i18n import tr
-
-
-def entryPoint():
- """
- 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,
- }
-
-
-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):
- try:
- with open(filename, "w") as fp:
- fp.write(self.text)
- return 1
- except:
- return 0
-
- 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
- """
- if obj == None:
- return
- self.appliEficas = appliEficas
- liste = self.generator(obj)
- 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):
- l.append(self.generUserASSD(obj.sdsDict[objRef]))
- if obj.definition.lNiveaux == ():
- # 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):
- """
- Methode particuliere pour les objets de type FORMULE
- """
- l = []
- nom = obj.getNom()
- if nom == "":
- nom = "sansnom"
- l.append(nom + " = FORMULE(")
- for v in obj.mcListe:
- text = self.generator(v)
- l.append(v.nom + "=" + text)
- 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
- """
- if (
- obj.nom == "ExpressionIncertitude"
- and hasattr(self, "generDeterministe")
- and self.generDeterministe == True
- ):
- return ""
- 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)
- 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
- if v.nom != "Consigne":
- l.append(data)
- return l
-
- def formatItem(self, valeur, etape, obj, vientDeListe=0, matriceDAssd=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):
- # 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)
-
- elif matriceDAssd:
- s = "["
- for v in valeur:
- s = s + str(self.generator(v)) + ", "
-
- s = s + "]"
- 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
- matriceDAssd = 0
- for ssType in obj.definition.type:
- if hasattr(ssType, "typElt"):
- if ssType.typElt not in ("R", "I", "C", "TXM"):
- matriceDAssd = 1
- break
- 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, matriceDAssd) + ","
- 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 :
- 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
+++ /dev/null
-# -*- coding: utf-8 -*-
-import os
-
-
-def value_repr_name(values):
- """
- Create a directory name using the representation of the values.
- Example:
- >>> valueReprName([0.5, 3.0 / 7.0])
- 'c0.5_0.42857142857142855_'
- """
- s = "c"
- for v in values:
- s += repr(v) + "_"
- return s
-
-
-def hashname(values):
- """
- Create a directory name using a hash function.
- Example:
- >>> hashName([0.5, 3.0 / 7.0])
- '6f454e45e9a4fa8856688e80de6bfc58'
- """
- import hashlib
-
- h = hashlib.md5(repr(values))
- return h.hexdigest()
-
-
-def temp_dirname():
- """
- Create a temporary directory in the current directory.
- """
- import tempfile
-
- return tempfile.mkdtemp(dir=os.getcwd())
-
-
-def replace_data(filename, key_values, filename_out=""):
- """
- Modify an input file using replace function.
- Example:
- origin file: "CPHY_MAT_ISO= $rho $cp $lambda -1 "
- key_values: {'$rho':'3', '$cp':'5', '$lambda':7}
- modified file: "CPHY_MAT_ISO= 3 5 7 -1"
- """
- with open(filename, "r") as f:
- filedata = f.read()
- for key, value in key_values.items():
- filedata = filedata.replace(key, value)
- if len(filename_out) == 0:
- filename_out = filename
- with open(filename_out, "w") as f:
- f.write(filedata)
-
-
-def format_data(filename, key_values):
- """
- Modify an input file using format function.
- Example:
- origin file: "CPHY_MAT_ISO= {rho} {cp} {lambda} -1 "
- key_values: {'rho':'3', 'cp':'5', 'lambda':'7'}
- modified file: "CPHY_MAT_ISO= 3 5 7 -1"
- """
- with open(filename, "r") as f:
- filedata = f.read()
- filedata = filedata.format(**key_values)
- with open(filename, "w") as f:
- f.write(filedata)
+++ /dev/null
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
-Ce module contient les variables
-par defaut pour Aster
-"""
-
-from OpenturnsSTD import STDGenerateur
-from OpenturnsXML import XMLGenerateur
-
-#====================================================
-# Preparation du fichier STD
-#====================================================
-# C.1. Parties du texte en dur dans le fichier STD
-#-------------------------------------------------
-
-DecalSTD = " "
-DecalSTDsaut = "\n "
-
-TexteSTDFIN ="\n\nexcept : \n"
-TexteSTDFIN += DecalSTD + "error_message = sys.exc_type\n"
-TexteSTDFIN += "\nif error_message is not None :\n"
-TexteSTDFIN += DecalSTD + "texte = \"\\n=================================================\""
-TexteSTDFIN += DecalSTD + "texte += \"\\nMessage d'erreur : \" + str(error_message)"
-TexteSTDFIN += DecalSTD + "texte += \"\\n=================================================\\n\""
-TexteSTDFIN += DecalSTD + "print (texte)"
-TexteSTDFIN += DecalSTD + "\nsys.exit(error_message)\n"
-
-# C.2. Definition de composants dans le fichier STD
-#--------------------------------------------------
-
-NomFunction = "myFunction"
-NomPhysicalStartingPoint = "myPhysicalStartingPoint"
-NomCollection = "myCollection"
-NomCopule = "myCopula"
-NomDistribution = "myDistribution"
-NomRandomVector_in = "myRandomVector_in"
-NomRandomVector_out = "myRandomVector_out"
-NomEvent = "myEvent"
-NomMethod = "myMethod"
-NomAlgo = "myAlgo"
-NomRoot = "myRoot"
-NomSampling = "mySampling"
-NomSolverSD = "mySolver"
-NomResu = "myResu"
-
-class Defaut :
-# Cette classe ajoute les parametres par defaut propres au Solver Aster
-# Elle va d abord enrichir le dictionnaire DictMCVal avec des valeurs par defaut
-# C est la methode enrichitMCVal
-# Elle va ensuite enrichir les variables
-# C est la methode enrichitListeVariables
-
- def __init__(self, parent) :
- self.parent=parent
- self.enrichitMCVal()
- self.enrichitListeVariables()
-
-
- def enrichitMCVal(self) :
- #=====================
- # InformationSolver : nom du wrapper, type de fichiers d'echange, etc
- #----------------------------------------------------------------------
- # Ajoute les informations sur le wrapper
- # nom du wrapper, type de fichiers d'echange, etc.
- dico = { "WrapperPath" : "Code_Aster.so",
- "FunctionName" : "Code_Aster",
- "WrapCouplingMode" : "fork",
- "State" : "shared",
- "InDataTransfer" : "files",
- "OutDataTransfer" : "files",
- }
-
- self.parent.ajouteDictMCVal(dico)
-
- #InformationSolverFile : parametres par defaut pour les fichiers d'echange
- #--------------------------------------------------------------------------
-
- liste = []
- dicoIn = { "Id" : "file_in", "Type" : "in", "Name" : "StdIn", "Path" : "commandes_aster" }
- liste.append(dicoIn)
- dicoOut = { "Id" : "file_out", "Type" : "out", "Name" : "StdOut", "Path" : "resultats_aster", }
- liste.append(dicoOut)
- dicoFile={"exchange_file" : liste}
- self.parent.ajouteDictMCVal(dicoFile)
-
-# D.2. InformationSolverCommande : arguments, etc
-#-------------------------------------------------------------------------
-# InformationSolverCommande est un dictionnaire indexe par le nom du solveur externe appele.
-# InformationSolverCommande[solveur] est lui-meme un dictionnaire qui contient les parametres
-# supplementaires pour la commande.
-# Des parametres sont donnes sous forme de tuple : (ok/nok, "mot-cle") ou (ok/nok, "mot-cle", valeur)
-# . On ajoute seulement si ok
-# . Avec (ok/nok, "mot-cle"), on ajoute en arguments les couples ("mot-cle", nom_du_parametre)
-# . Avec (ok/nok, "mot-cle", valeur), on ajoute en arguments les couples ("mot-cle", valeur)
-
-
-# dico = { "file_out" : (1, "-fic_de_aster_vers_ot"),
-# "variable_in" : (1, "-variable") }
-# self.parent.InformationSolverCommande["Code_Aster"] = dico
-
-
- def enrichitListeVariables(self) :
- # parametres par defaut pour chaque variable
- #--------------------------------------------
-
- dico_in = { "Regexp" : '"^" , "Name", "(.*)= *[0-9eE.+-]+([)]?;?)$"',
- "Format" : '"Name", "\\1=%20.13G\\2"'
- }
- dico_out = { "Regexp" : '"(.*)"' }
- self.parent.ajouteInfoVariables(dico_in,dico_out)
-
-class MonSTDGenerateur(STDGenerateur) :
-
- def CreeResu (self) :
- #------------------
- '''
- Le resultat :
- . Donnees :
- . l'algorithme choisi.
- . Resultats :
- . Ecriture des odres d'impression.
- '''
- if self.DictMCVal.has_key("Analysis"):
- self.Analysis = str(self.DictMCVal["Analysis"])
- else :
- self.Analysis = None
- self.fic_resu_OpenTURNS = "fic_resu_OpenTURNS_glop"
- Algorithm = str (self.DictMCVal["Algorithm"])
- texte = "\n\n# Le resultat\n"
- texte += DecalSTDsaut + NomResu + " = " + NomAlgo + ".getResult()"
- texte += DecalSTDsaut + "###" + "print ( " + NomResu+")"
- texte += DecalSTDsaut + "text_resu = \"Resultats\\n=======\\n\""
-
-# Particularites des algorithmes de fiabilite
-
- if self.Analysis in ( "Reliability", ) :
- texte += DecalSTDsaut + "aux = " + NomResu + ".getIsStandardPointOriginInFailureSpace()"
- texte += DecalSTDsaut + "if aux :"
- texte += DecalSTDsaut + DecalSTD + "texte_bis = \"est\""
- texte += DecalSTDsaut + "else :"
- texte += DecalSTDsaut + DecalSTD + "texte_bis = \"n\'est pas\""
- texte += DecalSTDsaut + "text_resu += \"\\nLe point initial \" + texte_bis + \" dans l\'espace de defaillance.\""
- l_aux = [ ("Probabilite de defaillance", "EventProbability") ]
- l_aux.append ( ("Indice de confiance generalise", "GeneralisedReliabilityIndex") )
- l_aux.append ( ("Indice de confiance de Hasofer", "HasoferReliabilityIndex") )
- for t_aux in l_aux :
- texte += DecalSTDsaut + "text_resu += \"\\n" + t_aux[0] + " = \" + str(" \
- + NomResu + ".get" + t_aux[1] + "())"
- l_aux = []
- l_aux.append("StandardSpaceDesignPoint")
- l_aux.append("PhysicalSpaceDesignPoint")
- l_aux.append("ImportanceFactors")
- texte += DecalSTDsaut + "l_aux_var = []"
- for DictVariable in self.ListeVariables :
- if ( DictVariable["Type"] == "in" ) :
- texte += DecalSTDsaut + "l_aux_var.append(\"" + DictVariable["Name"] + "\")"
- texte += DecalSTDsaut + "l_aux = []"
- for type_resu in l_aux :
- texte += DecalSTDsaut + "l_aux.append(" + NomResu + ".get" + type_resu + "())"
- texte += DecalSTDsaut + "for resu in l_aux :"
- texte += DecalSTDsaut + DecalSTD + "if not resu.isEmpty() :"
- texte += DecalSTDsaut + DecalSTD + DecalSTD + "text_resu += \"\\n\" + resu.getName() + \" :\""
- texte += DecalSTDsaut + DecalSTD + DecalSTD + "size = resu.getDimension()"
- texte += DecalSTDsaut + DecalSTD + DecalSTD + "l_aux_1 = resu.getCollection()"
- texte += DecalSTDsaut + DecalSTD + DecalSTD + "for iaux in range(size) :"
- texte += DecalSTDsaut + DecalSTD + DecalSTD + DecalSTD + "text_resu += \"\\n. \" + l_aux_var[iaux] + \" : \" + str(l_aux_1[iaux])"
-
-# Particularites des algorithmes de simulation
-
- if self.Analysis in ( "Simulation", ) :
- l_aux = [ ("Probabilite de defaillance", "ProbabilityEstimate") ]
- l_aux.append ( ("Variance", "VarianceEstimate") )
- l_aux.append ( ("Nombre d\'iterations", "OuterSampling") )
- for t_aux in l_aux :
- texte += DecalSTDsaut + "text_resu += \"\\n" + t_aux[0] + " = \" + str(" \
- + NomResu + ".get" + t_aux[1] + "())"
- texte += DecalSTDsaut + "text_resu += \"\\nNombre d'evaluations de l'etat limite = \" + str(" \
- + NomResu + ".getOuterSampling()*" + NomResu + ".getBlockSize())"
- if self.DictMCVal.has_key("ConfidenceIntervalProbability") :
- aux = self.DictMCVal["ConfidenceIntervalProbability"]
- texte += DecalSTDsaut + "proba = " + NomResu + ".getProbabilityEstimate()"
- texte += DecalSTDsaut + "t_aux = "
- if ( type(aux) is type(0.) ) :
- texte += "(" + str(aux) + ")"
- t_aux = [ str(aux) ]
- else :
- texte += str(aux)
- texte += DecalSTDsaut + "for val in t_aux :"
- texte += DecalSTDsaut + DecalSTD + "length = " + NomResu + ".getConfidenceLength(val)"
- texte += DecalSTDsaut + DecalSTD + "vinf = str( proba - 0.5*length )"
- texte += DecalSTDsaut + DecalSTD + "vsup = str( proba + 0.5*length )"
- texte += DecalSTDsaut + DecalSTD + "text_resu += \"\\nIntervalle de confiance a \" + str(val) + \" = [ \" "
- texte += "+ vinf + \" , \" + vsup + \" ]\""
-
-# Generalites
-
- texte += DecalSTDsaut + "d_aux = {}"
- texte += DecalSTDsaut + "d_aux[\"E\"] = ( \"de la fonction\", " + NomFunction + ".getEvaluationCallsNumber() )"
- texte += DecalSTDsaut + "d_aux[\"G\"] = ( \"du gradient\", " + NomFunction + ".getGradientCallsNumber() )"
- texte += DecalSTDsaut + "d_aux[\"H\"] = ( \"du hessien\", " + NomFunction + ".getHessianCallsNumber() )"
- texte += DecalSTDsaut + "for cle in d_aux.keys() :"
- texte += DecalSTDsaut + DecalSTD + "if d_aux[cle][1] > 0 :"
- texte += DecalSTDsaut + DecalSTD + DecalSTD + "text_resu += \"\\nNombre d\'appels au solveur pour le calcul \"" \
- + " + d_aux[cle][0] + \" = \" + str(d_aux[cle][1])"
-
-# Impression
-
- texte += DecalSTDsaut + "print ( \"\\n\", text_resu, \" ) \\n\""
- texte += DecalSTDsaut + "file_resu = open(\"" + self.fic_resu_OpenTURNS + "\", \"w\")"
- texte += DecalSTDsaut + "file_resu.write(text_resu)"
- texte += DecalSTDsaut + "file_resu.close()"
- texte += DecalSTDsaut + "probability = " + NomResu + ".getEventProbability()"
-
- return texte
-
+++ /dev/null
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-"""
-Ce module contient la partie commune
-aux generateurs XML et Etude d Openturns
-"""
-
-__revision__ = "V1.0"
-
-import os
-import sys
-
-path=os.getcwd()
-pathDef=path+"DefautOpenturns"
-
-sys.path.append(pathDef)
-
-
-#=============================================
-# La classe generale
-#=============================================
-
-class Generateur :
-
- '''
- Classe generale du generateur
- DictMCVal : dictionnaire des mots-cles
- ListeVariables : chaque variable est decrite par un dictionnaire ; cette liste les regroupe
- DictLois : dictionnaires des lois
- '''
- def __init__ (self, appli, DictMCVal = {}, ListeVariables = [], DictLois = {}, DictVariables = {} ) :
- #---------------------------------------------------------#
- self.ListeVariables = ListeVariables
- self.ListeVariablesIn = []
- self.ListeVariablesOut = []
- self.DictLois = DictLois
- self.DictVariables = DictVariables
- self.DictMCVal = DictMCVal
- self.DictTypeVar = {}
- self.nbVarIn = 0
- self.nbVarOut = 0
- self.creeInfoVar()
- self.appli = appli
- #
- # On charge eventuellement le Solver par defaut
- # et les valeurs par defaut du Solver (dans l init)
- #
- try :
- #if 1 :
- Solver = self.DictMCVal["PhysicalSolver"]
- import_name = "Defaut"+Solver
- self.module = __import__( import_name, globals(), locals() )
- monDefaut = self.module.Defaut( self )
- #else :
- except:
- self.module = None
-
-
- def getSTDGenerateur(self) :
- #--------------------------#
- try :
- gener = self.module.__dict__["MonSTDGenerateur"]
- monSTDGenerateur=gener( self.DictMCVal, self.ListeVariablesIn, self.ListeVariablesOut, self.DictLois )
- except :
- from OpenturnsSTD import STDGenerateur
- monSTDGenerateur = STDGenerateur( self.appli, self.DictMCVal, self.ListeVariablesIn, self.ListeVariablesOut, self.DictLois )
- return monSTDGenerateur
-
- def getXMLGenerateur(self) :
- #--------------------------#
- try :
- gener = self.module.__dict__["MonXMLGenerateur"]
- monXMLGenerateur=gener( self.DictMCVal, self.ListeVariables, self.DictLois )
- except :
- from OpenturnsXML import XMLGenerateur
- monXMLGenerateur = XMLGenerateur( self.appli, self.DictMCVal, self.DictVariables )
- return monXMLGenerateur
-
- def creeInfoVar (self) :
- #----------------------#
- """
- On repere les variables in/out et on les numerote.
- """
- num = 0
- liste = []
- for DictVariable in self.ListeVariables :
- if not DictVariable.has_key("Type") : DictVariable["Type"] = "in"
- self.DictTypeVar[num] = DictVariable["Type"]
- if DictVariable["Type"] == "in" :
- self.nbVarIn = self.nbVarIn + 1
- self.ListeVariablesIn.append( DictVariable )
- print "OpenturnsBase.py: new input variable = ", DictVariable
- else:
- self.nbVarOut = self.nbVarOut + 1
- self.ListeVariablesOut.append( DictVariable )
- print "OpenturnsBase.py: new output variable = ", DictVariable
- liste.append( DictVariable )
- num = num + 1
- self.ListeVariables = liste
-
-
- def ajouteDictMCVal(self, dicoPlus) :
- #-----------------------------------#
- # Appele par le classe Defaut du python specifique au code (exple DefautASTER.py)
- # enrichit self.DictMCVal avec les valeurs donnees dans dicoPlus
- # si elles ne sont pas deja dans le dictionnaire
-
- for clef in dicoPlus.keys():
- if not self.DictMCVal.has_key(clef) :
- self.DictMCVal[clef] = dicoPlus[clef]
-
- def ajouteInfoVariables (self, dicoVariablesIn, dicoVariablesOut) :
- #-----------------------------------------------------------------#
- # Appele par le classe Defaut du python specifique au code (exple DefautASTER.py)
- # met a jour les dictionnaires qui decrivent les variables (regexp par exemple)
- liste=[]
- num = 0
- for dictVariable in self.ListeVariables:
- if self.DictTypeVar[num] == "in" :
- dico = dicoVariablesIn
- else :
- dico = dicoVariablesOut
- for nouvelleVariable in dico.keys() :
- if not dictVariable.has_key(nouvelleVariable):
- dictVariable[nouvelleVariable] = dico[nouvelleVariable]
- liste.append( dictVariable )
- num = num + 1
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-"""
-Ce module contient le generateur Etude pour Openturns
-"""
-
-from Extensions.i18n import tr
-
-__revision__ = "V1.0"
-
-defaultSTD = """#! /usr/bin/env python
-
-class StudyFileGenerationError:
- def __init__ (self, st):
- self.st = st
- def __str__(self):
- return "'%s'" % self.st
-
-raise StudyFileGenerationError, "The study file was not generated. Check analysis type."
-"""
-
-headerSTD = """#! /usr/bin/env python
-
-# Chargement du module systeme
-import sys
-sys.path[:0]=['%s']
-
-# Chargement du module math
-import math
-
-# Chargement du module Open TURNS
-from openturns import *
-
-# Fonction verifiant si un echantillon contient des valeurs non valides (NaN)
-def contain_nan_values(sample):
- for point in sample:
- for val in point:
- if math.isnan(val):
- return True
- return False
-
-results = {}
-
-"""
-
-viewerSTD = """
-from openturns.viewer import View
-
-# Fonction de test du serveur X
-import subprocess
-xserver_available = None
-def is_xserver_available():
- global xserver_available
- if xserver_available is None:
- xserver_available = True
- try:
- subprocess.check_call('python -c "from matplotlib import pyplot;pyplot.figure()" >/dev/null 2>&1', shell = True)
- except:
- xserver_available = False
- return xserver_available
-
-"""
-
-footerSTD = """
-
-# Flush des messages en attente
-Log.Flush()
-
-# Terminaison du fichier
-#sys.exit( 0 )
-"""
-
-#=============================================
-# La classe de creation du fichier STD
-#=============================================
-
-class STDGenerateur :
-
- '''
- Generation du fichier python
- '''
- def __init__ (self, appli, DictMCVal, ListeVariablesIn, ListeVariablesOut, DictLois ) :
- self.DictMCVal = DictMCVal
- self.ListeVariablesIn = ListeVariablesIn
- self.ListeVariablesOut = ListeVariablesOut
- self.DictLois = DictLois
- #print "DictMCVal=", DictMCVal
- print "ListeVariablesIn= %s", ListeVariablesIn
-
-# A REPRENDRE DEPUIS ICI !!
- print "ListeVariablesOut= %s", ListeVariablesOut
- #print "DictLois=", DictLois
- self.texteSTD = defaultSTD
- self.OpenTURNS_path = appli.maConfiguration.OpenTURNS_path
-
- # Ce dictionnaire fait la correspondance entre le mot lu dans le dictionnaire des mots-clefs et la methode a appeler
- self.traitement = {
- "Min/Max" :
- ( "MinMax",
- { "Experiment Plane" : "ExperimentPlane",
- "Random Sampling" : "MinMaxRandomSampling",
- },
- ),
- "Central Uncertainty" :
- ( "CentralUncertainty",
- { "Taylor Variance Decomposition" : "TaylorVarianceDecomposition",
- "Random Sampling" : "CentralUncertaintyRandomSampling",
- },
- ),
- "Threshold Exceedence" :
- ( "ThresholdExceedence",
- { "Simulation" : "Simulation",
- "FORM_SORM" : "Analytical",
- "MonteCarlo" : "MonteCarlo",
- "LHS" : "LHS",
- "ImportanceSampling" : "ImportanceSampling",
- "FirstOrder" : "FORM",
- "SecondOrder" : "SORM",
- "Cobyla" : "Cobyla",
- "AbdoRackwitz" : "AbdoRackwitz",
- },
- ),
- }
-
- # Ce dictionnaire liste le nom des variables utilisees dans le script
- # La clef est le nom attendu par les methodes, la valeur est le nom produit dans le fichier de sortie
- # Le fait de passer par un dictionnaire permet de controler que les variables existent et sont correctement nommees
- # meme si clef == valeur
- self.variable = {
- "n" : "n",
- "p" : "p",
- "wrapper" : "wrapper",
- "wrapperdata" : "wrapperdata",
- "frameworkdata" : "frameworkdata",
- "framework" : "framework",
- "studyid" : "studyid",
- "studycase" : "studycase",
- "componentname" : "componentname",
- "model" : "model",
- "scaledVector" : "scaledVector",
- "translationVector" : "translationVector",
- "levels" : "levels",
- "myCenteredReductedGrid" : "myCenteredReductedGrid",
- "myExperimentPlane" : "myExperimentPlane",
- "inputSample" : "inputSample",
- "outputSample" : "outputSample",
- "minValue" : 'results["minValue"]',
- "maxValue" : 'results["maxValue"]',
- "flags" : "flags",
- "inSize" : "inSize",
- "distribution" : "distribution",
- "marginal" : "marginal",
- "collection" : "collection",
- "copula" : "copula",
- "correlation" : "correlation",
- "R" : "R",
- "vars" : "vars",
- "description" : "description",
- "inputRandomVector" : "inputRandomVector",
- "outputRandomVector" : "outputRandomVector",
- "myQuadraticCumul" : "myQuadraticCumul",
- "meanFirstOrder" : 'results["meanFirstOrder"]',
- "meanSecondOrder" : 'results["meanSecondOrder"]',
- "standardDeviationFirstOrder" : 'results["standardDeviationFirstOrder"]',
- "importanceFactors" : 'results["importanceFactors"]',
- "importanceFactorsGraph" : "importanceFactorsGraph",
- "importanceFactorsDrawing" : "importanceFactorsDrawing",
- "empiricalMean" : 'results["empiricalMean"]',
- "empiricalStandardDeviation" : 'results["empiricalStandardDeviation"]',
- "empiricalQuantile" : 'results["empiricalQuantile"]',
- "alpha" : "alpha",
- "beta" : "beta",
- "PCCcoefficient" : 'results["PCCcoefficient"]',
- "PRCCcoefficient" : 'results["PRCCcoefficient"]',
- "SRCcoefficient" : 'results["SRCcoefficient"]',
- "SRRCcoefficient" : 'results["SRRCcoefficient"]',
- "kernel" : "kernel",
- "kernelSmoothedDist" : "kernelSmoothedDist",
- "kernelSmoothedPDFDrawing" : "kernelSmoothedPDFDrawing",
- "kernelSmoothedGraph" : "kernelSmoothedGraph",
- "meanVector" : "meanVector",
- "importanceDensity" : "importanceDensity",
- "myEvent" : "myEvent",
- "myAlgo" : "myAlgo",
- "myResult" : "myResult",
- "probability" : 'results["probability"]',
- "standardDeviation" : 'results["standardDeviation"]',
- "level" : "level",
- "length" : "length",
- "coefficientOfVariation" : 'results["coefficientOfVariation"]',
- "convergenceGraph" : "convergenceGraph",
- "convergenceDrawing" : "convergenceDrawing",
- "simulationNumbers" : 'results["simulationNumbers"]',
- "myOptimizer" : "myOptimizer",
- "specificParameters" : "specificParameters",
- "startingPoint" : "startingPoint",
- "hasoferReliabilityIndex" : 'results["hasoferReliabilityIndex"]',
- "standardSpaceDesignPoint" : 'results["standardSpaceDesignPoint"]',
- "physicalSpaceDesignPoint" : 'results["physicalSpaceDesignPoint"]',
- "eventProbabilitySensitivity" : 'results["eventProbabilitySensitivity"]',
- "hasoferReliabilityIndexSensitivity" : 'results["hasoferReliabilityIndexSensitivity"]',
- "eventProbabilitySensitivityGraph" : "eventProbabilitySensitivityGraph",
- "eventProbabilitySensitivityDrawing" : "eventProbabilitySensitivityDrawing",
- "hasoferReliabilityIndexSensitivityGraph" : "hasoferReliabilityIndexSensitivityGraph",
- "hasoferReliabilityIndexSensitivityDrawing" : "hasoferReliabilityIndexSensitivityDrawing",
- "modelEvaluationCalls" : 'results["modelEvaluationCalls"]',
- "modelGradientCalls" : 'results["modelGradientCalls"]',
- "modelHessianCalls" : 'results["modelHessianCalls"]',
- "tvedtApproximation" : 'results["tvedtApproximation"]',
- "hohenBichlerApproximation" : 'results["hohenBichlerApproximation"]',
- "breitungApproximation" : 'results["breitungApproximation"]',
- }
-
- # Ce dictionnaire fait la correspondance entre le mot-clef du catalogue et le flag de la bibliotheque
- self.logFlags = {
- "DebugMessages" : "Log.DBG",
- "WrapperMessages" : "Log.WRAPPER",
- "UserMessages" : "Log.USER",
- "InfoMessages" : "Log.INFO",
- "WarningMessages" : "Log.WARN",
- "ErrorMessages" : "Log.ERROR",
- }
-
- def CreeSTD (self) :
- '''
- Pilotage de la creation du fichier python
- '''
- TypeAnalyse = None
- if ( self.DictMCVal.has_key( 'Type' ) ):
- TypeAnalyse = self.DictMCVal[ 'Type' ]
-
- traitement = None
- subDict = {}
- if ( self.traitement.has_key( TypeAnalyse ) ):
- (traitement, subDict) = self.traitement[ TypeAnalyse ]
-
- if ( traitement is not None ):
- self.texteSTD = apply( STDGenerateur.__dict__[ traitement ], (self, subDict) )
-
- return self.texteSTD
-
- def Header (self) :
- '''
- Imprime l entete commun a tous les fichiers
- '''
- txt = headerSTD % self.OpenTURNS_path
- txt += viewerSTD
- txt += "# Definit le niveau d'affichage de la log\n"
- txt += "%s = Log.NONE\n" % self.variable["flags"]
- for flag in self.logFlags.keys():
- if ( self.DictMCVal.has_key( flag ) ):
- val = self.DictMCVal[ flag ]
- op = "-"
- if val == 'yes' :
- op = "+"
- txt += "%s = %s %s %s\n" % (self.variable["flags"], self.variable["flags"], op, self.logFlags[ flag ])
- txt += "Log.Show( %s )\n" % self.variable["flags"]
- txt += "\n"
- return txt
-
- def Footer (self) :
- '''
- Imprime le pied de page commun a tous les fichiers
- '''
- return footerSTD
-
- def MinMax (self, subDict):
- '''
- Produit le fichier study correspondant a une analyse Min/Max
- '''
- txt = self.Header()
- txt += self.Model()
-
- Methode = None
- if ( self.DictMCVal.has_key( 'Method' ) ):
- Methode = self.DictMCVal[ 'Method' ]
-
- traitement = None
- if ( subDict.has_key( Methode ) ):
- traitement = subDict[ Methode ]
-
- if ( traitement is not None ):
- txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
-
- txt += self.MinMaxResult()
-
- txt += self.Footer()
- return txt
-
- def Model (self):
- '''
- Importe le modele physique
- '''
- if ( self.DictMCVal.has_key( 'FileName' ) ):
- name = self.DictMCVal[ 'FileName' ]
-
- txt = "# Charge le modele physique\n"
- txt += "%s = WrapperFile( '%s' )\n" % (self.variable["wrapper"], name)
- txt += "%s = %s.getWrapperData()\n" % (self.variable["wrapperdata"], self.variable["wrapper"])
-
- txt += "# Ces lignes sont utiles pour le fonctionnement du script sous Salome\n"
- txt += "if globals().has_key('%s'):\n" % self.variable["framework"]
- txt += " %s = %s.getFrameworkData()\n" % (self.variable["frameworkdata"], self.variable["wrapperdata"])
- txt += " %s.studyid_ = %s['%s']\n" % (self.variable["frameworkdata"], self.variable["framework"], self.variable["studyid"])
- txt += " %s.studycase_ = %s['%s']\n" % (self.variable["frameworkdata"], self.variable["framework"], self.variable["studycase"])
- txt += " %s.componentname_ = %s['%s']\n" % (self.variable["frameworkdata"], self.variable["framework"], self.variable["componentname"])
- txt += " %s.setFrameworkData( %s )\n" % (self.variable["wrapperdata"], self.variable["frameworkdata"])
- txt += " %s.setWrapperData( %s )\n" % (self.variable["wrapper"], self.variable["wrapperdata"])
- txt += "# Fin des lignes pour Salome\n"
-
- txt += "%s = NumericalMathFunction( %s )\n" % (self.variable["model"], self.variable["wrapper"],)
- txt += "%s = %s.getInputDimension()\n" % (self.variable["n"], self.variable["model"])
- txt += "\n"
- return txt
-
- def ExperimentPlane (self):
- '''
- Etude par plan d experience
- '''
- txt = "# Etude par plan d'experience\n"
- txt += self.Levels()
- txt += self.CenteredReductedGrid()
- txt += self.ScaledVector()
- txt += self.TranslationVector()
- txt += "%s = %s\n" % (self.variable["inputSample"], self.variable["myExperimentPlane"])
- txt += "\n"
- txt += "# Etude 'Min/Max'\n"
- txt += "# Calcul\n"
- txt += "%s = %s( %s )\n" % (self.variable["outputSample"], self.variable["model"], self.variable["inputSample"])
- txt += "if contain_nan_values( %s ):\n" % (self.variable["outputSample"])
- txt += " raise Exception('Some computations failed')\n"
- txt += "\n"
- return txt
-
- def MinMaxRandomSampling (self):
- '''
- Etude par echantillonage aleatoire
- '''
- size = 0
- if ( self.DictMCVal.has_key( 'SimulationsNumber' ) ):
- size = self.DictMCVal[ 'SimulationsNumber' ]
-
- txt = "# Etude par echantillonage aleatoire\n"
- txt += self.InputDistribution()
- txt += self.InputRandomVector()
- txt += "\n"
- txt += "# Etude 'Min/Max'\n"
- txt += "# Calcul\n"
- txt += "%s = %d\n" % (self.variable["inSize"], size)
- txt += "%s = RandomVector( %s, %s )\n" % (self.variable["outputRandomVector"], self.variable["model"], self.variable["inputRandomVector"])
- txt += "%s = %s.getSample( %s )\n" % (self.variable["outputSample"], self.variable["outputRandomVector"], self.variable["inSize"])
- txt += "if contain_nan_values( %s ):\n" % (self.variable["outputSample"])
- txt += " raise Exception('Some computations failed')\n"
- return txt
-
- def InputDistribution (self):
- '''
- Cree la loi jointe des variables d entree
- '''
- txt = "# Definit la loi jointe des variables d'entree\n"
- txt += "%s = DistributionCollection( %s )\n" % (self.variable["collection"], self.variable["n"])
- txt += "%s = Description( %s )\n" % (self.variable["description"], self.variable["n"])
- txt += "\n"
-
- dictVariables = {}
- for variable in self.ListeVariablesIn:
- nomVar = variable['ModelVariable'].getName()
- dictVariables[ nomVar ] = variable['Distribution']
-
- i = 0
- sortedVarNames = dictVariables.keys()
- sortedVarNames.sort()
- for variable in sortedVarNames:
- conceptloi = dictVariables[ variable ]
- loi = self.DictLois[ conceptloi ]
- if loi.has_key( 'Kind' ):
- marginale = "%s_%d" % (self.variable["marginal"], i)
- txt += "# Definit la loi marginale de la composante %d\n" % i
- txt += "%s = %s\n" % (marginale, apply( STDGenerateur.__dict__[ loi[ 'Kind' ] ], (self, loi) ))
- txt += "%s.setName( '%s' )\n" % (marginale, conceptloi.getName())
- txt += "%s[ %d ] = '%s'\n" % (self.variable["description"], i, variable)
- txt += "%s[ %d ] = Distribution( %s )\n" % (self.variable["collection"], i, marginale)
- txt += "\n"
- i += 1
-
- txt += self.Copula()
-
- txt += "# Definit la loi jointe\n"
- txt += "%s = ComposedDistribution( %s, Copula( %s ) )\n" % (self.variable["distribution"], self.variable["collection"], self.variable["copula"])
- txt += "%s.setDescription( %s )\n" % (self.variable["distribution"], self.variable["description"])
- txt += "\n"
- return txt
-
- def Copula (self):
- '''
- Cree la copule de la loi jointe
- '''
- txt = "# Definit la copule de la loi jointe\n"
-
- if ( not self.DictMCVal.has_key( 'Copula' ) ):
- self.DictMCVal[ 'Copula' ] = 'Independent'
-
- if ( self.DictMCVal[ 'Copula' ] in ( 'Independent', ) ):
- txt += "%s = IndependentCopula( %s )\n" % (self.variable["copula"], self.variable["n"])
- elif ( self.DictMCVal[ 'Copula' ] in ( 'Normal', ) ):
- varList = self.DictMCVal[ 'CorrelationMatrix' ][0]
- dimension = len(varList)
- txt += "%s = {}\n" % self.variable["correlation"]
- for i in range( dimension ):
- txt += "%s['%s'] = {}\n" % (self.variable["correlation"], varList[i])
- for j in range ( dimension ):
- txt += "%s['%s']['%s'] = %g\n" % (self.variable["correlation"], varList[i], varList[j], self.DictMCVal[ 'CorrelationMatrix' ][i+1][j])
- txt += "%s = getCorrelationMatrixFromMap( %s.getVariableList(), %s )\n" % (self.variable["R"], self.variable["wrapperdata"], self.variable["correlation"])
- txt += "%s = NormalCopula( %s )\n" % (self.variable["copula"], self.variable["R"])
-
- txt += "\n"
- return txt
-
- def InputRandomVector (self):
- '''
- Cree le vector aleatoire d entree
- '''
- txt = "# Definit le vecteur aleatoire d'entree\n"
- txt += "%s = RandomVector( %s )\n" % (self.variable["inputRandomVector"], self.variable["distribution"])
- txt += "\n"
- return txt
-
- def OutputRandomVector (self):
- '''
- Cree le vector aleatoire de sortie
- '''
- nomVar = "output"
- for variable in self.ListeVariablesOut:
- nomVar = variable['ModelVariable'].getName()
-
- txt = "# Definit le vecteur aleatoire de sortie\n"
- txt += "%s = RandomVector( %s, %s )\n" % (self.variable["outputRandomVector"], self.variable["model"], self.variable["inputRandomVector"])
- txt += "%s.setName( '%s' )\n" % (self.variable["outputRandomVector"], nomVar)
- txt += "\n"
- return txt
-
- def ScaledVector (self):
- '''
- Definit les coefficients multiplicateurs par composante du vecteur
- '''
- dimension = 0
- if ( self.DictMCVal.has_key( 'UnitsPerDimension' ) ):
- unitsPerDimension = self.DictMCVal[ 'UnitsPerDimension' ]
- dimension = len( unitsPerDimension )
-
- txt = "# Definit les facteurs d'echelle dans chaque direction\n"
- txt += "%s = NumericalPoint( %s )\n" % (self.variable["scaledVector"], self.variable["n"])
- for i in range(dimension):
- txt += "%s[%d] = %g\n" % (self.variable["scaledVector"], i, unitsPerDimension[i])
- txt += "%s.scale( %s )\n" % (self.variable["myExperimentPlane"], self.variable["scaledVector"])
- txt += "\n"
- return txt
-
- def TranslationVector (self):
- '''
- Definit le vecteur de translation
- '''
- dimension = 0
- if ( self.DictMCVal.has_key( 'Center' ) ):
- center = self.DictMCVal[ 'Center' ]
- dimension = len( center )
-
- txt = "# Definit le vecteur de translation\n"
- txt += "%s = NumericalPoint( %s )\n" % (self.variable["translationVector"], self.variable["n"])
- for i in range(dimension):
- txt += "%s[%d] = %g\n" % (self.variable["translationVector"], i, center[i])
- txt += "%s.translate( %s )\n" % (self.variable["myExperimentPlane"], self.variable["translationVector"])
- txt += "\n"
- return txt
-
- def Levels (self):
- '''
- Definit les niveaux du plan d experience
- '''
- dimension = 0
- if ( self.DictMCVal.has_key( 'Levels' ) ):
- levels = self.DictMCVal[ 'Levels' ]
- dimension = len( levels )
-
- txt = "# Definit les niveaux de la structure de grille\n"
- txt += "%s = NumericalPoint( %d )\n" % (self.variable["levels"], dimension)
- for i in range(dimension):
- txt += "%s[%d] = %g\n" % (self.variable["levels"], i, levels[i])
- txt += "\n"
- return txt
-
- def CenteredReductedGrid (self):
- '''
- Definit la grille reduite du plan d experience
- '''
- plane = None
- if ( self.DictMCVal.has_key( 'ExperimentPlane' ) ):
- plane = self.DictMCVal[ 'ExperimentPlane' ]
-
- txt = "# Cree le plan d'experience centre reduit\n"
- txt += "%s = %s(%s, %s)\n" % (self.variable["myCenteredReductedGrid"], plane, self.variable["n"], self.variable["levels"])
- txt += "%s = %s.generate()\n" % (self.variable["myExperimentPlane"], self.variable["myCenteredReductedGrid"])
- txt += "\n"
- return txt
-
- def MinMaxResult (self):
- '''
- Produit les resultats de l etude
- '''
- txt = "# Resultats\n"
- txt += "%s = %s.getMin()\n" % (self.variable["minValue"], self.variable["outputSample"])
- txt += "print '%s = ', %s\n" % ("minValue", self.variable["minValue"])
- txt += "\n"
- txt += "%s = %s.getMax()\n" % (self.variable["maxValue"], self.variable["outputSample"])
- txt += "print '%s = ', %s\n" % ("maxValue", self.variable["maxValue"])
- txt += "\n"
- return txt
-
- def CentralUncertainty (self, subDict):
- '''
- Produit le fichier study correspondant a une analyse d incertitude en valeur centrale
- '''
- txt = self.Header()
- txt += self.Model()
- txt += self.InputDistribution()
- txt += self.InputRandomVector()
- txt += self.OutputRandomVector()
-
- Methode = None
- if ( self.DictMCVal.has_key( 'Method' ) ):
- Methode = self.DictMCVal[ 'Method' ]
-
- traitement = None
- if ( subDict.has_key( Methode ) ):
- traitement = subDict[ Methode ]
-
- if ( traitement is not None ):
- txt += "# Etude 'Central Uncertainty'\n"
- txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
-
- txt += self.Footer()
- return txt
-
-
- def TaylorVarianceDecomposition (self):
- '''
- Etude par decomposition de Taylor
- '''
- txt = "# Cumul quadratique (decomposition de Taylor)\n"
- txt += "%s = QuadraticCumul( %s )\n" % (self.variable["myQuadraticCumul"], self.variable["outputRandomVector"])
- txt += "\n"
- txt += "# Resultats\n"
-
- if ( self.DictMCVal.has_key( 'MeanFirstOrder' ) ):
- if ( self.DictMCVal[ 'MeanFirstOrder' ] == "yes" ):
- txt += "%s = %s.getMeanFirstOrder()\n" % (self.variable["meanFirstOrder"], self.variable["myQuadraticCumul"])
- txt += "print '%s = ', %s\n" % ("mean First Order", self.variable["meanFirstOrder"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'MeanSecondOrder' ) ):
- if ( self.DictMCVal[ 'MeanSecondOrder' ] == "yes" ):
- txt += "%s = %s.getMeanSecondOrder()\n" % (self.variable["meanSecondOrder"], self.variable["myQuadraticCumul"])
- txt += "print '%s = ', %s\n" % ("mean Second Order", self.variable["meanSecondOrder"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'StandardDeviationFirstOrder' ) ):
- if ( self.DictMCVal[ 'StandardDeviationFirstOrder' ] == "yes" ):
- txt += "%s = %s.getCovariance()\n" % (self.variable["standardDeviationFirstOrder"], self.variable["myQuadraticCumul"])
- txt += "dim = %s.getDimension()\n" % self.variable["standardDeviationFirstOrder"]
- txt += "for i in range( dim ):\n"
- txt += " %s[ i, i ] = math.sqrt( %s[ i, i ] )\n" % (self.variable["standardDeviationFirstOrder"], self.variable["standardDeviationFirstOrder"])
- txt += " print '%s = ', %s[ i, i ]\n" % ("standard Deviation First Order", self.variable["standardDeviationFirstOrder"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'ImportanceFactor' ) ):
- if ( self.DictMCVal[ 'ImportanceFactor' ] == "yes" ):
- txt += "%s = %s.getImportanceFactors()\n" % (self.variable["importanceFactors"], self.variable["myQuadraticCumul"])
- txt += "for i in range(%s.getDimension()):\n" % self.variable["importanceFactors"]
- txt += " print %s.getDescription()[i], ':', %s[i]*100., '%%'\n" % (self.variable["distribution"], self.variable["importanceFactors"])
- txt += "\n"
- txt += "%s = %s.drawImportanceFactors()\n" % (self.variable["importanceFactorsGraph"], self.variable["myQuadraticCumul"])
- txt += "%s = '%s'\n" % (self.variable["importanceFactorsDrawing"], self.DictMCVal[ 'ImportanceFactorDrawingFilename' ])
- txt += "%s.draw( %s )\n" % (self.variable["importanceFactorsGraph"], self.variable["importanceFactorsDrawing"])
- txt += "#if is_xserver_available():\n"
- txt += "# view = View(%s)\n" % self.variable["importanceFactorsGraph"]
- txt += "# view.show(block=True)\n"
- txt += "#else:\n"
- txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["importanceFactorsGraph"]
- txt += "print 'bitmap =', %s.getBitmap()\n" % self.variable["importanceFactorsGraph"]
- txt += "print 'postscript =', %s.getPostscript()\n" % self.variable["importanceFactorsGraph"]
- txt += "\n"
-
- txt += "\n"
- return txt
-
- def CentralUncertaintyRandomSampling (self):
- '''
- Etude par echantillonage aleatoire
- '''
- size = 0
- if ( self.DictMCVal.has_key( 'SimulationsNumber' ) ):
- size = self.DictMCVal[ 'SimulationsNumber' ]
-
- txt = "# Echantillonnage aleatoire de la variable de sortie\n"
- txt += "%s = %d\n" % (self.variable["inSize"], size)
- txt += "%s = %s.getSample( %s )\n" % (self.variable["inputSample"], self.variable["inputRandomVector"], self.variable["inSize"])
- txt += "%s = %s( %s )\n" % (self.variable["outputSample"], self.variable["model"], self.variable["inputSample"])
- txt += "if contain_nan_values( %s ):\n" % (self.variable["outputSample"])
- txt += " raise Exception('Some computations failed')\n"
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'EmpiricalMean' ) ):
- if ( self.DictMCVal[ 'EmpiricalMean' ] == "yes" ):
- txt += "%s = %s.computeMean()\n" % (self.variable["empiricalMean"], self.variable["outputSample"])
- txt += "print '%s =', %s[0]\n" % ("empirical Mean", self.variable["empiricalMean"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'EmpiricalStandardDeviation' ) ):
- if ( self.DictMCVal[ 'EmpiricalStandardDeviation' ] == "yes" ):
- txt += "%s = %s.computeCovariance()\n" % (self.variable["empiricalStandardDeviation"], self.variable["outputSample"])
- txt += "dim = %s.getDimension()\n" % self.variable["empiricalStandardDeviation"]
- txt += "for i in range( dim ):\n"
- txt += " %s[ i, i ] = math.sqrt( %s[ i, i ] )\n" % (self.variable["empiricalStandardDeviation"], self.variable["empiricalStandardDeviation"])
- txt += " print '%s = ', %s[ i, i ]\n" % ("empirical Standard Deviation", self.variable["empiricalStandardDeviation"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'EmpiricalQuantile_Order' ) ):
- ordre = self.DictMCVal[ 'EmpiricalQuantile_Order' ]
- txt += "%s = %s.computeQuantile( %s )\n" % (self.variable["empiricalQuantile"], self.variable["outputSample"], ordre)
- txt += "print '%s ( %s ) =', %s\n" % ("empirical Quantile", ordre, self.variable["empiricalQuantile"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'CorrelationAnalysis' ) ):
- if ( self.DictMCVal[ 'CorrelationAnalysis' ] == "yes" ):
- txt += "if ( %s.getDimension() == 1 ):\n" % self.variable["outputSample"]
- txt += " %s = CorrelationAnalysis.PCC( %s, %s )\n" % (self.variable["PCCcoefficient"], self.variable["inputSample"], self.variable["outputSample"])
- txt += " print 'PCC Coefficients:'\n"
- txt += " for i in range( %s ):\n" % self.variable["n"]
- txt += " print %s.getDescription()[i], ':', %s[i]\n" % (self.variable["distribution"], self.variable["PCCcoefficient"])
- txt += "\n"
- txt += " %s = CorrelationAnalysis.PRCC( %s, %s )\n" % (self.variable["PRCCcoefficient"], self.variable["inputSample"], self.variable["outputSample"])
- txt += " print 'PRCC Coefficients:'\n"
- txt += " for i in range( %s ):\n" % self.variable["n"]
- txt += " print %s.getDescription()[i], ':', %s[i]\n" % (self.variable["distribution"], self.variable["PRCCcoefficient"])
- txt += "\n"
- txt += " %s = CorrelationAnalysis.SRC( %s, %s )\n" % (self.variable["SRCcoefficient"], self.variable["inputSample"], self.variable["outputSample"])
- txt += " print 'SRC Coefficients:'\n"
- txt += " for i in range( %s ):\n" % self.variable["n"]
- txt += " print %s.getDescription()[i], ':', %s[i]\n" % (self.variable["distribution"], self.variable["SRCcoefficient"])
- txt += "\n"
- txt += " %s = CorrelationAnalysis.SRRC( %s, %s )\n" % (self.variable["SRRCcoefficient"], self.variable["inputSample"], self.variable["outputSample"])
- txt += " print 'SRRC Coefficients:'\n"
- txt += " for i in range( %s ):\n" % self.variable["n"]
- txt += " print %s.getDescription()[i], ':', %s[i]\n" % (self.variable["distribution"], self.variable["SRRCcoefficient"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'KernelSmoothing' ) ):
- if ( self.DictMCVal[ 'KernelSmoothing' ] == "yes" ):
- txt += "# Kernel Smoohing\n"
- txt += "%s = KernelSmoothing()\n" % self.variable["kernel"]
- txt += "if ( %s.getDimension() == 1 ):\n" % self.variable["outputSample"]
- txt += " %s.setName( 'Output' )\n" % self.variable["outputSample"]
- txt += " %s = %s.build( %s, 'TRUE')\n" % (self.variable["kernelSmoothedDist"], self.variable["kernel"], self.variable["outputSample"])
- txt += " %s = %s.drawPDF()\n" % (self.variable["kernelSmoothedGraph"], self.variable["kernelSmoothedDist"])
- txt += " %s = '%s'\n" % (self.variable["kernelSmoothedPDFDrawing"], self.DictMCVal[ 'KernelSmoothingDrawingFilename' ])
- txt += " %s.draw( %s )\n" % (self.variable["kernelSmoothedGraph"], self.variable["kernelSmoothedPDFDrawing"])
- txt += " #if is_xserver_available():\n"
- txt += " # view = View(%s)\n" % self.variable["kernelSmoothedGraph"]
- txt += " # view.show(block=True)\n"
- txt += " #else:\n"
- txt += " # print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["kernelSmoothedGraph"]
- txt += " print 'bitmap =', %s.getBitmap()\n" % self.variable["kernelSmoothedGraph"]
- txt += " print 'postscript =', %s.getPostscript()\n" % self.variable["kernelSmoothedGraph"]
- txt += "\n"
-
- return txt
-
- def ThresholdExceedence (self, subDict):
- '''
- Produit le fichier study correspondant a une analyse de depassement de seuil
- '''
- txt = self.Header()
- txt += "# Etude 'Threshold Exceedence'\n"
-
- txt += self.RandomGenerator()
- txt += self.Model()
- txt += self.InputDistribution()
- txt += self.InputRandomVector()
- txt += self.OutputRandomVector()
- txt += self.Event()
-
- Methode = None
- if ( self.DictMCVal.has_key( 'Method' ) ):
- Methode = self.DictMCVal[ 'Method' ]
-
- traitement = None
- if ( subDict.has_key( Methode ) ):
- traitement = subDict[ Methode ]
-
- if ( traitement is not None ):
- txt += apply( STDGenerateur.__dict__[ traitement ], (self, subDict) )
-
- txt += self.Footer()
- return txt
-
- def Simulation (self, subDict):
- '''
- Methodes de simulation
- '''
- Algorithme = None
- if ( self.DictMCVal.has_key( 'Algorithm' ) ):
- Algorithme = self.DictMCVal[ 'Algorithm' ]
-
- traitement = None
- if ( subDict.has_key( Algorithme ) ):
- traitement = subDict[ Algorithme ]
-
- if ( traitement is not None ):
- txt = apply( STDGenerateur.__dict__[ traitement ], (self,) )
-
- maxOuterSampling = None
- if ( self.DictMCVal.has_key( 'MaximumOuterSampling' ) ):
- maxOuterSampling = self.DictMCVal[ 'MaximumOuterSampling' ]
- txt += "%s.setMaximumOuterSampling( %s )\n" % (self.variable["myAlgo"], maxOuterSampling)
-
- blockSize = None
- if ( self.DictMCVal.has_key( 'BlockSize' ) ):
- blockSize = self.DictMCVal[ 'BlockSize' ]
- txt += "%s.setBlockSize( %s )\n" % (self.variable["myAlgo"], blockSize)
-
- maxCoefficientOfVariation = None
- if ( self.DictMCVal.has_key( 'MaximumCoefficientOfVariation' ) ):
- maxCoefficientOfVariation = self.DictMCVal[ 'MaximumCoefficientOfVariation' ]
- txt += "%s.setMaximumCoefficientOfVariation( %s )\n" % (self.variable["myAlgo"], maxCoefficientOfVariation)
-
- txt += "%s.run()\n" % self.variable["myAlgo"]
- txt += "\n"
- txt += "# Resultats de la simulation\n"
- txt += "%s = %s.getResult()\n" % (self.variable["myResult"], self.variable["myAlgo"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'Probability' ) ):
- if ( self.DictMCVal[ 'Probability' ] == "yes" ):
- txt += "%s = %s.getProbabilityEstimate()\n" % (self.variable["probability"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("probability", self.variable["probability"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'StandardDeviation' ) ):
- if ( self.DictMCVal[ 'StandardDeviation' ] == "yes" ):
- txt += "%s = math.sqrt( %s.getProbabilityEstimate() )\n" % (self.variable["standardDeviation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("standard Deviation", self.variable["standardDeviation"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'ConfidenceInterval' ) and self.DictMCVal.has_key( 'Probability' ) ):
- if ( ( self.DictMCVal[ 'ConfidenceInterval' ] == "yes" ) and ( self.DictMCVal[ 'Probability' ] == "yes" ) ):
- level = self.DictMCVal[ 'Level' ]
- txt += "%s = %s.getConfidenceLength( %s )\n" % (self.variable["length"], self.variable["myResult"], level)
- txt += "print 'confidence interval at %s = [', %s-0.5*%s, ',', %s+0.5*%s, ']'\n" % (level, self.variable["probability"], self.variable["length"], self.variable["probability"], self.variable["length"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'VariationCoefficient' ) ):
- if ( self.DictMCVal[ 'VariationCoefficient' ] == "yes" ):
- txt += "%s = %s.getCoefficientOfVariation()\n" % (self.variable["coefficientOfVariation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("coefficient of Variation", self.variable["coefficientOfVariation"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'SimulationsNumber' ) ):
- if ( self.DictMCVal[ 'SimulationsNumber' ] == "yes" ):
- txt += "%s = %s.getOuterSampling()\n" % (self.variable["simulationNumbers"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("simulation Numbers", self.variable["simulationNumbers"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'ConvergenceGraph' ) and self.DictMCVal.has_key( 'ConfidenceInterval' ) ):
- if ( ( self.DictMCVal[ 'ConvergenceGraph' ] == "yes" ) and ( self.DictMCVal[ 'ConfidenceInterval' ] == "yes" ) ):
- txt += "%s = %s\n" % (self.variable["alpha"], self.DictMCVal[ 'Level' ])
- txt += "%s = %s.drawProbabilityConvergence( %s )\n" % (self.variable["convergenceGraph"], self.variable["myAlgo"], self.variable["alpha"])
- txt += "%s = '%s'\n" % (self.variable["convergenceDrawing"], self.DictMCVal[ 'ConvergenceDrawingFilename' ])
- txt += "%s.draw( %s )\n" % (self.variable["convergenceGraph"], self.variable["convergenceDrawing"])
- txt += "#if is_xserver_available():\n"
- txt += "# view = View(%s)\n" % self.variable["convergenceGraph"]
- txt += "# view.show(block=True)\n"
- txt += "#else:\n"
- txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["convergenceGraph"]
- txt += "\n"
-
- return txt
-
- def Analytical (self, subDict):
- '''
- Methodes analytiques
- '''
- txt = ""
-
- OptimizationAlgo = None
- if ( self.DictMCVal.has_key( 'OptimizationAlgorithm' ) ):
- OptimizationAlgo = self.DictMCVal[ 'OptimizationAlgorithm' ]
-
- traitement = None
- if ( subDict.has_key( OptimizationAlgo ) ):
- traitement = subDict[ OptimizationAlgo ]
-
- if ( traitement is not None ):
- txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
-
- txt += self.OptimizerSettings()
- txt += self.PhysicalStartingPoint()
-
- Approximation = None
- if ( self.DictMCVal.has_key( 'Approximation' ) ):
- Approximation = self.DictMCVal[ 'Approximation' ]
-
- traitement = None
- if ( subDict.has_key( Approximation ) ):
- traitement = subDict[ Approximation ]
-
- if ( traitement is not None ):
- txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
-
- txt += self.RunAlgorithm()
- txt += self.AnalyticalResult()
-
- return txt
-
- def OptimizerSettings (self):
- '''
- Parametrage de l optimiseur
- '''
- txt = ""
-
- simulationNumbers = None
- if ( self.DictMCVal.has_key( 'MaximumIterationsNumber' ) ):
- simulationNumbers = self.DictMCVal[ 'MaximumIterationsNumber' ]
- txt += "%s.setMaximumIterationsNumber( %s )\n" % (self.variable["myOptimizer"], simulationNumbers)
-
- absoluteError = None
- if ( self.DictMCVal.has_key( 'MaximumAbsoluteError' ) ):
- absoluteError = self.DictMCVal[ 'MaximumAbsoluteError' ]
- txt += "%s.setMaximumAbsoluteError( %s )\n" % (self.variable["myOptimizer"], absoluteError)
-
- relativeError = None
- if ( self.DictMCVal.has_key( 'MaximumRelativeError' ) ):
- relativeError = self.DictMCVal[ 'MaximumRelativeError' ]
- txt += "%s.setMaximumRelativeError( %s )\n" % (self.variable["myOptimizer"], relativeError)
-
- residualError = None
- if ( self.DictMCVal.has_key( 'MaximumResidualError' ) ):
- residualError = self.DictMCVal[ 'MaximumResidualError' ]
- txt += "%s.setMaximumResidualError( %s )\n" % (self.variable["myOptimizer"], residualError)
-
- constraintError = None
- if ( self.DictMCVal.has_key( 'MaximumConstraintError' ) ):
- constraintError = self.DictMCVal[ 'MaximumConstraintError' ]
- txt += "%s.setMaximumConstraintError( %s )\n" % (self.variable["myOptimizer"], constraintError)
-
- txt += "\n"
-
- return txt
-
- def PhysicalStartingPoint (self):
- '''
- Point physique de depart
- '''
- txt = "# Point physique de depart\n"
-
- if ( self.DictMCVal.has_key( 'PhysicalStartingPoint' ) ):
- point = self.DictMCVal[ 'PhysicalStartingPoint' ]
- dimension = len( point )
- txt += "%s = NumericalPoint( %d )\n" % (self.variable["startingPoint"], dimension)
- for i in range( dimension ):
- txt += "%s[ %d ] = %g\n" % (self.variable["startingPoint"], i, point[i])
- else:
- txt += "%s = %s.getMean()\n" % (self.variable["startingPoint"], self.variable["inputRandomVector"])
-
- txt += "\n"
-
- return txt
-
- def AnalyticalResult (self):
- '''
- Resultat des methodes analytiques
- '''
- txt = "# Resultat des methodes analytiques\n"
- txt += "%s = %s.getResult()\n" % (self.variable["myResult"], self.variable["myAlgo"])
-
- if ( self.DictMCVal.has_key( 'Probability' ) ):
- if ( self.DictMCVal[ 'Probability' ] == "yes" ):
- txt += "%s = %s.getEventProbability()\n" % (self.variable["probability"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % (self.variable["probability"], self.variable["probability"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'HasoferReliabilityIndex' ) ):
- if ( self.DictMCVal[ 'HasoferReliabilityIndex' ] == "yes" ):
- txt += "%s = %s.getHasoferReliabilityIndex()\n" % (self.variable["hasoferReliabilityIndex"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("hasofer Reliability Index", self.variable["hasoferReliabilityIndex"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'DesignPoint' ) ):
- if ( self.DictMCVal[ 'DesignPoint' ] == "yes" ):
- txt += "%s = %s.getStandardSpaceDesignPoint()\n" % (self.variable["standardSpaceDesignPoint"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("standard Space Design Point", self.variable["standardSpaceDesignPoint"])
- txt += "%s = %s.getPhysicalSpaceDesignPoint()\n" % (self.variable["physicalSpaceDesignPoint"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("physical Space Design Point", self.variable["physicalSpaceDesignPoint"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'ImportanceFactor' ) ):
- if ( self.DictMCVal[ 'ImportanceFactor' ] == "yes" ):
- txt += "print 'Importance Factors:'\n"
- txt += "%s = %s.getImportanceFactors()\n" % (self.variable["importanceFactors"], self.variable["myResult"])
- txt += "for i in range(%s.getDimension()):\n" % self.variable["importanceFactors"]
- txt += " print %s.getDescription()[i], ':', %s[i]*100., '%%'\n" % (self.variable["distribution"], self.variable["importanceFactors"])
- txt += "\n"
- txt += "%s = %s.drawImportanceFactors()\n" % (self.variable["importanceFactorsGraph"], self.variable["myResult"])
- txt += "%s = '%s'\n" % (self.variable["importanceFactorsDrawing"], self.DictMCVal[ 'ImportanceFactorDrawingFilename' ])
- txt += "%s.draw( %s )\n" % (self.variable["importanceFactorsGraph"], self.variable["importanceFactorsDrawing"])
- txt += "#if is_xserver_available():\n"
- txt += "# view = View(%s)\n" % self.variable["importanceFactorsGraph"]
- txt += "# view.show(block=True)\n"
- txt += "#else:\n"
- txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["importanceFactorsGraph"]
- txt += "print 'bitmap =', %s.getBitmap()\n" % self.variable["importanceFactorsGraph"]
- txt += "print 'postscript =', %s.getPostscript()\n" % self.variable["importanceFactorsGraph"]
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'FORMEventProbabilitySensitivity' ) ):
- if ( self.DictMCVal[ 'FORMEventProbabilitySensitivity' ] == "yes" ):
- txt += "%s = %s.getEventProbabilitySensitivity()\n" % (self.variable["eventProbabilitySensitivity"], self.variable["myResult"])
- txt += "print 'FORM Event Probability Sensitivity:'\n"
- txt += "for i in range( %s ):\n" % self.variable["n"]
- txt += " print %s.getDescription()[i], ':'\n" % self.variable["distribution"]
- txt += " for j in range( %s[i].getDimension() ):\n" % self.variable["eventProbabilitySensitivity"]
- txt += " print ' ', %s[i].getDescription()[j], ':', %s[i][j]\n" % (self.variable["eventProbabilitySensitivity"], self.variable["eventProbabilitySensitivity"])
- txt += "\n"
- txt += "%s = %s.drawEventProbabilitySensitivity()[0]\n" % (self.variable["eventProbabilitySensitivityGraph"], self.variable["myResult"])
- txt += "%s = '%s'\n" % (self.variable["eventProbabilitySensitivityDrawing"], self.DictMCVal[ 'FORMEventProbabilitySensitivityDrawingFilename' ])
- txt += "%s.draw( %s )\n" % (self.variable["eventProbabilitySensitivityGraph"], self.variable["eventProbabilitySensitivityDrawing"])
- txt += "#if is_xserver_available():\n"
- txt += "# view = View(%s)\n" % self.variable["eventProbabilitySensitivityGraph"]
- txt += "# view.show(block=True)\n"
- txt += "#else:\n"
- txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["eventProbabilitySensitivityGraph"]
- txt += "print 'bitmap =', %s.getBitmap()\n" % self.variable["eventProbabilitySensitivityGraph"]
- txt += "print 'postscript =', %s.getPostscript()\n" % self.variable["eventProbabilitySensitivityGraph"]
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'HasoferReliabilityIndexSensitivity' ) ):
- if ( self.DictMCVal[ 'HasoferReliabilityIndexSensitivity' ] == "yes" ):
- txt += "%s = %s.getHasoferReliabilityIndexSensitivity()\n" % (self.variable["hasoferReliabilityIndexSensitivity"], self.variable["myResult"])
- txt += "print 'Hasofer Reliability Index Sensitivity:'\n"
- txt += "for i in range( %s ):\n" % self.variable["n"]
- txt += " print %s.getDescription()[i], ':'\n" % self.variable["distribution"]
- txt += " for j in range( %s[i].getDimension() ):\n" % self.variable["hasoferReliabilityIndexSensitivity"]
- txt += " print ' ', %s[i].getDescription()[j], ':', %s[i][j]\n" % (self.variable["hasoferReliabilityIndexSensitivity"], self.variable["hasoferReliabilityIndexSensitivity"])
- txt += "\n"
- txt += "%s = %s.drawHasoferReliabilityIndexSensitivity()[0]\n" % (self.variable["hasoferReliabilityIndexSensitivityGraph"], self.variable["myResult"])
- txt += "%s = '%s'\n" % (self.variable["hasoferReliabilityIndexSensitivityDrawing"], self.DictMCVal[ 'HasoferReliabilityIndexSensitivityDrawingFilename' ])
- txt += "%s.draw( %s )\n" % (self.variable["hasoferReliabilityIndexSensitivityGraph"], self.variable["hasoferReliabilityIndexSensitivityDrawing"])
- txt += "#if is_xserver_available():\n"
- txt += "# view = View(%s)\n" % self.variable["hasoferReliabilityIndexSensitivityGraph"]
- txt += "# view.show(block=True)\n"
- txt += "#else:\n"
- txt += "# print 'Warning: cannot display image', %s.getBitmap(), '(probably because no X server was found)'\n" % self.variable["hasoferReliabilityIndexSensitivityGraph"]
- txt += "print 'bitmap =', %s.getBitmap()\n" % self.variable["hasoferReliabilityIndexSensitivityGraph"]
- txt += "print 'postscript =', %s.getPostscript()\n" % self.variable["hasoferReliabilityIndexSensitivityGraph"]
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'TvedtApproximation' ) ):
- if ( self.DictMCVal[ 'TvedtApproximation' ] == "yes" ):
- txt += "%s = %s.getEventProbabilityTvedt()\n" % (self.variable["tvedtApproximation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("Tvedt Approximation", self.variable["tvedtApproximation"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'HohenBichlerApproximation' ) ):
- if ( self.DictMCVal[ 'HohenBichlerApproximation' ] == "yes" ):
- txt += "%s = %s.getEventProbabilityHohenBichler()\n" % (self.variable["hohenBichlerApproximation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("HohenBichler Approximation", self.variable["tvedtApproximation"])
- txt += "\n"
-
- if ( self.DictMCVal.has_key( 'BreitungApproximation' ) ):
- if ( self.DictMCVal[ 'BreitungApproximation' ] == "yes" ):
- txt += "%s = %s.getEventProbabilityBreitung()\n" % (self.variable["breitungApproximation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("Breitung Approximation", self.variable["breitungApproximation"])
- txt += "\n"
-
-
- return txt
-
- def RandomGenerator (self):
- '''
- Generateur Aleatoire
- '''
- txt = ""
-
- seed = None
- if ( self.DictMCVal.has_key( 'RandomGeneratorSeed' ) ):
- seed = self.DictMCVal[ 'RandomGeneratorSeed' ]
- txt += "# Initialise le generateur aleatoire\n"
- txt += "RandomGenerator.SetSeed( %s )\n" % seed
- txt += "\n"
-
- return txt
-
- def Event (self):
- '''
- Definition de l evenement de defaillance
- '''
- operator = None
- if ( self.DictMCVal.has_key( 'ComparisonOperator' ) ):
- operator = self.DictMCVal[ 'ComparisonOperator' ]
-
- threshold = None
- if ( self.DictMCVal.has_key( 'Threshold' ) ):
- threshold = self.DictMCVal[ 'Threshold' ]
-
- txt = "# Evenement de defaillance\n"
- txt += "%s = Event( %s, ComparisonOperator( %s() ), %s )\n" % (self.variable["myEvent"], self.variable["outputRandomVector"], operator, threshold)
- txt += "%s.setName( '%s' )\n" % (self.variable["myEvent"], "myEvent")
- txt += "\n"
- return txt
-
- def MonteCarlo (self):
- '''
- Methode de MonteCarlo
- '''
- txt = "# Simulation par MonteCarlo\n"
- txt += "%s = MonteCarlo( %s )\n" % (self.variable["myAlgo"], self.variable["myEvent"])
- txt += "\n"
-
- return txt
-
- def LHS (self):
- '''
- Methode LHS
- '''
- txt = "# Simulation par LHS\n"
- txt += "%s = LHS( %s )\n" % (self.variable["myAlgo"], self.variable["myEvent"])
- txt += "\n"
-
- return txt
-
- def ImportanceSampling (self):
- '''
- Methode de tirage d importance
- '''
- dimension = 0
- if ( self.DictMCVal.has_key( 'MeanVector' ) ):
- meanVector = self.DictMCVal[ 'MeanVector' ]
- dimension = len( meanVector )
-
- txt = "# Simulation par Tirage d'importance\n"
- txt += "# Densite d'importance\n"
- txt += "%s = NumericalPoint( %s )\n" % (self.variable["meanVector"], self.variable["n"])
- for i in range(dimension):
- txt += "%s[%d] = %g\n" % (self.variable["meanVector"], i, meanVector[i])
-
- txt += "%s = Normal( %s, CovarianceMatrix( IdentityMatrix( %s ) ) )\n" % (self.variable["importanceDensity"], self.variable["meanVector"], self.variable["n"])
- txt += "%s = ImportanceSampling( %s, Distribution( %s ) )\n" % (self.variable["myAlgo"], self.variable["myEvent"], self.variable["importanceDensity"])
- txt += "\n"
-
- return txt
-
- def FORM (self):
- '''
- Methode FORM
- '''
- txt = "# Algorithme FORM\n"
- txt += "%s = FORM ( NearestPointAlgorithm( %s ), %s, %s )\n" % (self.variable["myAlgo"], self.variable["myOptimizer"], self.variable["myEvent"], self.variable["startingPoint"])
- txt += "\n"
-
- return txt
-
- def SORM (self):
- '''
- Methode SORM
- '''
- txt = "# Algorithme SORM\n"
- txt += "%s = SORM ( NearestPointAlgorithm( %s ), %s, %s )\n" % (self.variable["myAlgo"], self.variable["myOptimizer"], self.variable["myEvent"], self.variable["startingPoint"])
- txt += "\n"
-
- return txt
-
- def RunAlgorithm (self):
- '''
- Do the computation
- '''
- txt = ""
- if ( self.DictMCVal.has_key( 'FunctionCallsNumber' ) ):
- if ( self.DictMCVal[ 'FunctionCallsNumber' ] == "yes" ):
- txt += "%s = %s.getEvaluationCallsNumber()\n" % (self.variable["modelEvaluationCalls"], self.variable["model"])
- txt += "%s = %s.getGradientCallsNumber()\n" % (self.variable["modelGradientCalls"], self.variable["model"])
- txt += "%s = %s.getHessianCallsNumber()\n" % (self.variable["modelHessianCalls"], self.variable["model"])
- txt += "\n"
-
- txt += "# Perform the computation\n"
- txt += "%s.run()\n" % self.variable["myAlgo"]
- txt += "\n"
-
-
- if ( self.DictMCVal.has_key( 'FunctionCallsNumber' ) ):
- if ( self.DictMCVal[ 'FunctionCallsNumber' ] == "yes" ):
- txt += "%s = %s.getEvaluationCallsNumber() - %s\n" % (self.variable["modelEvaluationCalls"], self.variable["model"], self.variable["modelEvaluationCalls"])
- txt += "%s = %s.getGradientCallsNumber() - %s\n" % (self.variable["modelGradientCalls"], self.variable["model"], self.variable["modelGradientCalls"])
- txt += "%s = %s.getHessianCallsNumber() - %s\n" % (self.variable["modelHessianCalls"], self.variable["model"], self.variable["modelHessianCalls"])
- txt += "\n"
- txt += "print '%s =', %s\n" % ("model Evaluation Calls", self.variable["modelEvaluationCalls"])
- txt += "print '%s =', %s\n" % ("model Gradient Calls", self.variable["modelGradientCalls"])
- txt += "print '%s =', %s\n" % ("model Hessian Calls", self.variable["modelHessianCalls"])
- txt += "\n"
-
- return txt
-
- def Cobyla (self):
- '''
- Methode Cobyla
- '''
- txt = "# Optimisation par Cobyla\n"
- txt += "%s = Cobyla()\n" % self.variable["myOptimizer"]
- txt += "#%s = CobylaSpecificParameters()\n" % self.variable["specificParameters"]
- txt += "#%s.setSpecificParameters( %s )\n" % (self.variable["myOptimizer"], self.variable["specificParameters"])
- txt += "\n"
-
- return txt
-
- def AbdoRackwitz (self):
- '''
- Methode AbdoRackwitz
- '''
- txt = "# Optimisation par AbdoRackwitz\n"
- txt += "%s = AbdoRackwitz()\n" % self.variable["myOptimizer"]
- txt += "#%s = AbdoRackwitzSpecificParameters()\n" % self.variable["specificParameters"]
- txt += "#%s.setSpecificParameters( %s )\n" % (self.variable["myOptimizer"], self.variable["specificParameters"])
- txt += "\n"
- return txt
-
- def Beta (self, loi):
- '''
- Definition de la loi Beta
- '''
- settings = {
- "RT" : "Beta.RT",
- "MuSigma" : "Beta.MUSIGMA",
- }
- if loi[ 'Settings' ] == 'RT' :
- arg1 = loi[ 'R' ]
- arg2 = loi[ 'T' ]
- else :
- arg1 = loi[ 'Mu' ]
- arg2 = loi[ 'Sigma' ]
-
- arg3 = loi[ 'A' ]
- arg4 = loi[ 'B' ]
- txt = "Beta( %g, %g, %g, %g, %s )" % (arg1, arg2, arg3, arg4, settings[ loi[ 'Settings' ] ])
- return txt
-
- def Exponential (self, loi):
- '''
- Definition de la loi Exponential
- '''
- arg1 = loi[ 'Lambda' ]
- arg2 = loi[ 'Gamma' ]
- txt = "Exponential( %g, %g )" % (arg1, arg2)
- return txt
-
- def Gamma (self, loi):
- '''
- Definition de la loi Gamma
- '''
- settings = {
- "KLambda" : "Gamma.KLAMBDA",
- "MuSigma" : "Gamma.MUSIGMA",
- }
- if loi[ 'Settings' ] == 'KLambda' :
- arg1 = loi[ 'K' ]
- arg2 = loi[ 'Lambda' ]
- else :
- arg1 = loi[ 'Mu' ]
- arg2 = loi[ 'Sigma' ]
-
- arg3 = loi[ 'Gamma' ]
- txt = "Gamma( %g, %g, %g, %s )" % (arg1, arg2, arg3, settings[ loi[ 'Settings' ] ])
- return txt
-
- def Geometric (self, loi):
- '''
- Definition de la loi Geometric
- '''
- txt = "Geometric( %g )" % loi[ 'P' ]
- return txt
-
- def Gumbel (self, loi):
- '''
- Definition de la loi Gumbel
- '''
- settings = {
- "AlphaBeta" : "Gumbel.ALPHABETA",
- "MuSigma" : "Gumbel.MUSIGMA",
- }
- if loi[ 'Settings' ] == 'AlphaBeta' :
- arg1 = loi[ 'Alpha' ]
- arg2 = loi[ 'Beta' ]
- else :
- arg1 = loi[ 'Mu' ]
- arg2 = loi[ 'Sigma' ]
-
- txt = "Gumbel( %g, %g, %s )" % (arg1, arg2, settings[ loi[ 'Settings' ] ])
- return txt
-
- def Histogram (self, loi):
- '''
- Definition de la loi Histogram
- '''
- arg1 = loi[ 'First' ]
- arg2 = loi[ 'Values' ]
- txt = "Histogram( %g, %s )" % (arg1, arg2)
- return txt
-
- def Laplace (self, loi):
- '''
- Definition de la loi Laplace
- '''
- arg1 = loi[ 'Lambda' ]
- arg2 = loi[ 'Mu' ]
- txt = "Laplace( %g, %g )" % (arg1, arg2)
- return txt
-
- def Logistic (self, loi):
- '''
- Definition de la loi Logistic
- '''
- arg1 = loi[ 'Alpha' ]
- arg2 = loi[ 'Beta' ]
- txt = "Logistic( %g, %g )" % (arg1, arg2)
- return txt
-
- def LogNormal (self, loi):
- '''
- Definition de la loi LogNormal
- '''
- settings = {
- "MuSigmaLog" : "LogNormal.MUSIGMA_LOG",
- "MuSigma" : "LogNormal.MUSIGMA",
- "MuSigmaOverMu" : "LogNormal.MU_SIGMAOVERMU",
- }
- if loi[ 'Settings' ] == 'MuSigmaLog' :
- arg1 = loi[ 'MuLog' ]
- arg2 = loi[ 'SigmaLog' ]
- elif loi[ 'Settings' ] == 'MuSigmaOverMu' :
- arg1 = loi[ 'Mu' ]
- arg2 = loi[ 'SigmaOverMu' ]
- else :
- arg1 = loi[ 'Mu' ]
- arg2 = loi[ 'Sigma' ]
-
- arg3 = loi[ 'Gamma' ]
- txt = "LogNormal( %g, %g, %g, %s )" % (arg1, arg2, arg3, settings[ loi[ 'Settings' ] ])
- return txt
-
- def MultiNomial (self, loi):
- '''
- Definition de la loi MultiNomial
- '''
- arg1 = loi[ 'Values' ]
- arg2 = loi[ 'N' ]
- txt = "MultiNomial( NumericalPoint( %s ) , %d)" % (arg1, arg2)
- return txt
-
- def NonCentralStudent (self, loi):
- '''
- Definition de la loi NonCentralStudent
- '''
- arg1 = loi[ 'Nu' ]
- arg2 = loi[ 'Delta' ]
- arg3 = loi[ 'Gamma' ]
- txt = "NonCentralStudent( %g, %g )" % (arg1, arg2, arg3)
- return txt
-
- def Normal (self, loi):
- '''
- Definition de la loi Normal
- '''
- arg1 = loi[ 'Mu' ]
- arg2 = loi[ 'Sigma' ]
- txt = "Normal( %g, %g )" % (arg1, arg2)
- return txt
-
- def TruncatedNormal (self, loi):
- '''
- Definition de la loi TruncatedNormal
- '''
- arg1 = loi[ 'MuN' ]
- arg2 = loi[ 'SigmaN' ]
- arg3 = loi[ 'A' ]
- arg4 = loi[ 'B' ]
- txt = "TruncatedNormal( %g, %g, %g, %g )" % (arg1, arg2, arg3, arg4)
- return txt
-
- def Poisson (self, loi):
- '''
- Definition de la loi Poisson
- '''
- txt = "Poisson( %g )" % loi[ 'Lambda' ]
- return txt
-
- def Rayleigh (self, loi):
- '''
- Definition de la loi Rayleigh
- '''
- arg1 = loi[ 'Sigma' ]
- arg2 = loi[ 'Gamma' ]
- txt = "Rayleigh( %g, %g )" % (arg1, arg2)
- return txt
-
- def Student (self, loi):
- '''
- Definition de la loi Student
- '''
- arg1 = loi[ 'Mu' ]
- arg2 = loi[ 'Nu' ]
- arg3 = loi[ 'Sigma' ]
- txt = "Student( %g, %g, %g )" % (arg1, arg2, arg3)
- return txt
-
- def Triangular (self, loi):
- '''
- Definition de la loi Triangular
- '''
- arg1 = loi[ 'A' ]
- arg2 = loi[ 'M' ]
- arg3 = loi[ 'B' ]
- txt = "Triangular( %g, %g, %g )" % (arg1, arg2, arg3)
- return txt
-
- def Uniform (self, loi):
- '''
- Definition de la loi Uniform
- '''
- arg1 = loi[ 'A' ]
- arg2 = loi[ 'B' ]
- txt = "Uniform( %g, %g )" % (arg1, arg2)
- return txt
-
- def UserDefined (self, loi):
- '''
- Definition de la loi UserDefined
- '''
- txt = "** UserDefined not defined yet **"
- return txt
-
- def Weibull (self, loi):
- '''
- Definition de la loi Weibull
- '''
- settings = {
- "AlphaBeta" : "Weibull.ALPHABETA",
- "MuSigma" : "Weibull.MUSIGMA",
- }
- if loi[ 'Settings' ] == 'AlphaBeta' :
- arg1 = loi[ 'Alpha' ]
- arg2 = loi[ 'Beta' ]
- else :
- arg1 = loi[ 'Mu' ]
- arg2 = loi[ 'Sigma' ]
-
- arg3 = loi[ 'Gamma' ]
- txt = "Weibull( %g, %g, %g, %s )" % (arg1, arg2, arg3, settings[ loi[ 'Settings' ] ])
- return txt
-
-
-
- def GraphiquePDF (self, loi, chemin, fichier):
- '''
- Produit une image PNG representant la PDF de la loi
- '''
- txt = headerSTD % self.OpenTURNS_path
- txt += "dist = %s\n" % apply( STDGenerateur.__dict__[ loi[ 'Kind' ] ], (self, loi) )
- txt += "graph = dist.drawPDF()\n"
- txt += "graph.draw( '%s/%s' , 640, 480, GraphImplementation.PNG)\n" % (chemin, fichier)
- txt += footerSTD
- return txt
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
-Ce module contient le generateur XML pour Openturns
-"""
-import sys
-print sys.path
-from Extensions.i18n import tr
-import openturns
-
-# Dictionnaires de conversion des valeurs lues dans EFICAS
-# en valeurs reconnues par Open TURNS
-# Les clefs 'None' sont les valeurs par defaut
-
-VariableTypeByName = {
- "in" : openturns.WrapperDataVariableType.IN,
- "out" : openturns.WrapperDataVariableType.OUT,
- None : openturns.WrapperDataVariableType.IN,
- }
-
-FileTypeByName = {
- "in" : openturns.WrapperDataFileType.IN,
- "out" : openturns.WrapperDataFileType.OUT,
- None : openturns.WrapperDataFileType.IN,
- }
-
-SymbolProvidedByName = {
- "no" : openturns.WrapperSymbolProvided.NO,
- "yes" : openturns.WrapperSymbolProvided.YES,
- None : openturns.WrapperSymbolProvided.NO,
- }
-
-WrapperStateByName = {
- "shared" : openturns.WrapperState.SHARED,
- "specific" : openturns.WrapperState.SPECIFIC,
- None : openturns.WrapperState.SPECIFIC,
- }
-
-WrapperModeByName = {
- "static-link" : openturns.WrapperMode.STATICLINK,
- "dynamic-link" : openturns.WrapperMode.DYNAMICLINK,
- "fork" : openturns.WrapperMode.FORK,
- None : openturns.WrapperMode.FORK,
- }
-
-WrapperDataTransferByName = {
- "files" : openturns.WrapperDataTransfer.FILES,
- "pipe" : openturns.WrapperDataTransfer.PIPE,
- "arguments" : openturns.WrapperDataTransfer.ARGUMENTS,
- "socket" : openturns.WrapperDataTransfer.SOCKET,
- "corba" : openturns.WrapperDataTransfer.CORBA,
- None : openturns.WrapperDataTransfer.FILES,
- }
-
-#==========================
-# La classe de creation XML
-#==========================
-
-class XMLGenerateur :
-
- '''
- Generation du fichier XML
- '''
- def __init__ (self, appli, DictMCVal, DictVariables ) :
- self.DictMCVal = DictMCVal
- self.DictVariables = DictVariables
- self.appli = appli
-
- def CreeXML (self) :
- '''
- Pilotage general de la creation du fichier XML
- '''
- data = openturns.WrapperData()
- data.setLibraryPath( self.GetMCVal('WrapperPath','') )
- data.setVariableList( self.VariableList() )
- data.setFunctionDescription( self.FunctionDefinition() )
- data.setGradientDescription( self.GradientDefinition() )
- data.setHessianDescription( self.HessianDefinition() )
- data.setFileList( self.FileList() )
- data.setParameters( self.Parameters() )
- #data.setFrameworkData( self.FrameworkData() )
-
- wrapper=openturns.WrapperFile()
- wrapper.setWrapperData( data )
-
- return wrapper
-
-
- class __variable_ordering:
- def __init__ (self, dictVar) :
- self.dictVar = dictVar
-
- def __call__(self, a, b):
- return self.dictVar[a]['numOrdre'] - self.dictVar[b]['numOrdre']
-
- def VariableList (self) :
- '''
- Ecrit la liste des variables
- '''
- varList = openturns.WrapperDataVariableCollection()
- for var in sorted( self.DictVariables.keys(), self.__variable_ordering( self.DictVariables ) ) :
- varList.add( self.Variable( var, self.DictVariables[var] ) )
- return varList
-
- def Variable (self, var, dictVar) :
- '''
- Ecrit le parametrage d une variable
- '''
- variable = openturns.WrapperDataVariable()
- variable.id_ = var
- if dictVar[ 'Type' ] in VariableTypeByName.keys() :
- variable.type_ = VariableTypeByName[ dictVar[ 'Type' ] ]
- if dictVar.has_key('Comment') : variable.comment_ = dictVar[ 'Comment' ]
- if dictVar.has_key('Unit') : variable.unit_ = dictVar[ 'Unit' ]
- if dictVar.has_key('Regexp') : variable.regexp_ = dictVar[ 'Regexp' ]
- if dictVar.has_key('Format') : variable.format_ = dictVar[ 'Format' ]
- return variable
-
- def FunctionDefinition (self) :
- '''
- Ecrit la description de la Fonction
- '''
- func = openturns.WrapperFunctionDescription()
- func.name_ = self.GetMCVal( 'FunctionName', '' )
- if (len(func.name_) != 0) : func.provided_ = SymbolProvidedByName[ 'yes' ]
- return func
-
- def GradientDefinition (self) :
- '''
- Ecrit la description du Gradient
- '''
- grad = openturns.WrapperFunctionDescription()
- grad.name_ = self.GetMCVal( 'GradientName', '' )
- if (len(grad.name_) != 0) : grad.provided_ = SymbolProvidedByName[ 'yes' ]
- return grad
-
- def HessianDefinition (self) :
- '''
- Ecrit la description de la Hessienne
- '''
- hess = openturns.WrapperFunctionDescription()
- hess.name_ = self.GetMCVal( 'HessianName', '' )
- if (len(hess.name_) != 0) : hess.provided_ = SymbolProvidedByName[ 'yes' ]
- return hess
-
-
-
- def FileList (self) :
- '''
- Ecrit la liste des fichiers
- '''
- fileList = openturns.WrapperDataFileCollection()
- for dictFile in self.GetMCVal('Files', []) :
- fileList.add( self.File( dictFile ) )
- return fileList
-
- def File (self, dictFile ) :
- '''
- Ecrit le parametrage d un fichier
- '''
- fich = openturns.WrapperDataFile()
- fich.id_ = dictFile[ 'Id' ]
- if dictFile[ 'Type' ] in FileTypeByName.keys() :
- fich.type_ = FileTypeByName[ dictFile[ 'Type' ] ]
- if dictFile.has_key('Name') : fich.name_ = dictFile[ 'Name' ]
- if dictFile.has_key('Path') : fich.path_ = dictFile[ 'Path' ]
- if dictFile.has_key('Subst') :
- import string
- fich.subst_ = string.join( dictFile[ 'Subst' ], ',' )
- return fich
-
- def Parameters (self) :
- '''
- Ecrit les parametres de couplage au code externe
- '''
- parameters = openturns.WrapperParameter()
- parameters.mode_ = WrapperModeByName[ self.GetMCVal('WrapCouplingMode') ]
- if (parameters.mode_ == openturns.WrapperMode.FORK ):
- parameters.command_ = self.GetMCVal('Command')
- userPrefix = self.GetMCVal('UserPrefix', None)
- if userPrefix != None : parameters.userPrefix_ = userPrefix
- parameters.state_ = WrapperStateByName[ self.GetMCVal('State') ]
- parameters.in_ = WrapperDataTransferByName[ self.GetMCVal('InDataTransfer') ]
- parameters.out_ = WrapperDataTransferByName[ self.GetMCVal('OutDataTransfer') ]
- return parameters
-
- def FrameworkData (self) :
- '''
- Ecrit les donnees liees a l utilisation d un framework englobant
- '''
- framework = openturns.WrapperFrameworkData()
-# framework.studycase_ = "12:23:34"
-# framework.componentname_ = self.GetMCVal('SolverComponentName', 'UNDEFINED')
- CN = self.GetMCVal('SolverComponentName', 'UNDEFINED')
- print 'CN = %s', CN
- framework.componentname_ = CN
- return framework
-
-
- # ---------------------------------------------------------------------------------
-
-
- def GetTag (self, tag) :
- '''
- Recupere la chaine associee au tag dans la table dictTagsXML.
- Leve une exception si le tag n est pas trouve
- '''
- if ( dictTagsXML.has_key(tag) ) :
- return dictTagsXML[tag]
- else :
- raise KeyError, tr("Tag %s non-defini. Ceci est un bogue interne. en informer les developpeurs.", tag)
- pass
-
- def GetMCVal (self, MC, default = None, mandatory = False) :
- '''
- Recupere la chaine associee au MC dans la table DictMCVal.
- Leve une exception si le MC n est pas trouve et mandatory vaut True
- '''
- if ( self.DictMCVal.has_key(MC) and self.DictMCVal[MC] != None ) :
- return self.DictMCVal[MC]
- else :
- if ( mandatory ) :
- raise KeyError, tr(" Le mot-cle %s est obligatoire.", MC)
- else :
- return default
- pass
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-import traceback
-import types,string,re,os
-from Extensions.i18n import tr
-from generator_python import PythonGenerator
-
-# Groupes de mailles dont les types sont definis par des prefixes dans leur nom
-usePrefix = False # les noms ont des prefixes (True) ou non (False)
-# liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom
-# Ce prefixe (et caractere _) doivent etre supprimes dans le fichier .phys
-listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",
- "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",
- "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",
- "PORT_OMEGA","POST_PHI","PB_GRID",
- "SCUTE","SCUTN","ZS","ZJ","ZT")
-# liste des prefixes des groupes de mailles, sans le separateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire
-dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'),
- 'CONDUCTOR':('COND',),
- 'STRANDED_INDUCTOR':('CURRENT', ),
- 'EPORT':('EPORT', ),
- 'HPORT':('HPORT', ),
- 'ZSURFACIC':('ZS', ),
- 'ZINSULATOR':('ZJ', ),
- 'NILMAT':('NILMAT', )}
-# separateur entre le prefixe et le reste du nom du groupe de maille
-sepNomGroupeMaille = '_'
-
-# types de problemes
-HARMONIC = 'HARMONIC' # probleme frequentiel
-TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'CARMEL3D',
- # La factory pour creer une instance du plugin
- 'factory' : CARMEL3DGenerator,
- }
-
-
-class CARMEL3DGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
-
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
-
-#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None):
-
- self.initDico()
-
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
-
- if self.debug:
- print "self.text = %s", self.text
-
- # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
- # si le jdc est valide (sinon cela n a pas de sens)
- if obj.isValid() :
- # constitution du bloc VERSION du fichier PHYS (existe toujours)
- try :
- self.generBLOC_VERSION(obj)
- except ValueError, err:
- raise ValueError(str(err))
-
- # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
- self.generBLOC_MATERIALS()
-
- # constitution du bloc SOURCES du fichier PHYS (existe toujours)
- self.generBLOC_SOURCES()
-
-# print "texte carmel3d :\n",self.texteCarmel3D
-# print "dictMaterDielectric : ",self.dictMaterDielectric
- if self.debug:
- print "dictMaterConductor : %s", repr(self.dictMaterConductor)
-
- return self.text
-
-
-#----------------------------------------------------------------------------------------
-# initialisations
-#----------------------------------------------------------------------------------------
-
- def initDico(self) :
-
- self.texteCarmel3D=""
- self.debug = True # affichage de messages pour deboguage (.true.) ou non
- self.dicoEtapeCourant=None
- self.dicoMCFACTCourant=None
- self.dicoCourant=None
- self.dictGroupesMaillage = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[]} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
- self.dictMaterConductor={}
- self.dictMaterDielectric={}
- self.dictMaterZsurfacic={}
- self.dictMaterEmIso={}
- self.dictMaterEmAnIso={}
- self.dictMaterNilmat={}
- self.dictMaterZinsulator={}
- self.dictSourceStInd={}
- self.dictSourceEport={}
- self.dictSourceHport={}
- # on force le probleme a etre frequentiel, seul possible en l'etat des choses
- self.problem = HARMONIC
-
-
-#----------------------------------------------------------------------------------------
-# ecriture
-#----------------------------------------------------------------------------------------
-
- def writeDefault(self,fn) :
- """Ecrit le fichier de parametres (PHYS) pour le code Carmel3D"""
- if self.debug:
- print "ecriture du fichier de parametres (PHYS)"
- filePHYS = fn[:fn.rfind(".")] + '.phys'
- f = open( str(filePHYS), 'wb')
- f.write( self.texteCarmel3D)
- f.close()
-
-#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
-#----------------------------------------------------------------------------------------
-
- def generMCSIMP(self,obj) :
- """recuperation de l objet MCSIMP"""
- if self.debug:
- print "MCSIMP %(v_1)s %(v_2)s", {'v_1': obj.nom, "v_2": obj.valeur}
- s=PythonGenerator.generMCSIMP(self,obj)
- self.dicoCourant[obj.nom]=obj.valeurFormatee
- return s
-
-
-#----------------------------------------------------------------------------------------
- def generMCFACT(self,obj) :
- """recuperation de l objet MCFACT"""
- dico={}
- self.dicoMCFACTCourant=dico
- self.dicoCourant=self.dicoMCFACTCourant
- s=PythonGenerator.generMCFACT(self,obj)
- self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
- self.dicoMCFACTCourant=None
- self.dicoCourant=self.dicoEtapeCourant
- return s
-
-#----------------------------------------------------------------------------------------
- def generPROC_ETAPE(self,obj):
- """analyse des PROC du catalogue ( VERSION )"""
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- s=PythonGenerator.generPROC_ETAPE(self,obj)
- obj.valeur=self.dicoEtapeCourant
- if self.debug:
- print "PROC_ETAPE %(v_1)s %(v_2)s", \
- {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
- s=PythonGenerator.generPROC_ETAPE(self,obj)
- return s
-
-#----------------------------------------------------------------------------------------
- def generETAPE(self,obj):
- """analyse des OPER du catalogue"""
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- s=PythonGenerator.generETAPE(self,obj)
- obj.valeur=self.dicoEtapeCourant
- if self.debug:
- print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s", \
- {'v_1': obj.nom, 'v_2': obj.valeur}
- if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
- if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
- if obj.nom=="SOURCE" : self.generSOURCE(obj)
- s=PythonGenerator.generETAPE(self,obj)
- return s
-
-#----------------------------------------------------------------------------------------
- def generMACRO_ETAPE(self,obj):
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- import generator
- monGenerateur=generator.plugins["CARMEL3D"]()
- jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
- if self.debug:
- print "jdc_aux_texte : %s", jdc_aux_texte
-
- for cle in monGenerateur.dictMaterConductor:
- self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
- for cle in monGenerateur.dictMaterDielectric:
- self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
- for cle in monGenerateur.dictMaterZsurfacic:
- self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
- for cle in monGenerateur.dictMaterEmIso:
- self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
- for cle in monGenerateur.dictMaterEmAnIso:
- self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
- for cle in monGenerateur.dictMaterNilmat:
- self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
- for cle in monGenerateur.dictMaterZinsulator:
- self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
-
- print "________FIN MACRO______________________________________"
- s=PythonGenerator.generMACRO_ETAPE(self,obj)
- return s
-
-#----------------------------------------------------------------------------------------
-#----------------------------------------------------------------------------------------
- def generMESHGROUP(self,obj):
- """preparation de la ligne NAME referencant le groupe de mailles
- associe le groupe de mailles au materiau ou a la source utilisateur
- on sauvegarde aussi les noms des groupes de maillage
- """
-
- try:
- if usePrefix:
- nomGroupeMaillage = self.nomReelGroupeMaillage(obj.getSdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
- else:
- nomGroupeMaillage = obj.getSdname() # nom du groupe de maillage, i.e. nom du concept
- # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
- # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
- #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupeMaillage
- #
- # on utilise le fait que obj.valeur est un dictionnaire
- if self.debug:
- print "obj.valeur.keys()= %s", obj.valeur.keys()
- if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
- raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source.", nomGroupeMaillage)
- # association a un materiau
- if 'MATERIAL' in obj.valeur.keys():
- self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- self.dictGroupesMaillage['ordreMateriauxJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
- # association a une source
- elif 'SOURCE' in obj.valeur.keys():
- self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- self.dictGroupesMaillage['ordreSourcesJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
- # erreur ni materiau ni source associee
- else:
- raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau ou source.", nomGroupeMaillage)
- if self.debug:
- print "self.dictGroupesMaillage= %s", repr(self.dictGroupesMaillage)
- except:
- pass
-
-
- def generMATERIAL(self,obj):
- """preparation du bloc correspondant a un materiau du fichier PHYS"""
- texte=""
- if self.debug:
- print "generation material obj valeur = %s", obj.valeur
- try :
- nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
- if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
- if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
- if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
- if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
- if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
- if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
- if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
- except:
- pass
-
- def generMATERIAL_CONDUCTOR(self,obj):
- """preparation du sous bloc CONDUCTOR"""
- texte=""
- if self.debug:
- print "_____________cond_____________"
- # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
- if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
- print "ERREUR! Le bloc CONDUCTOR doit contenir PERMEABILITY et CONDUCTIVITY."
- else:
- # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
- for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
- # debut du sous bloc de propriete du DIELECTRIC
- texte+=" ["+keyN1+"\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
- # car sinon ces valeurs sont definies dans des fichiers annexes
- homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
- isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
- if homogeneous and isotropic:
- # loi (lineaire ou non)
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
- # valeur de la loi lineaire
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
- # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
- # seuls les reels sont pris en compte
- if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
- texte+=" [NONLINEAR \n"
- texte+=" ISOTROPY TRUE\n"
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
- # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
- for keyN2 in obj.valeur[keyN1] :
- if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
- # fin du sous-bloc NONLINEAR
- texte+=" ]"+"\n"
- # fin du sous bloc de propriete
- texte+=" ]"+"\n"
- if self.debug:
- print "texte = %s", texte
- self.dictMaterConductor[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
-
- def generMATERIAL_DIELECTRIC(self,obj):
- """preparation du sous bloc DIELECTRIC"""
- texte=""
- if self.debug:
- print "______________nocond_____________"
- # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
- if 'PERMEABILITY' not in obj.valeur or 'PERMITTIVITY' not in obj.valeur:
- print "ERREUR! Le bloc DIELECTRIC doit contenir PERMEABILITY et PERMITTIVITY."
- else:
- # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
- for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
- # debut du sous bloc de propriete du DIELECTRIC
- texte+=" ["+keyN1+"\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
- # car sinon ces valeurs sont definies dans des fichiers annexes
- homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
- isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
- if homogeneous and isotropic:
- # loi (lineaire ou non)
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
- # valeur de la loi lineaire
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
- # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
- # seuls les reels sont pris en compte
- if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
- texte+=" [NONLINEAR \n"
- texte+=" ISOTROPY TRUE\n"
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
- # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
- for keyN2 in obj.valeur[keyN1] :
- if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
- # fin du sous-bloc NONLINEAR
- texte+=" ]"+"\n"
- # fin du sous bloc de propriete
- texte+=" ]"+"\n"
- if self.debug:
- print "texte = %s", texte
- self.dictMaterDielectric[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
-
- def generMATERIAL_ZSURFACIC(self,obj):
- """preparation du sous bloc ZSURFACIC"""
- texte=""
- if self.debug:
- print "______________zsurf_____________"
- # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
- if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
- print "ERREUR! Le bloc ZSURFACIC doit contenir PERMEABILITY et CONDUCTIVITY."
- else:
- # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
- for keyN1 in obj.valeur :
- if keyN1=='TYPE': continue
- # print "type loi = ", obj.valeur[keyN1]['LAW']
- # debut du sous bloc de propriete du DIELECTRIC
- texte+=" ["+keyN1+"\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
- # car sinon ces valeurs sont definies dans des fichiers annexes
- homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
- isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
- if homogeneous and isotropic:
- # loi (lineaire ou non)
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
- # valeur de la loi lineaire
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
- # fin du sous bloc de propriete
- texte+=" ]"+"\n"
- if self.debug:
- print "texte = %s", texte
- self.dictMaterZsurfacic[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
-
- def generMATERIAL_EMISO(self,obj):
- """preparation du sous bloc EM_ISOTROPIC_FILES.
- Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
- ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
- """
- texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
- texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
- # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
- #from os.path import basename
- #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
- #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
- # print "obj get sdname= ", obj.getSdname()
- # if obj.getSdname() in self.dictMaterEmIso.keys() :
- # self.dictMaterEmIso[obj.getSdname()].append(texte)
- # else :
- self.dictMaterEmIso[obj.getSdname()]=texte
-
- def generMATERIAL_EMANISO(self,obj):
- """preparation du sous bloc EM_ANISOTROPIC_FILES.
- Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
- ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
- """
- texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
- texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
- # print "obj get sdname= ", obj.getSdname()
- # if obj.getSdname() in self.dictMaterEmAnIso.keys() :
- # self.dictMaterEmAnIso[obj.getSdname()].append(texte)
- # else :
- self.dictMaterEmAnIso[obj.getSdname()]=texte
-
- def generMATERIAL_NILMAT(self,obj):
- """preparation du sous bloc NILMAT"""
- texte=""
- self.dictMaterNilmat[obj.getSdname()]=texte
-
- def generMATERIAL_ZINSULATOR(self,obj):
- """"preparation du sous bloc ZINSULATOR"""
- texte=""
- self.dictMaterZinsulator[obj.getSdname()]=texte
-
-#-------------------------------------------------------------------
-
- def generSOURCE(self,obj):
- """preparation du bloc correspondant a une source du fichier PHYS"""
- if self.debug:
- print "generation source obj valeur = %s", obj.valeur
- texte=""
- try :
- # test de la presence des types de sources reconnus
- # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
- # la source ne peut contenir au plus qu'un type de source.
- if "STRANDED_INDUCTOR" in obj.valeur:
- self.generSOURCE_STRANDED_INDUCTOR(obj)
- elif "HPORT" in obj.valeur:
- self.generSOURCE_HPORT(obj)
- elif "EPORT" in obj.valeur:
- self.generSOURCE_EPORT(obj)
- else:
- print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
- except:
- pass
-
- def generSOURCE_STRANDED_INDUCTOR(self,obj):
- """preparation du sous bloc STRANDED_INDUCTOR"""
- texte=""
- sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
- try :
- texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
- # test de la presence d'une forme de source reconnue
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
- # la source ne peut contenir au plus qu'un type de source.
- if "WAVEFORM_CONSTANT" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
- print tr("ATTENTION! Une source constante \
- n'est possible qu'a frequence nulle \
- en regime frequentiel")
- elif "WAVEFORM_SINUS" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
- else:
- print tr("ERREUR! Une forme de la source du \
- type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
- self.dictSourceStInd[obj.getSdname()]=texte
- if self.debug:
- print texte
- except Exception:
- pass
-
- def generSOURCE_HPORT(self,obj):
- """preparation du sous bloc HPORT"""
- texte=""
- sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
- try :
- texte+=" TYPE %s\n" % str(sdict['TYPE'])
- # test de la presence d'une forme de source reconnue
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
- # la source ne peut contenir au plus qu'un type de source.
- if "WAVEFORM_CONSTANT" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
- print tr("ATTENTION! Une source constante n'est \
- possible qu'a frequence nulle en regime frequentiel")
- elif "WAVEFORM_SINUS" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
- else:
- print tr("ERREUR! Une forme de la source du type \
- WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
- self.dictSourceHport[obj.getSdname()]=texte
- if self.debug:
- print texte
- except:
- pass
-
- def generSOURCE_EPORT(self,obj):
- """preparation du sous bloc EPORT"""
- texte=""
- sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
- try :
- texte+=" TYPE %s\n" % str(sdict['TYPE'])
- # test de la presence d'une forme de source reconnue
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
- # la source ne peut contenir au plus qu'un type de source.
- if "WAVEFORM_CONSTANT" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
- print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")
- elif "WAVEFORM_SINUS" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
- else:
- print tr("ERREUR! Une forme de la source du type \
- WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
- self.dictSourceEport[obj.getSdname()]=texte
- if self.debug:
- print texte
- except:
- pass
-
-#---------------------------------------------------------------------------------------
-# traitement fichier PHYS
-#---------------------------------------------------------------------------------------
-
- def generBLOC_VERSION(self,obj) :
- # constitution du bloc VERSION du fichier PHYS
- # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
- # dans le du catalogue
- version=obj.addEntite('VERSION',pos=None)
- self.generPROC_ETAPE(obj.etapes[0])
- self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
- for cle in obj.etapes[0].valeur :
- self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
- self.texteCarmel3D+="]\n"
- # destruction de l entite creee
- obj.suppEntite(version)
-
-#----------------------------------------------------------------------------------------
- def generBLOC_MATERIALS(self) :
- """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
- Le bloc MATERIALS existe toujours !
- """
- if self.debug:
- print "cle dictionnaire materconductor : %s", self.dictMaterConductor.keys()
- print "cle dictionnaire materdielectric : %s", self.dictMaterDielectric.keys()
- # constitution du bloc MATERIALS du fichier PHYS
- self.texteCarmel3D+="[MATERIALS\n"
- # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
- nomsGroupesMaillage = self.dictGroupesMaillage['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
- nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels
- if self.debug:
- print "noms groupes de mailles associes a des materiaux \
- (ordre JdC puis tri)= %(v_1)s %(v_2)s", \
- {'v_1': self.dictGroupesMaillage['ordreMateriauxJdC'], \
- 'v_2': nomsGroupesMaillage}
- # constitution du bloc CONDUCTOR du fichier PHYS si existe
- if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupesMaillage)
- # constitution du bloc DIELECTRIC du fichier PHYS si exixte
- if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupesMaillage)
- # constitution du bloc ZSURFACIC du fichier PHYS si exixte
- if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupesMaillage)
- # constitution du bloc NILMAT du fichier PHYS si exixte
- if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupesMaillage)
- # constitution du bloc ZINSULATOR du fichier PHYS si exixte
- if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupesMaillage)
- # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
- # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
- if self.dictMaterEmIso != {} : self.creaBLOC_EMISO()
- # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
- if self.dictMaterEmAnIso != {} : self.creaBLOC_EMANISO()
- # fin du bloc MATERIALS du fichier PHYS
- self.texteCarmel3D+="]\n"
-
- def creaBLOC_CONDUCTOR(self, nomsGroupesMaillage) :
- """Constitution du bloc CONDUCTOR du fichier PHYS"""
- typeBloc = 'CONDUCTOR' # initialisation du type de bloc
- dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
- if self.debug:
- print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s', \
- {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_DIELECTRIC(self, nomsGroupesMaillage) :
- """Constitution du bloc DIELECTRIC du fichier PHYS"""
- typeBloc = 'DIELECTRIC' # initialisation du type de bloc
- dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
- if self.debug:
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s', \
- {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_ZSURFACIC(self, nomsGroupesMaillage) :
- """Constitution du bloc ZSURFACIC du fichier PHYS"""
- typeBloc = 'ZSURFACIC' # initialisation du type de bloc
- dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
- if self.debug:
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s', \
- {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_EMISO(self) :
- """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
- for cle in self.dictMaterEmIso.keys():
- self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
- self.texteCarmel3D+= self.dictMaterEmIso[cle]
- self.texteCarmel3D+=" ]\n"
-
- def creaBLOC_EMANISO(self) :
- """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
- for cle in self.dictMaterEmAnIso.keys():
- self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
- self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
- self.texteCarmel3D+=" ]\n"
-
- def creaBLOC_ZINSULATOR(self, nomsGroupesMaillage) :
- """Constitution du bloc ZINSULATOR du fichier PHYS"""
- typeBloc = 'ZINSULATOR' # initialisation du type de bloc
- dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
- if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_NILMAT(self, nomsGroupesMaillage) :
- """Constitution du bloc NILMAT du fichier PHYS"""
- typeBloc = 'NILMAT' # initialisation du type de bloc
- dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
- if self.debug:
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s', \
- {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
-#----------------------------------------------------------------------------------------
- def generBLOC_SOURCES(self):
- """constitution du bloc SOURCES du fichier PHYS"""
- self.texteCarmel3D+="[SOURCES\n"
- # tri alphabetique de tous les groupes de maillage associes a des sources
- nomsGroupesMaillage = self.dictGroupesMaillage['ordreSourcesJdC'][:] # copie de l'original, qui est une liste
- nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels
- if self.debug:
- print 'noms groupes de mailles associes a des sources \
- (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s', \
- {'g_maillage_orig': self.dictGroupesMaillage['ordreSourcesJdC'], \
- 'g_maillage_trie': nomsGroupesMaillage}
- if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupesMaillage)
- if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupesMaillage)
- if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupesMaillage)
- # fin du bloc SOURCES du fichier PHYS
- self.texteCarmel3D+="]\n"
-
-
- def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupesMaillage) :
- """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
- if self.debug:
- print 'cles sources STRANDED_INDUCTOR= %s', self.dictSourceStInd.keys()
- typeBloc = 'STRANDED_INDUCTOR'
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
- # ecriture du bloc de l'inducteur bobine
- self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupesMaillage[nom]] # ecriture des proprietes de l'inducteur bobine
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_EPORT(self, nomsGroupesMaillage) :
- """constitution du bloc EPORT du fichier PHYS"""
- if self.debug:
- print 'cles sources EPORT= %s', self.dictSourceEport.keys()
- typeBloc = 'EPORT'
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
- # ecriture du bloc du port electrique
- self.texteCarmel3D+=" [EPORT\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= self.dictSourceEport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port electrique
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_HPORT(self, nomsGroupesMaillage) :
- """constitution du bloc HPORT du fichier PHYS"""
- if self.debug:
- print 'cles sources HPORT= %s', self.dictSourceHport.keys()
- typeBloc = 'HPORT'
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
- # ecriture du bloc du port magnetique
- self.texteCarmel3D+=" [HPORT\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= self.dictSourceHport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port magnetique
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
-#-------------------------------------
-# Methodes utilitaires
-# ------------------------------------
- def formateCOMPLEX(self,nbC):
- """prise en compte des differentes formes de description d un nombre complexe
- 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
- """
- if self.debug:
- print "formatage "
- print "type : %(type_nb_c)s pour %(nb_c)s", \
- {'type_nb_c': type(nbC), 'nb_c': nbC}
- nbformate =""
- if isinstance(nbC,(tuple,list)):
- if nbC[0] == "'RI'" :
- nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
- if nbC[0] == "'MP'" :
- nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
- else:
- nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
- if self.debug:
- print "nbformate : %s", nbformate
- return nbformate
-
- def nomReelGroupeMaillage(self, nom, typeBloc=None):
- """Calcule et retourne le nom reel du groupe de maillage donne en entree,
- en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
- de bloc du fichier PHYS specifie.
- Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
- """
- from string import join
- if self.debug:
- print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
- {'nom': nom, 'use_prefix': str(usePrefix)}
- nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
- if usePrefix:
- # suppression du prefixe si present
- partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
- # les tests suivants ne generent une erreur que si le prefixe est obligatoire
- if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
- print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
- indiquant le type de materiau ou de source associee", nom)
- elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
- print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable", nom)
- else:
- # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
- if typeBloc is not None:
- if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
- print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))
- elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
- print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \
- le prefixe correct pour etre associe a un type %(type_bloc)s", \
- {'nom': nom, 'type_bloc': str(typeBloc)})
- else: # c'est bon
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
- if self.debug:
- print "ce groupe de maille (%(nom)s) a un prefixe qui \
- est supprime automatiquement pour devenir : %(nom_reel)s", \
- {'nom': nom, 'nom_reel': nomReel}
- else: # c'est bon
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
- if self.debug:
- print "ce groupe de maille (%(nom)s) a un prefixe qui \
- est supprime automatiquement pour devenir : %(nom_reel)s", \
- {'nom': nom, 'nom_reel': nomReel}
- if self.debug:
- print "... %s", nomReel
- return nomReel
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-import xml.etree.cElementTree as ET
-import traceback
-import types,string,re,os
-from Extensions.i18n import tr
-from generator_python import PythonGenerator
-
-# types de problemes
-HARMONIC = 'HARMONIC' # probleme frequentiel
-TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
-
-# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
-nomPlugin = 'CARMEL3DTV0'
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : nomPlugin,
- # La factory pour creer une instance du plugin
- 'factory' : CARMEL3DTV0Generator,
- }
-
-
-
-class CARMEL3DTV0Generator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
-
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
-
-#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None):
-
- self.initDico()
-
- #self.debug = True
-
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
-
- if self.debug:
- print "self.text = %s" % self.text
-
- # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
- # si le jdc est valide (sinon cela n a pas de sens)
- if obj.isValid() :
- try :
- # constitution du bloc VERSION du fichier PHYS (existe toujours)
- self.generBLOC_VERSION(obj)
-
- except ValueError, err:
- raise ValueError(str(err))
-
- return self.text
-
-
-
-
-#----------------------------------------------------------------------------------------
-# initialisations
-#----------------------------------------------------------------------------------------
-
- def initDico(self) :
- self.texteCarmel3D=""
- self.texteCarmel3D_SH=""
- self.debug = True # affichage de messages pour deboguage (.true.) ou non
- self.dicoEtapeCourant=None
- self.dicoMCFACTCourant=None
- self.dicoCourant=None
- self.dictGroupes = {} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
- self.dictMacroGroupes = {} # macro-groupe et leurs propriétés
- self.listSymetrie=[]
- self.dictMouvement= {'ordre':[]} # dictionnaire contenant les mouvements, avec liste incluse pour l'ordre
- self.nombreMouvements = 0 # nombre de mouvements définis, servant de compteur aussi
- self.dictMaterial={}
- self.dictSource={}
- self.dictStrand={}
- self.dictGroupeMilieux={"ordreSource":[], "ordreId":[]}
- self.dictDomaine={}
- # Parametre du maillage
- self.identification = ""
- self.fichierMaillage = ""
- self.echelleMaillage = ""
- # Parametre de Precision
- self.precond=""
- self.precisionLineaire=""
- self.kEpsilonDistance=""
- self.kdistanceRef=""
- self.nbIterationMax=""
- self.methodeNonLineaire = ""
- self.kEpsilonNonLinearite=""
- self.kCoefficientRelaxation=""
- self.jauge=""
- self.NBoucleTemps=""
- self.dt=""
- # Paramètres divers
- self.typeSolveur = "" # type de solveur, linéaire (Solveur_lineaire) ou non-linéaire (Solveur_non_lineaire)
- #Post traitement
- self.carteChamp="" # liste des pas de temps demandés lors du post-traitement des cartes de champ
- self.carteCourantInduit="" # liste des pas de temps demandés lors du post-traitement des cartes de courants induits
- self.carteForce="" # liste des pas de temps demandés lors du post-traitement des cartes de force
- self.post_global = [] # liste des grandeurs globales demandées lors du post-traitement
-
- # on force le probleme a etre frequentiel, seul possible en l'etat des choses
- self.problem = HARMONIC
-
- def indent(self, elem, level=0, more_sibs=False, espace=4*' '):
- """Transformation du XML créé par le module interne xml.etree.ElementTree afin d'écrire les indentations et retours à la ligne corrects.
- D'après un script original de Fredrik Lundh en 2004 (http://effbot.org/zone/element-lib.htm#prettyprint),
- modifié par Joshua Richardson en 2012 (http://stackoverflow.com/questions/749796/pretty-printing-xml-in-python)
- et par Loic Chevallier en 2014 (ajout du reglage de l'indentation).
- L'indentation est de 4 espaces par défaut (cf. argument optionel : espace)
- Utilisation : self.indent(root), avant écriture dans un fichier de root = ET.Element("configuration") ou de tree = ET.ElementTree(root)
- où ET = xml.etree.ElementTree
- """
- i = "\n"
- if level:
- i += (level-1) * espace
- num_kids = len(elem)
- if num_kids:
- if not elem.text or not elem.text.strip():
- elem.text = i + espace
- if level:
- elem.text += espace
- count = 0
- for kid in elem:
- self.indent(kid, level+1, count < num_kids - 1)
- count += 1
- if not elem.tail or not elem.tail.strip():
- elem.tail = i
- if more_sibs:
- elem.tail += espace
- else:
- if level and (not elem.tail or not elem.tail.strip()):
- elem.tail = i
- if more_sibs:
- elem.tail += espace
-
-#----------------------------------------------------------------------------------------
-# ecriture
-#----------------------------------------------------------------------------------------
-
- def writeDefault(self,fn) :
- """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
-
- file = fn[:fn.rfind(".")] # emplacement du ficher .comm (chemin complet)
- namefile=os.path.basename(file) # nom du fichier.comm
- repertory=os.path.dirname(file) # répertoire contenant le fichier .comm (emplacement absolu)
-
- # correspondances globales
- correspondance_booleen = {'oui':'true', 'non':'false'}
-
- fileXML = os.path.join(repertory, 'configuration.xml') # nom du fichier de configuration XML (chemin complet)
- if self.debug:
- print "\necriture du fichier XML : ", fileXML
- print "self.dictMaterial = ",self.dictMaterial
- print "self.dictSource = ",self.dictSource
- print "self.dictGroupes = ",self.dictGroupes
- print "self.dictMacroGroupes = ",self.dictMacroGroupes
-
- root = ET.Element("configuration")
-
- #Bloc <Maillage></Maillage>
- Maillage = ET.SubElement(root, "Maillage")
- identification = ET.SubElement(Maillage, "identification")
- identification.text = self.identification
- fichierMaillage = ET.SubElement(Maillage, "fichierMaillage")
- fichierMaillage.text = self.fichierMaillage
- echelleMaillage = ET.SubElement(Maillage, "echelleMaillage")
- correspondance_echelleMaillage = {"Metre":1.0, "Millimetre":1.0e-3}
- echelleMaillage.text = "%f" % (correspondance_echelleMaillage[self.echelleMaillage], )
-
- #Bloc <ParametrePrecision></ParametrePrecision>
- ParametrePrecision = ET.SubElement(root, "ParametrePrecision")
- TypeSolveurLineaire = ET.SubElement(ParametrePrecision, "TypeSolveurLineaire")
- if self.precond=="Crout":
- TypeSolveurLineaire.text = "1"
- if self.precond=="Jacobi":
- TypeSolveurLineaire.text = "2"
- if self.precond=="MUMPS":
- TypeSolveurLineaire.text = "3"
- kEpsilonGCP = ET.SubElement(ParametrePrecision, "kEpsilonGCP")
- kEpsilonGCP.text = "%s" %(self.kEpsilonGCP)
- nbIterationMax = ET.SubElement(ParametrePrecision, "nbIterationMax")
- nbIterationMax.text = "%s" %(self.nbIterationMax)
- if self.typeSolveur == 'Solveur_non_lineaire': # écriture des paramètres du solveur non-linéaire seulement si défini dans l'étude
- methodeNonLineaire = ET.SubElement(ParametrePrecision, "methodeNonLineaire")
- methodeNonLineaire.text = "%s" %(self.methodeNonLineaire)
- kEpsilonNonLinearite = ET.SubElement(ParametrePrecision, "kEpsilonNonLinearite")
- kEpsilonNonLinearite.text = "%s" %(self.kEpsilonNonLinearite)
- kCoefficientRelaxation = ET.SubElement(ParametrePrecision, "kCoefficientRelaxation")
- kCoefficientRelaxation.text = "%s" %(self.kCoefficientRelaxation)
- kEpsilonDistance = ET.SubElement(ParametrePrecision, "kEpsilonDistance")
- kEpsilonDistance.text = "%s" %(self.kEpsilonDistance)
- kdistanceRef = ET.SubElement(ParametrePrecision, "kdistanceRef")
- kdistanceRef.text = "%s" %(self.kdistanceRef)
- jauge = ET.SubElement(ParametrePrecision, "jauge")
- jauge.text = "%s" %(correspondance_booleen[self.jauge], )
- NBoucleTemps = ET.SubElement(ParametrePrecision, "NBoucleTemps")
- NBoucleTemps.text = "%s" %(self.NBoucleTemps)
- dt = ET.SubElement(ParametrePrecision, "dt")
- dt.text = "%s" %(self.dt)
-
- #Bloc <Milieux></Milieux>
- i=0
- j=0
- p=0
- k=0
- listeMilieux = [] # liste des milieux, dans l'ordre de création
- Milieux=ET.SubElement(root, "Milieux") # création du bloc <Milieux>...</Milieux>
- for nom in self.dictGroupes: # on parcoure tous les groupes MESHGROUP
- if self.dictGroupes[nom].has_key('MATERIAL') \
- or self.dictGroupes[nom].has_key('SOURCE') \
- or self.dictGroupes[nom].has_key('AIMANT') \
- or self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY') : # si MESHGROUP ou MACRO_GROUPE associé à au moins un matériau, source ou géométrie d'inducteur bobiné, c'est un milieu
- milieu=ET.SubElement(Milieux,"milieu" ) # création d'un nouveau milieu
- listeMilieux.append(nom) # mise à jour de la liste des milieux
- i = i+1 # incrément du numéro de milieu
- self.dictGroupes[nom]['idMilieu'] = i # affectation de l'id à ce groupe
- milieu.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
- milieu.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
- nomGroupeMaillage = ET.SubElement(milieu, "nomGroupeMaillage") # nom du groupe de maillage
- nomGroupeMaillage.text = nom
- if self.dictGroupes[nom].has_key('MATERIAL'): # matériau trouvé pour ce milieu
- material = self.dictGroupes[nom]['MATERIAL'] # on récupère le nom de la propriété du matériau, clé de self.dictMaterial
- permeabiliteLineaire=ET.SubElement(milieu, "permeabiliteLineaire")
- permeabiliteLineaire.text="%s"%(self.dictMaterial[material]["PERMEABILITY"]["VALUE"])
- if self.dictMaterial[material]["PERMEABILITY"]["LAW"]=="NONLINEAR":
- coefficientsMarrocco=ET.SubElement(milieu, "coefficientsMarrocco")
- epsilon = self.dictMaterial[material]["PERMEABILITY"]["EPSILON"]
- c = self.dictMaterial[material]["PERMEABILITY"]["C"]
- alpha = self.dictMaterial[material]["PERMEABILITY"]["ALPHA"]
- tau = self.dictMaterial[material]["PERMEABILITY"]["TAU"]
- coefficientsMarrocco.text = '%g, %g, %g, %g' % (epsilon, c, alpha, tau)
- if self.dictMaterial[material].has_key('CONDUCTIVITY'):
- conductivite=ET.SubElement(milieu, "conductivite")
- conductivite.text="%s" %(self.dictMaterial[material]["CONDUCTIVITY"]["VALUE"])
- if self.dictMaterial[material].has_key('AIMANT'):
- norme=ET.SubElement(milieu, "norme")
- norme.text="%s" %(self.dictMaterial[material]["AIMANT"]["VALUE"])
- if self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY'): # géométrie d'inducteur bobiné trouvée pour ce milieu
- strand=self.dictGroupes[nom]['STRANDED_INDUCTOR_GEOMETRY'] # on récupère le nom de la géométrie d'inducteur bobiné, clé de self.dictStrand
- axe = ET.SubElement(milieu, "axe")
- axe.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Direction"]))
- if self.dictStrand[strand]["Forme"]=="Circulaire":
- coordonneesPolaires=ET.SubElement(milieu, "coordonneesPolaires")
- coordonneesPolaires.text="true"
- origineReperePolaire=ET.SubElement(milieu, "origineReperePolaire")
- origineReperePolaire.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Centre"]))
- section=ET.SubElement(milieu, "section")
- section.text="%g" %(self.dictStrand[strand]["Section"], )
- if self.dictGroupes[nom].has_key('SOURCE'): # source trouvée pour ce milieu
- Source = self.dictGroupes[nom]['SOURCE'] # on récupère le nom de la source, clé de self.dictSource
- self.dictSource[Source]['milieux'].append(nom) # ajout du nom du groupe à cette source
- if self.dictSource[Source].has_key('STRANDED_INDUCTOR'):
- nbSpires=ET.SubElement(milieu, "nbSpires")
- nbSpires.text="%g" %(self.dictSource[Source]["STRANDED_INDUCTOR"]["NTURNS"])
-
- #Bloc <ConditionsLimitesChamps>...</ConditionsLimitesChamps>
- ConditionsLimitesChamps = ET.SubElement(root, "ConditionsLimitesChamps")
- for nomCondition in self.dictGroupes:
- if self.dictGroupes[nomCondition].has_key('CONDITION_LIMITE'): # condition aux limites associée à ce groupe, hors symétrie et mouvement
- if self.dictGroupes[nomCondition].has_key('LISTE'): # MACRO_GROUPE
- for i in range(len(self.dictGroupes[nomCondition]['LISTE'])):
- conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
- Type=ET.SubElement(conditionLimite,"type" )
- Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
- GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
- GroupeNoeud.text="%s" %(self.dictGroupes[nomCondition]['LISTE'][i])
- else: # MESHGROUP
- conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
- Type=ET.SubElement(conditionLimite,"type" )
- Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
- GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
- GroupeNoeud.text="%s" %(nomCondition)
-
- for i in range(len(self.listSymetrie)): # symétries, définies dans le bloc des conditions aux limites
- conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamp")
- Type=ET.SubElement(conditionLimite,"type" )
- Type.text="%s" %(self.listSymetrie[i]["Type"])
- GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
- GroupeNoeud.text="%s" %(self.listSymetrie[i]["Face1"])
- if 'Face2' in self.listSymetrie[i] :
- GroupeNoeud2=ET.SubElement(conditionLimite, "groupeNoeud2")
- GroupeNoeud2.text="%s" %(self.listSymetrie[i]["Face2"])
- if 'Mouvement_associe' in self.listSymetrie[i]:
- MouvementAssocie=ET.SubElement(conditionLimite, "mouvementAssocie")
- nomMouvementAssocie = self.listSymetrie[i]['Mouvement_associe'].nom # on récupère le nom du mouvement associé, car on a stocké le concept tout entier
- MouvementAssocie.text="%i"%(self.dictMouvement[nomMouvementAssocie]['ordre'], )
- if 'Groupe_Points' in self.listSymetrie[i] :
- GroupePoints=ET.SubElement(conditionLimite, "groupePoints")
- GroupePoints.text="%s" %(self.listSymetrie[i]['Groupe_Points'])
-
- #Bloc <TermeSourceElectrique>...</TermeSourceElectrique>
- TermeSourceElectrique=ET.SubElement(root, "TermeSourceElectrique")
- i=0 # ?
- if self.debug: print 'self.dictSource = ', self.dictSource
- for source in self.dictSource.keys(): # parcours des sources
- if len(self.dictSource[source]['milieux']) > 0: # on continue si au moins un groupe de maillage, i.e., milieux est associé à cette source
- if self.dictSource[source].has_key('STRANDED_INDUCTOR'): # inducteur bobiné
- inducteur=ET.SubElement(TermeSourceElectrique, "inducteur")
- listeMilieux=ET.SubElement(inducteur, "listeMilieux") # création de la liste des milieux
- idListeMilieux = [] # indices des milieux concernés
- for milieu in self.dictSource[source]['milieux']: # construction de la liste des milieux
- idListeMilieux.append(self.dictGroupes[milieu]['idMilieu'])
- listeMilieux.text = "%s" % ','.join(map(str,idListeMilieux))
- if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="CURRENT": # source de type courant imposé
- couplageTension=ET.SubElement(inducteur, "couplageTension")
- couplageTension.text = "false"
- courant=ET.SubElement(inducteur, "courant")
- if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
- courant.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
- if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
- amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
- frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
- phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
- courant.text="%g, %g, %g" % (amplitude, frequence, phase)
- courant.set('forme', 'sinus') # attribut forme="sinus"
- if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="VOLTAGE": # source de type tension imposée
- couplageTension=ET.SubElement(inducteur, "couplageTension")
- couplageTension.text = "true"
- tension=ET.SubElement(inducteur, "tension")
- if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
- tension.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
- if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
- amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
- frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
- phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
- tension.text="%g, %g, %g" % (amplitude, frequence, phase)
- tension.set('forme', 'sinus') # attribut forme="sinus"
- if self.dictSource[source]["STRANDED_INDUCTOR"].has_key('Resistance'):
- resistance=ET.SubElement(inducteur, "resistance")
- resistance.text="%g" %(self.dictSource[source]["STRANDED_INDUCTOR"]['Resistance'])
-
- #definir Terme Source Magnetique
- #definirTermeSourceMagnetique=ET.SubElement(root, "definirTermeSourceMagnetique")
- #nombreTermeSourceMagnetique=ET.SubElement(definirTermeSourceMagnetique, "nombreTermeSourceMagnetique")
- #nombreTermeSourceMagnetique.text="0"
-
- #definir Aimants
- #definirAimants=ET.SubElement(root, "definirAimants")
- #nombreAimants=ET.SubElement(definirAimants, "nombreAimants")
- #nombreAimants.text="0"
-
- #Bloc <Mouvements>...</Mouvements>
- i = 0
- Mouvements=ET.SubElement(root, "Mouvements")
- for nom in self.dictMouvement['ordre']: # parcours de la liste des noms de mouvement définis, dans l'ordre
- i = i+1
- mouvement = ET.SubElement(Mouvements, "mouvement") # création de ce mouvement
- mouvement.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
- mouvement.set("name", nom ) # ajout de l'attribut name, inutilisé
- milieuGlissement = ET.SubElement(mouvement, "milieuGlissement")
- nomMilieuGlissement = self.dictMouvement[nom]['valeurs']['Milieu_glissement'].nom # concept stocké -> nom du concept
- milieuGlissement.text="%i" % (self.dictGroupes[nomMilieuGlissement]['idMilieu'], ) # numéro du milieu défini par son nom, selon tableaux remplis précédemment
- surfaceGlissement = ET.SubElement(mouvement, "surfaceGlissement")
- surfaceGlissement.text= self.dictMouvement[nom]['valeurs']['Surface_glissement'].nom # concept stocké -> nom du concept
- deltaMaillage = ET.SubElement(mouvement, "deltaMaillage")
- deltaMaillage.text="%g" % (self.dictMouvement[nom]['valeurs']['Delta_maillage'], )
- nbPermutPas = ET.SubElement(mouvement, "nbPermutPas")
- nbPermutPas.text="%i" % (self.dictMouvement[nom]['valeurs']['Nombre_pas_permutation'], )
- axeRotation = ET.SubElement(mouvement, "axeRotation")
- axeRotation.text= self.dictMouvement[nom]['valeurs']['Axe_rotation']
-
- #definir Force Couple
- #definirForceCouple=ET.SubElement(root, "definirForceCouple")
- #nombreForceCouple=ET.SubElement(definirForceCouple, "nombreForceCouple")
- #nombreForceCouple.text="0"
-
- #bloc <SpiresExploratrices></SpiresExploratrices>
- i = 0 # compteur de spires
- spiresExploratrices = False # pas de spires exploratrices a priori
- for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
- if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
- spiresExploratrices = True
- if spiresExploratrices: # on a trouvé au moins une spire exploratrice
- SpiresExploratrices=ET.SubElement(root, "SpiresExploratrices") # création du bloc XML adéquat
- for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
- if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
- spire = ET.SubElement(SpiresExploratrices, "spireExploratrice") # création du bloc XML pour cette spire
- spire.text = nom # le nom du groupe de noeud est directement écrit
- i = i+1 # incrément du numéro de spire
- spire.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
- spire.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
-
- #bloc <PotentielsFlottants></PotentielsFlottants>
- i = 0 # compteur de potentiels flottants
- potentielsFlottants = False # pas de potentiel flottant a priori
- for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
- if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
- potentielsFlottants = True
- if potentielsFlottants: # on a trouvé au moins un potentiel flottant
- PotentielsFlottants=ET.SubElement(root, "PotentielsFlottants") # création du bloc XML adéquat
- for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
- if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
- potentielFlottant = ET.SubElement(PotentielsFlottants, "potentielFlottant") # création du bloc XML pour ce potentiel flottant
- potentielFlottant.text = nom # le nom du groupe de noeud est directement écrit
- i = i+1 # incrément du numéro de spire
- potentielFlottant.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
- potentielFlottant.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
-
-
- #Definir Post traitement
- postraitement=ET.SubElement(root, "postraitement")
- # Ecriture des cartes de champ
- carteChamp=ET.SubElement(postraitement, "carteChamp")
- if type(self.carteChamp)==float:
- carteChamp.text="%s" %(self.carteChamp)
- else:
- carteChamp.text="%s" % ','.join(map(str,self.carteChamp))
- # Ecriture des cartes de courants induits
- carteCourantInduit=ET.SubElement(postraitement, "carteCourantInduit")
- if type(self.carteCourantInduit)==float:
- carteCourantInduit.text="%s" %(self.carteCourantInduit)
- else:
- carteCourantInduit.text="%s" % ','.join(map(str,self.carteCourantInduit))
- # Ecriture des cartes de force
- carteForce=ET.SubElement(postraitement, "carteForce")
- if type(self.carteForce)==float:
- carteForce.text="%s" %(self.carteForce)
- else:
- carteForce.text="%s" % ','.join(map(str,self.carteForce))
- # Sortie des grandeurs globales, enregistrées dans self.post_global
- # liste de correspondance entre la valeur du catalogue et le nom de la balise XML
- # sous forme ordonnée (nomXML, valeur catalogue)
- correspondance_global = (('energie', "Energie"),\
- ('perteJoule', "Pertes Joules"),\
- ('fluxInducteur', "Flux par inducteur"),\
- ('courantInducteur', "Courants par inducteur"),\
- ('tensionInducteur', "Tensions par inducteur"), \
- ('forceCouple', "Force et couple"),\
- ('fluxSpire', "Flux par spire exploratrice"),\
- ('fluxGroupe', "Flux par groupe"),\
- ('ddpElect', "Tensions electriques"),\
- ('ddpMagn', "DDP magnetiques"), \
- ('fluxMagn', "Flux magnetiques"),\
- ('fluxJinduitTotal', "Flux J induit"),\
- ('potFlottant', "Potentiel flottant"))
- # Sortie des grandeurs demandées seulement (true)
- for table in correspondance_global:
- if table[1] in self.post_global:
- post_global_item=ET.SubElement(postraitement, table[0])
- post_global_item.text = "true"
-# # Sortie de toutes les grandeurs possibles, avec la valeur true pour celles demandées et false sinon
-# for table in correspondance_global:
-# post_global_item=ET.SubElement(postraitement, table[0])
-# if table[1] in self.post_global:
-# post_global_item.text = "true"
-# else:
-# post_global_item.text = "false"
-
- self.indent(root) # indentations et retours à la ligne, à l'aide d'une fonction maison, car xml.etree.ElementTree ne sait pas faire et le module lxml n'est pas disponible dans Salomé
-
- tree = ET.ElementTree(root)
-
- tree.write(fileXML, encoding="UTF-8")
-
- # print "le dico complet=%s" %(self.dictGroupes)
-
- if self.debug:
- print "ecriture du fichier d'execution (SH)"
- RepCarmel=os.path.join(repertory,"lancer.sh")
- f = open( RepCarmel, 'wb')
- self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
- self.texteCarmel3D_SH+='./carmel << FIN\n'
- correspondance_resolution = {"(T-)Omega seulement":"1\n","A(-Phi) seulement":"2\n", "(T-)Omega puis A(-Phi)":"1\n2\n", "A(-Phi) puis (T-)Omega":"2\n1\n"}
- self.texteCarmel3D_SH+= correspondance_resolution[self.formulation]
- self.texteCarmel3D_SH+='0\nFIN\n'
- f.write(self.texteCarmel3D_SH)
- f.close()
-
-
-#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
-#----------------------------------------------------------------------------------------
-
- def generMCSIMP(self,obj) :
- """recuperation de l objet MCSIMP"""
- if self.debug:
- print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
- s=PythonGenerator.generMCSIMP(self,obj)
- try:
- self.dicoCourant[obj.nom]=obj.valeurFormatee
- except:
- print "Oubli des messages texte homo='information'"
- return s
-
-
-#----------------------------------------------------------------------------------------
- def generMCFACT(self,obj) :
- """recuperation de l objet MCFACT"""
- dico={}
- self.dicoMCFACTCourant=dico
- self.dicoCourant=self.dicoMCFACTCourant
- s=PythonGenerator.generMCFACT(self,obj)
- self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
- self.dicoMCFACTCourant=None
- self.dicoCourant=self.dicoEtapeCourant
- return s
-
-
-#----------------------------------------------------------------------------------------
- def generPROC_ETAPE(self,obj):
- """analyse des PROC du catalogue ( VERSION )"""
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- s=PythonGenerator.generPROC_ETAPE(self,obj)
- obj.valeur=self.dicoEtapeCourant
-
- if self.debug:
- print "PROC_ETAPE %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
- s=PythonGenerator.generPROC_ETAPE(self,obj)
- if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
- if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
- if obj.nom=="SYMETRIE" : self.generBLOC_SYMETRIE(obj)
- if obj.nom=="POST_TRAITEMENT" : self.generPOST_TRAITEMENT(obj)
- return s
-
-
-
-#----------------------------------------------------------------------------------------
- def generETAPE(self,obj):
- """analyse des OPER du catalogue"""
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- s=PythonGenerator.generETAPE(self,obj)
- obj.valeur=self.dicoEtapeCourant
- if self.debug:
- print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
- if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
- if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
- if obj.nom=="SOURCE" : self.generSOURCE(obj)
- if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
- if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
- if obj.nom=="MOUVEMENT" : self.generMOUVEMENT(obj)
- s=PythonGenerator.generETAPE(self,obj)
- return s
-
-#----------------------------------------------------------------------------------------
- def generMACRO_ETAPE(self,obj):
- """Utilisé par INCLUDE"""
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- import generator
- monGenerateur=generator.plugins[nomPlugin]()
- jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
- if self.debug:
- print "jdc_aux_texte : %s" % jdc_aux_texte
-
- # sauvegarde de tous les matériaux trouvés dans les bibliothèques INCLUDE
- for cle in monGenerateur.dictMaterial:
- self.dictMaterial[cle] = monGenerateur.dictMaterial[cle]
- # sauvegarde de toutes les sources trouvées dans les bibliothèques INCLUDE
- for cle in monGenerateur.dictSource:
- self.dictSource[cle] = monGenerateur.dictSource[cle]
-
- print "________FIN MACRO______________________________________"
- s=PythonGenerator.generMACRO_ETAPE(self,obj)
- return s
-
-#----------------------------------------------------------------------------------------
-#----------------------------------------------------------------------------------------
- def generMESHGROUP(self,obj):
- """preparation de la ligne NAME referencant le groupe de mailles
- associe le groupe de mailles au materiau ou a la source utilisateur
- on sauvegarde aussi les noms des groupes de maillage
- """
- try:
- nomGroupe = obj.getSdname() # nom du groupe de maillage, i.e. nom du concept
- print "liste des noms sans prefixes %s" %(nomGroupe)
-
- # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
- # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
- #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
-
- # on utilise le fait que obj.valeur est un dictionnaire
- self.dictGroupes[nomGroupe] = {}
- if self.debug:
- print "obj.valeur.keys()= %s" % obj.valeur.keys()
- #if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
- # raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupe)
- # association a un materiau
- if 'MATERIAL' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- # self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
- # association a une source
- if 'SOURCE' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- # self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
- # erreur ni materiau ni source associee
- if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['STRANDED_INDUCTOR_GEOMETRY'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- # self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
- if 'CONDITION_LIMITE' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['CONDITION_LIMITE'] = obj.valeur['CONDITION_LIMITE']
- # self.dictGroupes['ordreConditionJdC'].append(nomGroupe)
- if 'Domaine' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
- # self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
- texte=""
- texte+="%s"%(obj.valeur['Domaine'])
- print"le texte=%s" %(texte)
- self.dictDomaine[obj.getSdname()]=texte
- print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
- if 'Potentiel_Flottant' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['Potentiel_Flottant'] = True
- if 'Spire_Exploratrice' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['Spire_Exploratrice'] = True
-
-# else:
-# raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
- if self.debug:
- print "self.dictGroupes= %s" % repr(self.dictGroupes)
- except ValueError, err:
- raise ValueError, str(err)
-
- def generMACRO_GROUPE(self, obj):
- """preparation de la ligne NAME referencant le groupe de mailles
- associe le groupe de mailles au materiau ou a la source utilisateur
- on sauvegarde aussi les noms des macros groupes
- """
- try:
- nomMacroGroupe = obj.getSdname() # nom du macro groupe
- print "liste des noms sans prefixes %s" %(nomMacroGroupe)
- self.dictMacroGroupes[nomMacroGroupe] = obj.valeur # sauvegarde des propriétés du macro-groupe
-
- if self.debug:
- print "obj.valeur.keys()= %s" % obj.valeur.keys()
- # association a une source
- if 'LISTE_MESHGROUP' in obj.valeur.keys(): # test de liste définie dans la macro-groupe, sinon erreur
- listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- self.dictMacroGroupes[nomMacroGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
- groupe = groupe.replace("'", "") # suppression des guillement simples
- groupe = groupe.replace('"', "") # suppression des guillement doubles
- self.dictMacroGroupes[nomMacroGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
- else:
- raise ValueError, nomMacroGroupe + tr(" : ce MACRO_GROUPE doit contenir une liste de groupes LISTE_MESHGROUP.")
-
- for nomGroupe in self.dictMacroGroupes[nomMacroGroupe]['LISTE']: # liste des groupes MESHGROUP de ce macro-groupe. On leur associe les propriétés du MACRO_GROUPE
- for propriete in ('SOURCE', 'MATERIAL', 'STRANDED_INDUCTOR_GEOMETRY'): # liste des propriétés automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
- if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
- if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete].nom: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
- print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP %s associé à ce macro-groupe." % \
- ( propriete, obj.valeur[propriete].nom, nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
- raise ValueError, propriete + ',' + obj.valeur[propriete].nom + ',' + nomMacroGroupe + ',' + self.dictGroupes[nomGroupe][propriete] + ',' + nomGroupe\
- + tr(" : conflit entre la propriete (#1:#2) du MACRO_GROUPE (de nom #3) et celle (#4) du MESHGROUP (#5) associe a ce macro-groupe.")
- else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
- self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete].nom # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
- for propriete in ('CONDITION_LIMITE', ): # liste des propriétés définies à l'avance automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
- if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
- if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete]: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
- print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP %s associé à ce macro-groupe." % \
- ( propriete, obj.valeur[propriete], nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
- raise ValueError, propriete + ',' + obj.valeur[propriete].nom + ',' + nomMacroGroupe + ',' + self.dictGroupes[nomGroupe][propriete] + ',' + nomGroupe\
- + tr(" : conflit entre la propriete (#1:#2) du MACRO_GROUPE (de nom #3) et celle (#4) du MESHGROUP (#5) associe a ce macro-groupe.")
- else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
- self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete] # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
- except ValueError, err:
- raise ValueError, str(err)
-
-
- def generSOLVEUR(self, obj):
- if self.debug:
- print "generation solveur obj.valeur = %s" % obj.valeur
- try :
- self.typeSolveur = obj.valeur['Type']
- if self.typeSolveur == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
- if self.typeSolveur == "Solveur_non_lineaire" :
- self.generSOLVEUR_LINEAIRE(obj)
- self.generSOLVEUR_NON_LINEAIRE(obj)
- except ValueError, err:
- raise ValueError, str(err)
-
- def generSOLVEUR_LINEAIRE(self, obj):
- if self.debug:
- print "generation material obj.valeur = %s" % obj.valeur
- try :
- nature = obj.valeur['Methode_lineaire']
- if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
- if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
- except ValueError, err:
- raise ValueError, str(err)
-
- def generMETHODE_ITERATIVE_BICGCR(self, obj):
- if self.debug:
- print "generation methode iterative BICGCR obj.valeur = %s" % obj.valeur
- self.kEpsilonGCP = obj.valeur["Precision"]
- self.precond=obj.valeur["Preconditionneur"]
- self.nbIterationMax=obj.valeur["Nombre_iterations_max"]
-
-
- def generMETHODE_DIRECTE_MUMPS(self, obj):
- texte=""
- if self.debug:
- print "_____________directe_____________"
-
- def generSOLVEUR_NON_LINEAIRE(self, obj):
- if self.debug:
- print "generation solveur_non_lineaire obj.valeur = %s" % obj.valeur
- correspondance_methodeNonLineaire = {"Methode de Newton":2,"Methode de substitution":1} # correspondance sur la méthode non-linéaire entre le catalogue et le XML
- self.methodeNonLineaire = correspondance_methodeNonLineaire[obj.valeur["Methode_non_lineaire"]]
- self.kEpsilonNonLinearite=obj.valeur["PrecisionNonLineaire"]
- self.kCoefficientRelaxation=obj.valeur["Coefficient_de_Relaxation"]
-
- def generMATERIAL(self,obj):
- """preparation du bloc correspondant a un materiau du fichier PHYS"""
- texte=""
- if self.debug:
- print "generation material obj.valeur = %s" % obj.valeur
- try :
- nomMaterial = obj.getSdname()
- self.dictMaterial[nomMaterial]=obj.valeur
- print"self.dictMaterial=%s" %(self.dictMaterial)
- except ValueError, err:
- raise ValueError, str(err)
-#-------------------------------------------------------------------
-
- def generSOURCE(self,obj):
- """preparation du bloc correspondant a une source du fichier PHYS"""
- if self.debug:
- print "generation source obj valeur = %s" % obj.valeur
- texte=""
- try :
- nomSource = obj.getSdname()
- self.dictSource[nomSource]=obj.valeur # dictionnaire
- self.dictSource[nomSource]['milieux'] = [] # liste ordonnée des groupes associés à cette source
- print"mon dico des sources=%s" %(self.dictSource)
- except ValueError, err:
- raise ValueError, str(err)
-
-#---------------------------------------------------------------------------------------
-# traitement fichier PHYS
-#---------------------------------------------------------------------------------------
- def generBLOC_VERSION(self,obj) :
- # constitution du bloc VERSION du fichier PHYS
- # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
- # dans le du catalogue
- version=obj.addEntite('VERSION',pos=None)
- self.generPROC_ETAPE(obj.etapes[0])
- self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
- for cle in obj.etapes[0].valeur :
- self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
- self.texteCarmel3D+="]\n"
- # destruction de l entite creee
- obj.suppEntite(version)
- #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
- #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
-
-
- def generBLOC_PARAMETERS(self,obj):
- if self.debug:
- print "generation parameters obj.valeur = %s" % obj.valeur
-
- self.identification = obj.valeur["Identification_du_Modele"]
- self.fichierMaillage = obj.valeur["Fichier_maillage"]
- self.echelleMaillage = obj.valeur["Echelle_du_maillage"]
-
- self.kEpsilonDistance=obj.valeur["kEpsilonDistance"]
- self.kdistanceRef=obj.valeur["kdistanceRef"]
- self.jauge=obj.valeur["Jauge"]
- self.NBoucleTemps=obj.valeur["Nb_pas_de_temps"]
- self.dt=obj.valeur["Pas_de_temps"]
-
- self.repertory=obj.valeur["RepCarmel"]
- self.fcarmel=obj.valeur["Resoudre_probleme"]
- self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
- self.formulation=obj.valeur["Formulation"]
-
- def generBLOC_SYMETRIE(self, obj):
- if self.debug:
- print "generation de la symetrie obj.valeur = %s" % obj.valeur
-
- try:
- self.listSymetrie.append(obj.valeur)
- print"ma liste symetrie =%s" %(self.listSymetrie)
- except ValueError, err:
- raise ValueError, str(err)
-#----------------------------------------------------------------------------------------
-
- def generMOUVEMENT(self, obj):
- if self.debug:
- print "generation du mouvement obj.valeur = %s" % obj.valeur
-
- try:
- nom = obj.getSdname()
- self.nombreMouvements = self.nombreMouvements+1
- self.dictMouvement[nom] = {'ordre': self.nombreMouvements, 'valeurs': obj.valeur}
- self.dictMouvement['ordre'].append(nom)
- if self.debug:
- print "self.dictMouvement =%s" %(self.dictMouvement)
- print "self.nombreMouvements =%i" %(self.nombreMouvements)
- except ValueError, err:
- raise valueError, str(err)
-#----------------------------------------------------------------------------------------
- def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
- """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
- if self.debug:
- print "generation strand obj valeur = %s" % obj.valeur
- try :
- nomStrand = obj.getSdname()
- self.dictStrand[nomStrand]=obj.valeur
- print"mon dico des stranded inductor geometry=%s" %(self.dictStrand)
-
- except ValueError, err:
- raise ValueError, str(err)
-
- def generPOST_TRAITEMENT(self, obj):
- if self.debug:
- print "generation post traitement obj.valeur = %s" % obj.valeur
- self.carteChamp=obj.valeur["Cartes_des_champs"]
- self.carteCourantInduit=obj.valeur["Cartes_des_courants_induits"]
- self.carteForce=obj.valeur["Cartes_des_forces"]
- if obj.valeur.has_key('GLOBAL'):
- self.post_global = obj.valeur['GLOBAL']
- # sauvegarde de la liste au format correct, en supprimant les guillemets simples et doubles extra générés par Eficas
- # car Eficas génère une liste ["'Energie'","'Flux par inducteur'","'Force et couple'"] enrichie
- # à partir de l'instruction .comm correctement formatée : GLOBAL=('Energie','Flux par inducteur','Force et couple',)
- for i in range(len(self.post_global)):
- self.post_global[i] = self.post_global[i].replace("'", "") # suppression des guillement simples
- self.post_global[i] = self.post_global[i].replace('"', "") # suppression des guillement doubles
-
-#-------------------------------------
-# Methodes utilitaires
-# ------------------------------------
- def formateCOMPLEX(self,nbC):
- """prise en compte des differentes formes de description d un nombre complexe
- 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
- """
- if self.debug:
- print "formatage"
- print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
- nbformate =""
- if isinstance(nbC,(tuple,list)):
- if nbC[0] == "'RI'" :
- nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
- if nbC[0] == "'MP'" :
- nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
- else:
- nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
- if self.debug:
- print "nbformate : %s" % nbformate
- return nbformate
-
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-import traceback
-import types,string,re,os
-from Extensions.i18n import tr
-from generator_python import PythonGenerator
-import Accas
-
-debutTextePhys ="[VERSION\n NUM 1\n FILETYPE PHYS\n]\n"
-debutTextePhys+="[MATERIALS\n"
-texteConductor =" [CONDUCTIVITY\n LAW LINEAR\n"
-texteConductor+=" HOMOGENEOUS TRUE\n"
-texteConductor+=" ISOTROPIC TRUE\n"
-texteConducto2 =" 0.0000000000000000E+00\n ]\n"
-texteConducto2+=" [PERMEABILITY\n LAW LINEAR\n"
-texteConducto2+=" HOMOGENEOUS TRUE\n"
-texteConducto2+=" ISOTROPIC TRUE\n"
-texteNoCond =" [PERMITTIVITY\n LAW LINEAR\n"
-texteNoCond+=" HOMOGENEOUS TRUE\n ISOTROPIC TRUE\n"
-texteNoCond+=" VALUE COMPLEX 0.1000000000000000E+01 0.0000000000000000E+00\n"
-texteNoCond+=" ]\n [PERMEABILITY\n LAW LINEAR\n"
-texteNoCond+=" HOMOGENEOUS TRUE\n ISOTROPIC TRUE\n"
-
-debutTexteParam ="[VERSION\n NUM 1\n FILETYPE PARAM\n]\n"
-debutTexteParam+="[PROBLEM\n NAME HARMONIC\n]\n"
-debutTexteParam+="[CAR_FILES\n NAME "
-
-debutTexteZs0 =" [ZSURFACIC\n NAME "
-debutTexteZs ="\n [CONDUCTIVITY\n"
-debutTexteZs+=" LAW LINEAR\n"
-debutTexteZs+=" HOMOGENEOUS TRUE\n"
-debutTexteZs+=" ISOTROPIC TRUE\n"
-debutTexteZs+=" VALUE COMPLEX "
-texteZs2 =" 0.0000000000000000E+00\n ]\n"
-texteZs2 +=" [PERMEABILITY\n LAW LINEAR\n"
-texteZs2 +=" HOMOGENEOUS TRUE\n"
-texteZs2 +=" ISOTROPIC TRUE\n VALUE COMPLEX "
-finTexteZs =" 0.0000000000000000E+00\n ]\n ]\n"
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'CARMELCND',
- # La factory pour creer une instance du plugin
- 'factory' : CARMELCNDGenerator,
- }
-
-
-class CARMELCNDGenerator(PythonGenerator):
- """
- 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',)
-
-#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None):
-
- self.initDico()
-
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
- self.racine=obj
- return self.text
-
-
-#----------------------------------------------------------------------------------------
-# initialisations
-#----------------------------------------------------------------------------------------
-
- def initDico(self) :
-
- self.dictMCVal={}
-
-#----------------------------------------------------------------------------------------
-# ecriture
-#----------------------------------------------------------------------------------------
-
- def writeDefault(self,file) :
-#file ne sert pas
-
- self.texteIngendof=""
- self.texteParam=debutTexteParam
- self.chercheFichier()
- self.traiteSourceVCut()
-
- fn=self.fnBase
- fileIngendofDeb = fn[:fn.rfind(".")] + '.ingendof'
- fileIngendof = os.path.join(self.sauveDirectory,fileIngendofDeb)
- f = open( str(fileIngendof), 'wb')
- f.write( self.texteIngendof )
- f.close()
-
- self.textePhys=debutTextePhys
- self.traiteMateriaux()
- filePhysDeb = fn[:fn.rfind(".")] + '.phys'
- filePhys = os.path.join(self.sauveDirectory,filePhysDeb)
- f = open( str(filePhys), 'wb')
- f.write( self.textePhys )
- f.close()
-
- fileParamDeb = fn[:fn.rfind(".")] + '.param'
- fileParam = os.path.join(self.sauveDirectory,fileParamDeb)
- self.traiteParam()
- f = open( str(fileParam), 'wb')
- f.write( self.texteParam )
- f.close()
-
- self.texteCMD="[ \n GLOBAL \n] \n[ \nVISU \n"+self.fnBase.split(".med")[0]+"\nMED \nELEMENT \n] "
- fileCMDDeb = fn[:fn.rfind(".")] + '.cmd'
- fileCMD =os.path.join(self.sauveDirectory,fileCMDDeb)
- f = open( str(fileCMD), 'wb')
- f.write( self.texteCMD )
- f.close()
-
- nomBaseFichier=os.path.basename(fileParam).split(".med")[0]
-
- self.texteInfcarmel=nomBaseFichier
- fileInfcarmelDeb = fn[:fn.rfind(".")] + '.infcarmel'
- fileInfcarmel=os.path.join(self.sauveDirectory,fileInfcarmelDeb)
- f = open( str(fileInfcarmel), 'wb')
- f.write( self.texteInfcarmel )
- f.close()
-
- self.texteInpostpro=nomBaseFichier+"\n"+nomBaseFichier.split(".param")[0]+'.xmat\n'+nomBaseFichier.split(".param")[0]+'.cmd'
- fileInpostproDeb = fn[:fn.rfind(".")] + '.inpostprocess'
- fileInpostpro = os.path.join(self.sauveDirectory,fileInpostproDeb)
- f = open( str(fileInpostpro), 'wb')
- f.write( self.texteInpostpro )
- f.close()
-
-#----------------------------------------------------------------------------------------
-# analyse des commentaires pour trouver le nom du fichier
-#----------------------------------------------------------------------------------------
-
- def chercheFichier(self) :
- nomFichier="inconnu"
- for e in self.racine.etapes:
- if isinstance(e,Accas.COMMENTAIRE):
- print 'ùmasdkfh=',e.valeur[0:17]
- if e.valeur[0:17]=="Cree - fichier : ":
- debut=e.valeur[17:]
- liste=debut.split(" - ")
- nomFichier=liste[0]
- #print 'nom=',nomFichier
- #print 'e.va=',e.valeur.split(" ")[-1]
- #print 'liste=',liste
- nomDomaine=e.valeur.split(" ")[-1]
- break
- self.sauveDirectory=os.path.dirname(nomFichier)
- self.fnBase=os.path.basename(nomFichier)
- self.texteIngendof =os.path.basename(nomFichier)+"\n"
- self.texteParam += os.path.basename(nomFichier).split(".med")[0]+".car\n]\n"
- self.texteParam +="[PHYS_FILES\n NAME "+os.path.basename(nomFichier).split(".med")[0]+".phys\n]\n"
-
-#----------------------------------------------------------------------------------------
-# analyse du dictionnaire pour trouver les sources et les VCut et les ZS
-#----------------------------------------------------------------------------------------
-
- def traiteSourceVCut(self) :
- listeSource=[]
- listeVCut=[]
- self.listeZS=[]
- self.texteSourcePhys="[SOURCES\n"
- for k in self.dictMCVal.keys():
- if k.find ("______SOURCE__") > -1 :
- noms=k.split("_____")
- if noms[0] not in listeSource : listeSource.append(noms[0])
- if k.find ("______VCUT__") > -1 :
- noms=k.split("_____")
- if noms[0] not in listeVCut : listeVCut.append(noms[0])
- if k.find ("______ZS") > -1 :
- noms=k.split("_____")
- if noms[0] not in self.listeZS : self.listeZS.append(noms[0])
- listeSource.sort()
- for source in listeSource:
- debutKey=source+"______SOURCE__"
- texteSource=self.dictMCVal[debutKey+"EnveloppeConnexeInducteur"]+"\n"
- texteSource+="2\n"
- for val in self.dictMCVal[debutKey+"VecteurDirecteur"] :
- texteSource+=str(val)+" "
- texteSource+="\n"
- for val in self.dictMCVal[debutKey+"Centre"] :
- texteSource+=str(val)+" "
- texteSource+="\n"
- texteSource+=str(self.dictMCVal[debutKey+"SectionBobine"])+"\n"
- self.texteIngendof+=texteSource
- self.texteSourcePhys+=" [STRANDED_INDUCTOR\n"
- self.texteSourcePhys+=" NAME "+source+"\n"
- self.texteSourcePhys+=" NTURNS "+str(self.dictMCVal[debutKey+"NbdeTours"])+"\n"
- self.texteSourcePhys+=" CURJ POLAR "+str(self.dictMCVal[debutKey+"Amplitude"])
- self.texteSourcePhys+=" 0.0000000000000000E+00\n ]\n"
-
- self.texteSourcePhys+="]\n"
- for vcut in listeVCut:
- self.texteIngendof+="1\n"
- debutKey=vcut+"______VCUT__"
- if self.dictMCVal[debutKey+"Orientation"] == "Oppose" :self.texteIngendof+="0\n"
- else : self.texteIngendof+="1\n"
- if self.dictMCVal["__PARAMETRES__TypedeFormule"]=="APHI" :self.texteIngendof+="1\n"
- else : self.texteIngendof+="2\n"
-
-
-
-#----------------------------------------------------------------------------------------
- def traiteMateriaux(self) :
-#----------------------------------------------------------------------------------------
- listeCond=[]
- listeNoCond=[]
- for k in self.dictMCVal.keys():
- if k.find ("______CONDUCTEUR") > -1 :
- noms=k.split("_____")
- if noms[0] not in listeCond : listeCond.append(noms[0])
- if k.find ("______NOCOND") > -1 :
- noms=k.split("_____")
- if noms[0] not in listeNoCond : listeNoCond.append(noms[0])
-
- for c in listeCond:
- self.textePhys +=" [CONDUCTOR\n"
- self.textePhys +=" NAME "+c+"\n"
- self.textePhys +=texteConductor
- self.textePhys+=" VALUE COMPLEX "
- self.textePhys+=str(self.dictMCVal[c+"______CONDUCTEUR__Conductivite"])
- self.textePhys+=texteConducto2
- self.textePhys+=" VALUE COMPLEX "
- self.textePhys+=str(self.dictMCVal[c+"______CONDUCTEUR__PermeabiliteRelative"])
- self.textePhys+=" 0.0000000000000000E+00\n ]\n ]\n"
-
- for c in listeNoCond:
- self.textePhys+=" [DIELECTRIC\n"
- self.textePhys +=" NAME "+c+"\n"
- self.textePhys += texteNoCond
- self.textePhys+=" VALUE COMPLEX "
- self.textePhys+=str(self.dictMCVal[c+"______NOCOND__PermeabiliteRelative"])
- self.textePhys+=" 0.0000000000000000E+00\n ]\n ]\n"
-
- for zs in self.listeZS:
- self.textePhys+=debutTexteZs0+zs
- self.textePhys+=debutTexteZs
- self.textePhys+=str(self.dictMCVal[zs+"______ZS__Conductivite"])
- self.textePhys+=texteZs2
- self.textePhys+=str(self.dictMCVal[zs+"______ZS__PermeabiliteRelative"])
- self.textePhys+=finTexteZs
-
- self.textePhys+="]\n"
- self.textePhys+=self.texteSourcePhys
-
-#----------------------------------------------------------------------------------------
-# Creation du fichier Param
-#----------------------------------------------------------------------------------------
- def traiteParam(self):
- self.texteParam +="[FREQUENCY\n SINGLE "+str(self.dictMCVal["__PARAMETRES__Frequence"])+"\n]\n"
- self.texteParam +="[SOLVER\n NAME BICGCR\n"
- self.texteParam +=" [ITERATIVE_PARAM\n"
- self.texteParam +=" NITERMAX "+str(self.dictMCVal["__PARAMETRES__Nb_Max_Iterations"])+"\n"
- self.texteParam +=" EPSILON "+ str(self.dictMCVal["__PARAMETRES__Erreur_Max"])+"\n ]\n]"
-
-
-#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
-#----------------------------------------------------------------------------------------
-
- def generMCSIMP(self,obj) :
- """recuperation de l objet MCSIMP"""
- s=PythonGenerator.generMCSIMP(self,obj)
- if hasattr(obj.etape,'sdnom'): clef=obj.etape.sdnom+"____"
- else: clef=""
- for i in obj.getGenealogie() :
- clef=clef+"__"+i
- self.dictMCVal[clef]=obj.valeur
-
- return s
-
- def get_repExeCarmel(self) :
- return self.dictMCVal["__PARAMETRES__RepCarmel"]
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-import traceback
-import types,string,re,os
-from Extensions.i18n import tr
-from generator_python import PythonGenerator
-import Accas
-
-
-
-
-#keys = ['Carmel3D_StudyDirectory','Syrthes_StudyDirectory']
-
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'CARMELCS',
- # La factory pour creer une instance du plugin
- 'factory' : CARMELCSGenerator,
- }
-
-
-class CARMELCSGenerator(PythonGenerator):
- """
- 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',)
-
-#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None):
-
- self.initDico()
-
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
- self.racine=obj
- return self.text
-
- def generxml(self,obj,format='brut',config=None):
-
- texte = self.gener(obj,format,config)
-# print 'self.dictMCVal = ',self.dictMCVal
- textePourRun = self.update_XMLYacsSchemaForRunning()
- return textePourRun
-
-#----------------------------------------------------------------------------------------
-# initialisations
-#----------------------------------------------------------------------------------------
-
- def initDico(self) :
-
- self.texteDico = ""
- self.dictMCVal={}
- self.dicoCS={}
- self.debutKey = '__PARAM_CS__'
-
-#----------------------------------------------------------------------------------------
-# ecriture
-#----------------------------------------------------------------------------------------
-
- def getdico(self) :
- #print 'getdico : self.dictMCVal.keys() = ',self.dictMCVal.keys()
- for k in self.dictMCVal.keys():
- if k.find (self.debutKey) > -1 :
- a,kproperty=k.split(self.debutKey)
- self.dicoCS[kproperty] = self.dictMCVal[k]
- #print "self.dicoCS = ",self.dicoCS
- return self.dicoCS
-
- def getXMLYacsSchemaFileTemplate(self) :
-
- for k in self.dictMCVal.keys():
- if k.find (self.debutKey) > -1 :
- a,kproperty=k.split(self.debutKey)
- if kproperty == 'XMLYacsFile' :
- return self.dictMCVal[k]
-
- def getXMLYacsSchemaFileRun(self) :
- xmlYacsSchemaFilePath = self.getXMLYacsSchemaFileTemplate()
- filename = os.path.basename(xmlYacsSchemaFilePath)
- dirname = os.path.dirname(xmlYacsSchemaFilePath)
- prefix = '_run_'
- runxmlfile = os.path.join(dirname,prefix+filename)
- return xmlYacsSchemaFilePath,runxmlfile
-
- def update_XMLYacsSchemaForRunning(self) :
- """
- Creation du fichier _run_XXX.xml, a partir des elements donnes par l'utilisateur dans l'interface :
- Carmel3D_StudyDirectory : YYY (path du repertoire de l'etude CARMEL3D de couplage)
- Syrthes_StudyDirectory : YYY/THERMIQUE (path du repertoire de l'etude SYRTHES de couplage)
- XMLYacsFile : PATH du fichier template du schema yacs d'execution du couplage
- """
- xmlYacsSchemaFilePath,runxmlfile = self.getXMLYacsSchemaFileRun()
- f_xml = open( str(xmlYacsSchemaFilePath), 'r')
- texte_template_xml = f_xml.read()
- f_xml.close()
- dicoCS = self.getdico()
- print "dicoCS = ",dicoCS
- # ajout dans dicoCS des elements pour SYRTHES qui sont deja sous cette forme la dans le fichier xml sinon ca pose pb
- dicoCS['DEB']='%(DEB)s'
- dicoCS['FIN']='%(FIN)s'
- newTexteXml = texte_template_xml%dicoCS
- f = open(runxmlfile,'w')
- f.write(newTexteXml)
- f.close()
- return runxmlfile
-
- def writeDefault(self,fn) :
- fileDico = fn[:fn.rfind(".")] + '.py'
- f = open( str(fileDico), 'wb')
- f.write( self.texteDico )
- f.close()
- runxmlfile = self.update_XMLYacsSchemaForRunning()
-
-#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
-#----------------------------------------------------------------------------------------
-
- def generMCSIMP(self,obj) :
- """recuperation de l objet MCSIMP"""
- s=PythonGenerator.generMCSIMP(self,obj)
- self.texteDico+=obj.nom+ "=" + s[0:-1]+ "\n"
-# print 'generMCSIMP self.texteDico = ',self.texteDico
- if hasattr(obj.etape,'sdnom'): clef=obj.etape.sdnom+"____"
- else: clef=""
- for i in obj.getGenealogie() :
- clef=clef+"__"+i
- self.dictMCVal[clef]=obj.valeur
-
- return s
-
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-from __future__ import absolute_import
-try :
- from builtins import str
-except : pass
-
-texte_debut="int main() \n{ \n init_var();\n"
-texte_debut+=' format="med";\n'
-import traceback
-import types,re,os
-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,
- }
-
-
-class PSENGenerator(DicoImbriqueGenerator):
- """
- 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',)
-
-#----------------------------------------------------------------------------------------
- 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'
-
-
-#----------------------------------------------------------------------------------------
-# 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()
-
-
-
-#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
-#----------------------------------------------------------------------------------------
-
-## def generMCSIMP(self,obj) :
-## """recuperation de l objet MCSIMP"""
-## #print dir(obj)
-## self.dicoMCSIMP[obj.nom]=obj.val
-## self.dicoTemp[obj.nom]=obj.val
-## s=DicoImbriqueGenerator.generMCSIMP(self,obj)
-## return s
-##
-## def generETAPE(self,obj):
-## self.dicoTemp={}
-## s=DicoImbriqueGenerator.generETAPE(self,obj)
-## if obj.nom=="DISTRIBUTION" : self.dicoLois[obj.sd.nom]=self.dicoTemp
-## self.dicoTemp={}
-## return s
-
-
-# si repertoire on change tous les noms de fichier
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-from __future__ import absolute_import
-import types,re,os
-from Extensions.i18n import tr
-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,
- }
-
-
-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
-
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
-
-#----------------------------------------------------------------------------------------
- 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
-
- return self.text
-
-
-
-# si repertoire on change tous les noms de fichier
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- SEP pour EFICAS.
-
-"""
-import traceback
-import types,string,re,os
-
-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' : 'SEP',
- # La factory pour creer une instance du plugin
- 'factory' : SEPGenerator,
- }
-
-
-class SEPGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format py
-
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
-
- def gener(self,obj,format='brut',config=None):
- self.initDico()
- # Cette instruction génère le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
- # Cette instruction génère le contenu du fichier de paramètres python
- self.genereSEP()
- return self.text
-
- def getTubePy(self) :
- return self.texteTubePy
-
- def genereSEP(self) :
- '''
- Prépare le contenu du fichier de paramètres python. Le contenu
- peut ensuite être obtenu au moyen de la fonction getTubePy().
- '''
- #self.__genereSEP_withVariables()
- self.__genereSEP_withDico()
-
- def __genereSEP_withVariables(self) :
- '''
- Les paramètres sont transcrits sous forme de variables nom=valeur.
- '''
- self.texteTubePy="# Parametres generes par Eficas \n"
- for MC in self.dictMCVal.keys():
- ligne = MC +"="+ repr(self.dictMCVal[MC])+'\n'
- self.texteTubePy=self.texteTubePy+ligne
-
- print self.texteTubePy
-
- # __GBO__: Tester self.tube pour aiguiller en fonction du cas (au besoin)
- fichier=os.path.join(os.path.dirname(__file__),"tube.py")
- f=open(fichier,'r')
- for ligne in f.readlines():
- self.texteTubePy=self.texteTubePy+ligne
- f.close
-
- def __genereSEP_withDico(self) :
- """
- Les paramètres sont transcrits sous la forme d'un dictionnaire nom=valeur.
- """
- from Sep import properties
- self.texteTubePy="# -*- coding: utf-8 -*-\n"
- self.texteTubePy+="# ======================================================================================\n"
- self.texteTubePy+="# FICHIER GENERE PAR EFICAS - OUTIL MÉTIER SOUS-EPAISSEUR - "
- self.texteTubePy+="VERSION "+str(properties.version)+" du "+str(properties.date)+"\n"
- self.texteTubePy+="# ======================================================================================\n"
- self.texteTubePy+="\n"
- self.texteTubePy+="# Parametres Utilisateur Eficas \n"
- self.texteTubePy+="parameters={}\n"
-
- for MC in self.dictMCVal.keys():
- ligne = "parameters['"+MC+"']="+ repr(self.dictMCVal[MC])+'\n'
- self.texteTubePy=self.texteTubePy+ligne
-
- # On ajoute des paramètres de configuration pour contrôle de
- # cohérence avec la procédure outil métier
- self.texteTubePy+="# Parametres de Configuration Eficas \n"
- ligne = "parameters['OMVERSION']="+str(properties.version)+"\n"
- self.texteTubePy+=ligne
-
- # __GBO__: Tester self.tube pour aiguiller en fonction du cas (au besoin)
- self.texteTubePy+="\n"
- self.texteTubePy+="# Exécution de la procédure outil métier \n"
- self.texteTubePy+="import os,sys\n"
- self.texteTubePy+="sys.path.insert(0,os.environ['OM_ROOT_DIR'])\n"
- self.texteTubePy+="import om_data\n"
- self.texteTubePy+="om_data.setParameters(parameters)\n"
- self.texteTubePy+="def run():\n"
- self.texteTubePy+=" import om_smeca\n"
- self.texteTubePy+="\n"
- self.texteTubePy+='if __name__ == "__main__":\n'
- self.texteTubePy+=" run()\n"
-
- # For debug only
- print self.texteTubePy
-
-
- def initDico(self) :
- self.tube=0
- self.coude=0
- self.dictMCVal={}
- self.texteTubePy=""
-
- # __GBO__: surcharge de PythonGenerator:
- # voir example generator_cuve2dg.py (genea)
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en texte python
- Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
- """
- clef=""
- for i in obj.getGenealogie() :
- clef=clef+"__"+i
- #self.dictMCVal[obj.nom]=obj.valeur
- self.dictMCVal[clef]=obj.valeur
-
- s=PythonGenerator.generMCSIMP(self,obj)
- return s
-
- # __GBO__: surcharge de PythonGenerator
- def generMACRO_ETAPE(self,obj):
- print obj.nom
- if obj.nom == "S_EP_INTERNE" :
- self.tube=1
- if obj.nom == "M_COUDE" :
- self.coude=1
- s=PythonGenerator.generMACRO_ETAPE(self,obj)
- return s
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-from __future__ import absolute_import
-from __future__ import print_function
-try :
- from builtins import str
-except : pass
-
-import pickle
-texte_debut="#include <Zcracks_base.z7p> \n int main() \n{ \n init_var();\n"
-texte_debut+=' format="med";\n'
-import traceback
-import types,re,os
-from Extensions.i18n import tr
-from .generator_python import PythonGenerator
-#ListeConcatene=('ridge_names','topo_names','geom_names','elsetNames','fasetNames','lisetNames','nsetNames','center','normal','dir')
-ListeConcatene=('ridge_names','topo_names','geom_names','elsetNames','fasetNames','lisetNames','nsetNames')
-ListeConcatene2=('center','normal','dir')
-ListeConcatene3=('ra','rb')
-if_ellipse=False
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'ZCRACKS',
- # La factory pour creer une instance du plugin
- 'factory' : ZCrackGenerator,
- }
-
-
-class ZCrackGenerator(PythonGenerator):
- """
- 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',)
-
-#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=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.textePourRun = texte_debut
-
-
-#----------------------------------------------------------------------------------------
-# ecriture
-#----------------------------------------------------------------------------------------
-
- def writeDefault(self,fn) :
- fileZcrack = fn[:fn.rfind(".")] + '.z7p'
- f = open( str(fileZcrack), 'wb')
- print((self.textePourRun))
-
- self.ajoutRun()
- self.textePourRunAvecDouble=self.textePourRun.replace("'",'"')
- f.write( self.textePourRunAvecDouble)
- f.close()
-
- def ajoutRun(self) :
- self.textePourRun+=" write_mesh_crack();\n"
- self.textePourRun+=" do_mesh_crack(0);\n"
- self.textePourRun+=" write_refine_mesh();\n"
- self.textePourRun+=" do_refine_mesh(0);\n"
- self.textePourRun+=" write_cut_mesh();\n"
- self.textePourRun+=" do_cut_mesh(0);\n"
-# self.textePourRun+=" nice_cut("+str(self.maximum_aspect_ratio)+");\n"
- self.textePourRun+=' export_mesh("'+self.cracked_name+'","med");\n'
- self.textePourRun+="}"
-
-#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
-#----------------------------------------------------------------------------------------
-
- def generMCSIMP(self,obj) :
- """recuperation de l objet MCSIMP"""
- #print dir(obj)
- s=PythonGenerator.generMCSIMP(self,obj)
- if obj.nom=="sane_name" :
- self.textePourRun+=' import_mesh("'+obj.val+'", "med");\n'
- if obj.nom in ListeConcatene :
-# obj.val=obj.val+" "
- stringListe=""
- for val in obj.val:
- stringListe+=val+""
-# pickle.dump( stringListe, open( "/home/H60874/test.pickle", "wb" ) )
-# self.textePourRun+=" "+obj.nom+ "='"+ stringListe[0:-1]+ "';\n"
-# self.textePourRun+=" "+obj.nom+ "='"+ stringListe+ "';\n"
- return s
- if obj.nom in ListeConcatene3 :
- if (obj.nom=="ra") :
- self.textePourRun+=" "+"if_ellipse=1;\n"
- self.textePourRun+=" "+obj.nom+ "="+str(obj.val)+";\n"
- if_ellipse_ellipse=True
- return s
-
- if obj.nom in ListeConcatene2 :
- stringListe=""
-# self.textePourRun+="GGGGGGG%"+obj.nom+"\n"
-# if (len(val)>1) :
- for val in obj.val:
- stringListe+=str(val)+","
- self.textePourRun+=" "+obj.nom+ "=set_vector3("+ stringListe[0:-1]+ ");\n"
-# else :
-# self.textePourRun+=" "+obj.nom+ str(obj.val+ ";\n"
-# stringListe+=str(val)+" "
-# self.textePourRun+=" "+obj.nom+ "=set_vector3("+stringListe[0]+","+stringListe[1]+","+stringListe[2]+");\n"
-# self.textePourRun+=" "+obj.nom+ "=set_vector3("+obj.val+","+");\n"
- return s
-# if obj.nom=="center" :
-# self.textePourRun+=" set_vector3("+obj.val+'");\n"
-# if obj.nom=="center" :
-# self.textePourRun+=" set_vector3("+obj.val+'");\n"
-# if obj.nom=="normal" :
-# self.textePourRun+=" set_vector3("+obj.val+'");\n"
-# if obj.nom=="dir" :
-# self.textePourRun+=" set_vector3("+obj.val+'");\n"
- if obj.nom=="elset_radius" :
- self.textePourRun+=" if_must_define_elset=1;\n"
-
-
- if obj.nom=="cracked_name" : self.cracked_name=obj.val
- if obj.nom=="maximum_aspect_ratio" : self.maximum_aspect_ratio=obj.val
- if obj.nom=="repertoire" :
- print ("PNPNPN a traiter")
- return s
- self.textePourRun+=" "+obj.nom+ "=" + s[0:-1]+ ";\n"
- return s
-
-
-# si repertoire on change tous les noms de fichier
-# exple repertoire='/home' __> fichier='/home/crack.med
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format asterv5 pour EFICAS.
-
-
-"""
-import traceback
-import types,string
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
-from Noyau import N_CR
-from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
-from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
-from Accas import GEOM,ASSD
-from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
-from Formatage import Formatage
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
-
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'asterv5',
- # La factory pour creer une instance du plugin
- 'factory' : AsterGenerator,
- }
-
-
-class AsterGenerator:
- """
- Ce generateur parcourt un objet de type JDC et produit
- un fichier au format asterv5
-
- L'acquisition et le parcours sont realises par la methode
- generator.gener(objet_jdc,format)
-
- L'ecriture du fichier au format asterv5 est realisee 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 asterv5',
- fin='fin CR format asterv5')
- # Le texte au format asterv5 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'):
- """
- 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
- """
- liste= self.generator(obj)
- if format == 'brut':
- self.text=liste
- elif format == 'standard':
- self.text=string.join(liste)
- elif format == 'beautifie':
- jdc_formate = Formatage(liste,sep=':',l_max=72)
- self.text=jdc_formate.formateJdc()
- 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 à 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)
- else:
- raise EficasException(tr("Type d'objet non prevu : %s", repr(obj)))
-
- def generJDC(self,obj):
- """
- Cette methode convertit un objet JDC en une liste de chaines de
- caracteres à la syntaxe asterv5
- """
- l=[]
- 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])==types.ListType:
- l[-1][-1] = l[-1][-1]+'\n'
- elif type(l[-1])==types.StringType:
- l[-1] = l[-1]+'\n'
- return l
-
- def generCOMMANDE_COMM(self,obj):
- """
- Cette methode convertit un COMMANDE_COMM
- en une liste de chaines de caracteres à la syntaxe asterv5
- """
- l_lignes = string.split(obj.valeur,'\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 à la syntaxe asterv5
- """
- return 'EVAL(u"'+ obj.valeur +'")'
-
- def generCOMMENTAIRE(self,obj):
- """
- Cette methode convertit un COMMENTAIRE
- en une liste de chaines de caracteres à la syntaxe asterv5
- """
- l_lignes = string.split(obj.valeur,'\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 liste de chaines de caracteres à la syntaxe asterv5
- """
- 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 liste de chaines de caracteres à la syntaxe asterv5
- """
- if type(obj.valeur) == types.StringType:
- 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 liste de chaines de caracteres à la syntaxe asterv5
- """
- 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 à la syntaxe asterv5
- """
- try:
- if obj.reuse != None:
- sdname= "&" + self.generator(obj.reuse)
- else:
- sdname= self.generator(obj.sd)
- except:
- sdname='sansnom'
- l=[]
- label=sdname + '='+obj.definition.nom+'('
- l.append(label)
- for v in obj.mc_liste:
- if isinstance(v,MCBLOC) or isinstance(v,MCList):
- liste=self.generator(v)
- for mocle in liste :
- l.append(mocle)
- else:
- l.append(self.generator(v))
- if len(l) == 1:
- l[0]=label+');'
- else :
- l.append(');')
- return l
-
- def generFORM_ETAPE(self,obj):
- """
- Methode particuliere pour les objets de type FORMULE
- """
- l=[]
- nom = obj.getNom()
- if nom == '' : nom = 'sansnom'
- if len(obj.mc_liste)>0:
- l.append(nom + ' = FORMULE(')
- s=obj.type_retourne + ' = ' + "'''" + obj.arguments + ' = ' + obj.corps+"'''"
- l.append(s)
- l.append(');')
- else:
- l.append(nom+' = FORMULE();')
- return l
-
- def generMACRO_ETAPE(self,obj):
- """
- Cette methode convertit une macro-etape
- en une liste de chaines de caracteres à la syntaxe asterv5
- """
- if obj.definition.nom == 'FORMULE' : return self.gen_ast_formule(obj)
- try:
- if obj.reuse != None:
- sdname= "&" + self.generator(obj.reuse)+'='
- elif obj.sd == None:
- sdname=''
- else:
- sdname= self.generator(obj.sd)+'='
- except:
- sdname='sansnom='
- l=[]
- label = sdname + obj.definition.nom+'('
- l.append(label)
- for v in obj.mc_liste:
- if isinstance(v,MCBLOC) or isinstance(v,MCList):
- liste=self.generator(v)
- for mocle in liste :
- l.append(mocle)
- else:
- # MCFACT ou MCSIMP
- l.append(self.generator(v))
- if len(l) == 1:
- l[0]=label+');'
- else :
- l.append(');')
- return l
-
- def gen_ast_formule(self,obj):
- """
- Methode gen_ast particuliere aux objets de type FORMULE
- """
- label='!FORMULE('
- try:
- sdname= self.generator(obj.sd)
- except:
- sdname='sansnom'
- l=[]
- l.append(label)
- for v in obj.mc_liste:
- s=''
- s= v.nom+':'+sdname+'('+v.valeur+')'
- l.append(s)
- if len(l) == 1:
- l[0]=label+');'
- else :
- l.append(');')
- return l
-
- def generPROC_ETAPE(self,obj):
- """
- Cette methode convertit une etape
- en une liste de chaines de caracteres à la syntaxe asterv5
- """
- l=[]
- label=obj.definition.nom+'('
- l.append(label)
- for v in obj.mc_liste:
- if isinstance(v,MCBLOC) or isinstance(v,MCList):
- liste=self.generator(v)
- for mocle in liste :
- l.append(mocle)
- else:
- l.append(self.generator(v))
- if len(l) == 1:
- l[0]=label+');'
- else :
- l.append(');')
- return l
-
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en une liste de chaines de caracteres à la
- syntaxe asterv5
- """
- if type(obj.valeur) == types.TupleType :
- s = '('
- for val in obj.valeur :
- if s != '(': s = s + ','
- if type(val) == types.InstanceType :
- if isinstance(val,PARAMETRE):
- # il ne faut pas prendre la string que retourne gen_ast
- # mais seulement le nom dans le cas d'un parametre
- s = s + val.nom
- else:
- s = s + self.generator(val)
- elif self.wait_geom(obj):
- s = s + val
- elif type(val) == types.FloatType :
- #s = s + self.repr_float(val)
- s = s + str(val)
- else :
- s = s + `val`
- s = s + ')'
- s=obj.nom+':'+s+' '
- return s
- else :
- if type(obj.valeur) == types.InstanceType :
- if isinstance(obj.valeur,PARAMETRE):
- # il ne faut pas prendre la string que retourne gen_ast
- # mais seulement str dans le cas d'un parametre
- s = obj.valeur.nom
- else:
- s = self.generator(obj.valeur)
- elif self.wait_geom(obj):
- s = obj.valeur
- elif type(obj.valeur) == types.FloatType :
- #s = self.repr_float(obj.valeur)
- s = str(obj.valeur)
- else :
- s = `obj.valeur`
- s=obj.nom+':'+s+' '
- return s
-
- def wait_geom(self,obj):
- for typ in obj.definition.type:
- if type(typ) == types.ClassType :
- if issubclass(typ,GEOM) : return 1
- return 0
-
- def repr_float(self,valeur):
- """
- Cette fonction represente le reel valeur comme une chaîne de caracteres
- sous forme mantisse exposant si necessaire cad si le nombre contient plus de 5 caracteres
- NB : valeur est un reel au format Python ou une chaîne de caracteres representant un reel
- """
- if type(valeur) == types.StringType : valeur = eval(valeur)
- if valeur == 0. : return '0.0'
- if abs(valeur) > 1. :
- if abs(valeur) < 10000. : return repr(valeur)
- else :
- if abs(valeur) > 0.01 : return repr(valeur)
- t=repr(valeur)
- if string.find(t,'e') != -1 or string.find(t,'E') != -1 :
- # le reel est dejà sous forme mantisse exposant !
- # --> on remplace e par E
- t=string.replace(t,'e','E')
- # --> on doit encore verifier que la mantisse contient bien un '.'
- if string.find(t,'.')!= -1:
- return t
- else:
- # -->il faut rajouter le point avant le E
- t=string.replace(t,'E','.E')
- return t
- s=''
- neg = 0
- if t[0]=='-':
- s=s+t[0]
- t=t[1:]
- cpt = 0
- if string.atof(t[0]) == 0.:
- # reel plus petit que 1
- neg = 1
- t=t[2:]
- cpt=1
- while string.atof(t[0]) == 0. :
- cpt = cpt+1
- t=t[1:]
- s=s+t[0]+'.'
- for c in t[1:]:
- s=s+c
- else:
- # reel plus grand que 1
- s=s+t[0]+'.'
- if string.atof(t[1:]) == 0.:
- l=string.split(t[1:],'.')
- cpt = len(l[0])
- else:
- r=0
- pt=0
- for c in t[1:]:
- r=r+1
- if c != '.' :
- if pt != 1 : cpt = cpt + 1
- s=s+c
- else:
- pt = 1
- if r+1 == len(t) or string.atof(t[r+1:]) == 0.:break
- s=s+'E'+neg*'-'+repr(cpt)
- return s
-
- def generASSD(self,obj):
- """
- Convertit un objet derive d'ASSD en une chaine de caracteres à la
- syntaxe asterv5
- """
- return obj.getName()
-
- def generMCFACT(self,obj):
- """
- Convertit un objet MCFACT en une liste de chaines de caracteres à la
- syntaxe asterv5
- """
- l=[]
- label=obj.nom + ':('
- l.append(label)
- for v in obj.mc_liste:
- if isinstance(v,MCBLOC) or isinstance(v,MCList):
- liste=self.generator(v)
- for mocle in liste :
- l.append(mocle)
- else:
- l.append(self.generator(v))
- l.append(')')
- return l
-
- def generMCList(self,obj):
- """
- Convertit un objet MCList en une liste de chaines de caracteres à la
- syntaxe asterv5
- """
- l=[]
- for mcfact in obj.data:
- l.append(self.generator(mcfact))
- return l
-
- def generMCBLOC(self,obj):
- """
- Convertit un objet MCBLOC en une liste de chaines de caracteres à la
- syntaxe asterv5
- """
- l=[]
- for v in obj.mc_liste:
- if isinstance(v,MCBLOC) or isinstance(v,MCList):
- liste=self.generator(v)
- for mocle in liste :
- l.append(mocle)
- else:
- l.append(self.generator(v))
- return l
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- DefaillCUVE pour EFICAS.
-
-"""
-import traceback
-import types,string,re
-
-from Noyau import N_CR
-from Accas import MCSIMP
-from generator_python import PythonGenerator
-
-def entryPoint():
- """
- Retourne les informations nécessaires pour le chargeur de plugins
-
- Ces informations sont retournées dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'cuve2dg',
- # La factory pour créer une instance du plugin
- 'factory' : Cuve2dgGenerator,
- }
-
-
-class Cuve2dgGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format DefaillCUVE
-
- """
- # Les extensions de fichier préconisées
- 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 DefaillCUVE pour DefaillCUVE',
- fin='fin CR format DefaillCUVE pour DefaillCUVE')
- # Le texte au format DefaillCUVE est stocké dans l'attribut textCuve
- self.textCuve=''
-
- # Ce dictionnaire liste le nom des variables utilisees dans le script
- self.variable = {
- "NiveauImpression" : "MESSAGE_LEVEL",
- "FichierDataIn" : "DATARESUME_FILE",
- "FichierTempSigma" : "TEMPSIG_FILE",
- "FichierCSV" : "CSV_FILE",
- "FichierRESTART" : "RESTART_FILE",
- "FichierEXTR" : "EXTR_FILE",
- "ChoixPlugin" : "CHOIPLUG",
- "GrandeurEvaluee" : "GRANDEUR",
- "IncrementTemporel" : "INCRTPS",
- "IncrementMaxTemperature" : "DTPREC",
- "ChoixExtractionTransitoires" : "CHOIEXTR",
- "IncrementMaxTempsAffichage" : "DTARCH",
- "traitementGeometrie" : "TYPEGEOM",
- "RayonInterne" : "RINT",
- "RayonInterne_mess" : "RINT_MESSAGE",
- "RayonExterne" : "REXT",
- "RayonExterne_mess" : "REXT_MESSAGE",
- "EpaisseurRevetement" : "LREV",
- "EpaisseurRevetement_mess" : "LREV_MESSAGE",
- "LigamentExterneMin" : "LIGMIN",
- "LigamentExterneMin_mess" : "LIGMIN_MESSAGE",
- "NombreNoeudsMaillage" : "NBNO",
- "TypeInitial" : "TYPEDEF",
- "Orientation" : "ORIEDEF",
- "Position" : "POSDEF",
- "ProfondeurRadiale" : "PROFDEF",
- "ProfondeurRadiale_mess" : "PROFDEF_MESSAGE",
- "ModeCalculLongueur" : "OPTLONG",
- "Longueur" : "LONGDEF",
- "Longueur_mess" : "LONGDEF_MESSAGE",
- "CoefDirecteur" : "PROFSURLONG",
- "CoefDirecteur_mess" : "PROFSURLONG_MESSAGE",
- "Constante" : "LONGCONST",
- "ModeCalculDecalage" : "DECATYP",
- "DecalageNormalise" : "DECANOR",
- "DecalageNormalise_mess" : "DECANOR_MESSAGE",
- "DecalageRadial" : "DECADEF",
- "DecalageRadial_mess" : "DECADEF_MESSAGE",
- "Azimut" : "ANGLDEF",
- "Azimut_mess" : "ANGLDEF_MESSAGE",
- "Altitude_mess" : "ANGLDEF_MESSAGE",
- "Altitude" : "ALTIDEF",
- "Altitude_mess" : "ALTIDEF_MESSAGE",
- "Pointe" : "POINDEF",
- "ModeleFluence" : "MODELFLUENCE",
- "ZoneActiveCoeur_AltitudeSup" : "H1COEUR",
- "ZoneActiveCoeur_AltitudeInf" : "H2COEUR",
- "FluenceMax" : "fmax",
- "KPFrance" : "KPFRANCE",
- "KPUS" : "KPUS",
- "Azimut_0deg" : "COEFFLUENCE1",
- "Azimut_5deg" : "COEFFLUENCE2",
- "Azimut_10deg" : "COEFFLUENCE3",
- "Azimut_15deg" : "COEFFLUENCE4",
- "Azimut_20deg" : "COEFFLUENCE5",
- "Azimut_25deg" : "COEFFLUENCE6",
- "Azimut_30deg" : "COEFFLUENCE7",
- "Azimut_35deg" : "COEFFLUENCE8",
- "Azimut_40deg" : "COEFFLUENCE9",
- "Azimut_45deg" : "COEFFLUENCE10",
- "TypeIrradiation" : "TYPEIRR",
- "RTNDT" : "RTNDT",
- "ModeleIrradiation" : "MODELIRR",
- "TeneurCuivre" : "CU",
- "TeneurCuivre_mess" : "CU_MESSAGE",
- "TeneurNickel" : "NI",
- "TeneurNickel_mess" : "NI_MESSAGE",
- "TeneurPhosphore" : "P",
- "TeneurPhosphore_mess" : "P_MESSAGE",
- "MoyenneRTndt" : "RTimoy",
- "MoyenneRTndt_mess" : "RTimoy_MESSAGE",
- "CoefVariationRTndt" : "RTicov",
- "CoefVariationRTndt_mess" : "RTicov_MESSAGE",
- "EcartTypeRTndt" : "USectDRT",
- "EcartTypeRTndt_mess" : "USectDRT_MESSAGE",
- "NombreEcartTypeRTndt" : "nbectDRTNDT",
- "NombreEcartTypeRTndt_mess" : "nbectDRTNDT_MESSAGE",
- "ModeleTenacite" : "MODELKIC",
- "NombreCaracteristique" : "NBCARAC",
- "NbEcartType_MoyKIc" : "nbectKIc",
- "NbEcartType_MoyKIc_mess" : "nbectKIc_MESSAGE",
- "PalierDuctile_KIc" : "KICPAL",
- "CoefficientVariation_KIc" : "KICCDV",
- "Fractile_KIc" : "fractKIc",
- "Fractile_KIc_mess" : "fractKIc_MESSAGE",
- "Temperature_KIc100" : "T0WALLIN",
- "A1" : "A1",
- "A2" : "A2",
- "A3" : "A3",
- "B1" : "B1",
- "B2" : "B2",
- "B3" : "B3",
- "C1" : "C1",
- "C2" : "C2",
- "C3" : "C3",
- "ChoixCorrectionLongueur" : "CHOIXCL",
- "AttnCorrBeta" : "ATTNCORRBETA",
- "CorrIrwin" : "CORRIRWIN",
- "ArretDeFissure" : "ARRETFISSURE",
- "IncrementTailleFissure" : "INCRDEF",
- "IncrementTailleFissure_mess" : "INCRDEF_MESSAGE",
- "NbEcartType_MoyKIa" : "nbectKIa",
- "PalierDuctile_KIa" : "KIAPAL",
- "CoefficientVariation_KIa" : "KIACDV",
- "ChoixCoefficientChargement" : "CHOIXSIGM",
- "CoefficientDuctile" : "COEFSIGM1",
- "CoefficientFragile" : "COEFSIGM2",
- "InstantInitialisation" : "INSTINIT",
- "ConditionLimiteThermiqueREV" : "KTHREV",
- "TemperatureDeformationNulleREV" : "TREFREV",
- "TemperaturePourCoefDilatThermREV" : "TDETREV",
- "CoefficientPoissonREV" : "NUREV",
- "ConditionLimiteThermiqueMDB" : "KTHMDB",
- "TemperatureDeformationNulleMDB" : "TREFMDB",
- "TemperaturePourCoefDilatThermMDB" : "TDETMDB",
- "CoefficientPoissonMDB" : "NUMDB",
- "TypeConditionLimiteThermique" : "TYPCLTH",
- "Instant_1" : "INSTANT1",
- "Instant_2" : "INSTANT2",
- "Instant_3" : "INSTANT3",
- "DebitAccumule" : "QACCU",
- "DebitInjectionSecurite" : "QIS",
- "TempInjectionSecurite" : "TIS",
- "TempInjectionSecurite_mess" : "TIS_MESSAGE",
- "DiametreHydraulique" : "DH",
- "DiametreHydraulique_mess" : "DH_MESSAGE",
- "SectionEspaceAnnulaire" : "SECTION",
- "SectionEspaceAnnulaire_mess" : "SECTION_MESSAGE",
- "HauteurCaracConvectionNaturelle" : "DELTA",
- "HauteurCaracConvectionNaturelle_mess" : "DELTA_MESSAGE",
- "CritereConvergenceRelative" : "EPS",
- "CoefficientsVestale" : "COEFVESTALE",
- "VolumeMelange_CREARE" : "VMTAB",
- "TemperatureInitiale_CREARE" : "T0",
- "TemperatureInitiale_CREARE_mess" : "T0_MESSAGE",
- "SurfaceEchange_FluideStructure" : "SE",
- "SurfaceEchange_FluideStructure_mess" : "SE_MESSAGE",
- "InstantPerteCirculationNaturelle" : "INST_PCN",
- }
-
- # Ce dictionnaire liste le nom des valeurs proposées utilisees dans le script
- self.valeurproposee = {
- "Aucune impression" : "0",
- "Temps total" : "1",
- "Temps intermediaires" : "2",
- "Facteur de marge KIc/KCP" : "FM_KICSURKCP",
- "Marge KIc-KI" : "MARGE_KI",
- "Marge KIc-KCP" : "MARGE_KCP",
- "Topologie" : "GEOMETRIE",
- "Maillage" : "MAILLAGE",
- "Defaut Sous Revetement" : "DSR",
- "Defaut Decale" : "DECALE",
- "Defaut Debouchant" : "DEBOUCHANT",
- "Longitudinale" : "LONGITUD",
- "Circonferentielle" : "CIRCONF",
- "Virole" : "VIROLE",
- "Joint soude" : "JSOUDE",
- "Valeur" : "VALEUR",
- "Fonction affine de la profondeur" : "FCTAFFINE",
- "Valeur normalisee" : "NORMALISE",
- "A" : "A",
- "B" : "B",
- "A et B" : "BOTH",
- "Exponentiel sans revetement k=9.7 (Reglementaire)" : "Reglementaire",
- "Exponentiel sans revetement k=12.7 (France)" : "France",
- "Exponentiel sans revetement k=0. (ValeurImposee)" : "ValeurImposee",
- "Donnees francaises du palier CPY (SDM)" : "SDM",
- "Regulatory Guide 1.99 rev 2 (USNRC)" : "USNRC",
- "Dossier 900 MWe AP9701 rev 2 (REV_2)" : "REV_2",
- "Lissage du modele ajuste (SDM_Lissage)" : "SDM_Lissage",
- "Donnees francaises du palier CPY ajustees par secteur angulaire (GrandeDev)" : "GrandeDev",
- "Grand developpement (GD_Cuve)" : "GD_Cuve",
- "Exponentiel sans revetement k=9.7 (Reglementaire CUVE1D)" : "Cuve1D",
- "RTndt de la cuve a l instant de l analyse" : "RTNDT",
- "Modele d irradiation" : "FLUENCE",
- "Formule de FIM/FIS Lefebvre modifiee" : "LEFEBnew",
- "Metal de Base : formule de FIM/FIS Houssin" : "HOUSSIN",
- "Metal de Base : formule de FIM/FIS Persoz" : "PERSOZ",
- "Metal de Base : formule de FIM/FIS Lefebvre" : "LEFEBVRE",
- "Metal de Base : Regulatory Guide 1.00 rev 2" : "USNRCmdb",
- "Joint Soude : formulation de FIM/FIS Brillaud" : "BRILLAUD",
- "Joint Soude : Regulatory Guide 1.00 rev 2" : "USNRCsoud",
- "RCC-M/ASME coefficient=2" : "RCC-M",
- "RCC-M/ASME coefficient=2 CUVE1D" : "RCC-M_simpl",
- "RCC-M/ASME coefficient=2.33 (Houssin)" : "Houssin_RC",
- "RCC-M/ASME avec KI=KIpalier" : "RCC-M_pal",
- "RCC-M/ASME avec KI~exponentiel" : "RCC-M_exp",
- "Weibull basee sur la master cuve" : "Wallin",
- "Weibull basee sur la master cuve (REME)" : "REME",
- "Weibull n\xb01 (etude ORNL)" : "ORNL",
- "Weibull n\xb02" : "WEIB2",
- "Weibull n\xb03" : "WEIB3",
- "Weibull generalisee" : "WEIB-GEN",
- "Exponentielle n\xb01 (Frama)" : "Frama",
- "Exponentielle n\xb02 (LOGWOLF)" : "LOGWOLF",
- "Quantile" : "QUANTILE",
- "Ordre" : "ORDRE",
- "Enthalpie" : "ENTHALPIE",
- "Chaleur" : "CHALEUR",
- "Temperature imposee en paroi" : "TEMP_IMPO",
- "Flux de chaleur impose en paroi" : "FLUX_REP",
- "Temperature imposee du fluide et coefficient echange" : "ECHANGE",
- "Debit massique et temperature d injection de securite" : "DEBIT",
- "Temperature imposee du fluide et debit d injection de securite" : "TEMP_FLU",
- "Courbe APRP" : "APRP",
- "Calcul TEMPFLU puis DEBIT" : "TFDEBIT",
- }
-
- # Ce dictionnaire liste le commentaire des variables utilisees dans le script
- self.comment = {
- "NiveauImpression" : "Niveau d impression des messages a l ecran (=0 : rien, =1 : temps calcul total, =2 : temps intermediaires)",
- "FichierDataIn" : "sortie du fichier recapitulatif des donnees d entree {OUI ; NON}",
- "FichierTempSigma" : "sortie des fichiers temperature et contraintes {OUI ; NON}",
- "FichierCSV" : "sortie du fichier resultat template_DEFAILLCUVE.CSV {OUI ; NON}",
- "FichierRESTART" : "sortie du fichier de re-demarrage",
- "FichierEXTR" : "sortie du fichier d extraction des transitoires",
- "ChoixPlugin" : "choix d'un repertoire de plug-in",
- "GrandeurEvaluee" : "choix de la grandeur sous critere evaluee {FM_KICSURKCP ; MARGE_KI ; MARGE_KCP}",
- "IncrementTemporel" : "increment temporel pour l analyse PROBABILISTE (si DETERMINISTE, fixer a 1)",
- "IncrementMaxTemperature" : "increment max de temp/noeud/instant (degC)",
- "ChoixExtractionTransitoires" : "choix d'extraction de transitoires de temp et contraintes",
- "IncrementMaxTempsAffichage" : "increment max de temps pour affichage (s)",
- "traitementGeometrie" : "traitement de la geometrie de la cuve : {GEOMETRIE, MAILLAGE}",
- "RayonInterne" : "rayon interne (m)",
- "RayonInterne_mess" : "affichage ecran du rayon interne (m)",
- "RayonExterne" : "rayon externe (m)",
- "RayonExterne_mess" : "affichage ecran du rayon externe (m)",
- "EpaisseurRevetement" : "epaisseur revetement (m)",
- "EpaisseurRevetement_mess" : "affichage ecran de l epaisseur revetement (m)",
- "LigamentExterneMin" : "ligament externe minimal avant rupture (% de l'epaisseur de cuve)",
- "LigamentExterneMin_mess" : "affichage ecran du ligament externe minimal avant rupture (% de l'epaisseur de cuve)",
- "NombreNoeudsMaillage" : "nbre de noeuds dans l'epaisseur de la cuve",
- "TypeInitial" : "type initial du defaut : DEBOUCHANT=Defaut Debouchant, DSR=Defaut Sous Revetement, DECALE=Defaut Decale",
- "Orientation" : "orientation (LONGITUD / CIRCONF)",
- "Position" : "Position du defaut (VIROLE / JSOUDE)",
- "ProfondeurRadiale" : "profondeur radiale ou encore hauteur (m)",
- "ProfondeurRadiale_mess" : "affichage ecran de la profondeur radiale ou encore hauteur (m)",
- "ModeCalculLongueur" : "option pour definir la longueur du defaut (VALEUR pour une valeur fixe, FCTAFFINE pour une fct affine de la profondeur)",
- "Longueur" : "longueur (m) pour defaut Sous Revetement",
- "Longueur_mess" : "affichage ecran de la longueur (m) pour defaut Sous Revetement",
- "CoefDirecteur" : "pente de la fonction affine l = h/profsurlong + a0",
- "CoefDirecteur_mess" : "affichage ecran de la pente de la fonction affine l = h/profsurlong + a0",
- "Constante" : "constante de la fonction affine a0",
- "ModeCalculDecalage" : "type de decalage : normalise (NORMALISE) ou reel (VALEUR)",
- "DecalageNormalise" : "decalage radial normalise (valeur comprise entre 0. et 1.) pour defaut Sous Revetement",
- "DecalageNormalise_mess" : "affichage ecran du decalage radial normalise (valeur comprise entre 0. et 1.) pour defaut Sous Revetement",
- "DecalageRadial" : "decalage radial reel (m) pour defaut decale",
- "DecalageRadial_mess" : "affichage ecran du decalage radial reel (m) pour defaut decale",
- "Azimut" : "coordonnee angulaire (degre)",
- "Azimut_mess" : "affichage ecran de la coordonnee angulaire (degre)",
- "Altitude" : "altitude (m) : valeur negative",
- "Altitude_mess" : "affichage ecran de l altitude (m) : valeur negative",
- "Pointe" : "choix du(des) point(s) du defaut considere {'A','B','BOTH'} pour DSR et DECALE (pour DEBOUCHANT : automatiquement 'B')",
- "ModeleFluence" : "modele de fluence : {Reglementaire, France, ValeurImposee, SDM, USNRC, REV_2, SDM_Lissage, GrandeDev, GD_Cuve, Cuve1D}",
- "ZoneActiveCoeur_AltitudeSup" : "cote superieure de la zone active de coeur (ici pour cuve palier 900Mw)",
- "ZoneActiveCoeur_AltitudeInf" : "cote inferieure de la zone active de coeur (ici pour cuve palier 900Mw)",
- "FluenceMax" : "fluence maximale assimilee par la cuve (n/cm2)",
- "KPFrance" : "parametre exponentiel du modele France",
- "KPUS" : "parametre exponentiel du modele US",
- "Azimut_0deg" : "fluence a l'azimut 0 (10^19 n/cm)",
- "Azimut_5deg" : "fluence a l'azimut 5 (10^19 n/cm)",
- "Azimut_10deg" : "fluence a l'azimut 10 (10^19 n/cm)",
- "Azimut_15deg" : "fluence a l'azimut 15 (10^19 n/cm)",
- "Azimut_20deg" : "fluence a l'azimut 20 (10^19 n/cm)",
- "Azimut_25deg" : "fluence a l'azimut 25 (10^19 n/cm)",
- "Azimut_30deg" : "fluence a l'azimut 30 (10^19 n/cm)",
- "Azimut_35deg" : "fluence a l'azimut 35 (10^19 n/cm)",
- "Azimut_40deg" : "fluence a l'azimut 40 (10^19 n/cm)",
- "Azimut_45deg" : "fluence a l'azimut 45 (10^19 n/cm)",
- "TypeIrradiation" : "type irradiation : {RTNDT, FLUENCE}",
- "RTNDT" : "RTNDT finale (degC)",
- "ModeleIrradiation" : "modele d irradiation : LEFEBnew, ou {HOUSSIN, PERSOZ, LEFEBVRE, USNRCmdb} pour virole et {BRILLAUD,USNRCsoud} pour jointsoude",
- "TeneurCuivre" : "teneur en cuivre (%)",
- "TeneurCuivre_mess" : "affichage ecran de la teneur en cuivre (%)",
- "TeneurNickel" : "teneur en nickel (%)",
- "TeneurNickel_mess" : "affichage ecran de la teneur en nickel (%)",
- "TeneurPhosphore" : "teneur en phosphore (%)",
- "TeneurPhosphore_mess" : "affichage ecran de la teneur en phosphore (%)",
- "MoyenneRTndt" : "moyenne de la RTNDT initiale : virole C1 de cuve Chinon : mdb=>-17.degC et js=>42.degC (HT-56/05/038 : p.52)",
- "MoyenneRTndt_mess" : "affichage ecran de la moyenne de la RTNDT initiale",
- "CoefVariationRTndt" : "coef de variation de la RTNDT initiale",
- "CoefVariationRTndt_mess" : "affichage ecran du coef de variation de la RTNDT initiale",
- "EcartTypeRTndt" : "pour modeles USNRCsoud ou USNRCmdb, ecart-type du decalage de RTNDT (°F) (28. pour js et 17. pour mdb)",
- "EcartTypeRTndt_mess" : "affichage ecran, pour modeles USNRCsoud ou USNRCmdb, ecart-type du decalage de RTNDT (°F) (28. pour js et 17. pour mdb)",
- "NombreEcartTypeRTndt" : "Nbre d ecart-type par rapport a la moyenne de DRTNDT si analyse PROBABILISTE (en DETERMINISTE, fixer a 2.)",
- "NombreEcartTypeRTndt_mess" : "affichage ecran du nbre d ecart-type par rapport a la moyenne de DRTNDT si analyse PROBABILISTE",
- "ModeleTenacite" : "modele de tenacite : {RCC-M, RCC-M_pal, RCC-M_exp, RCC-M_simpl, Houssin_RC, Wallin, REME, ORNL, Frama, WEIB3, WEIB2, LOGWOLF, WEIB-GEN}",
- "NombreCaracteristique" : "Nb caracteristique : ORDRE ou QUANTILE",
- "NbEcartType_MoyKIc" : "Nbre d ecart-type par rapport a la moyenne de KIc si analyse PROBABILISTE (en DETERMINISTE, fixer a -2.)",
- "NbEcartType_MoyKIc_mess" : "affichage ecran du nbre d ecart-type par rapport a la moyenne de KIc si analyse PROBABILISTE",
- "PalierDuctile_KIc" : "palier deterministe de K1c (MPa(m^0.5))",
- "CoefficientVariation_KIc" : "coef de variation de la loi normale de K1c",
- "Fractile_KIc" : "valeur caracteristique de KIc exprimee en ordre de fractile (%)",
- "Fractile_KIc_mess" : "affichage ecran de la valeur caracteristique de KIc exprimee en ordre de fractile (%)",
- "Temperature_KIc100" : "parametre T0 du modele Wallin (degC)",
- "A1" : "coef des coefs d une WEIBULL generale",
- "A2" : "",
- "A3" : "",
- "B1" : "",
- "B2" : "",
- "B3" : "",
- "C1" : "",
- "C2" : "",
- "C3" : "",
- "ChoixCorrectionLongueur" : "Activation ou non de la correction de longueur {OUI ; NON}",
- "AttnCorrBeta" : "Attenuation de la correction plastique : {OUI, NON} ==> uniquement pour DSR ou DECALE",
- "CorrIrwin" : "Correction plastique IRWIN : {OUI, NON} ==> uniquement pour DEBOUCHANT",
- "ArretDeFissure" : "prise en compte de l arret de fissure {OUI, NON} (en PROBABILISTE, fixer a NON)",
- "IncrementTailleFissure" : "increment de la taille de fissure (m)",
- "IncrementTailleFissure_mess" : "affichage ecran de l increment de la taille de fissure (m)",
- "NbEcartType_MoyKIa" : "Nbre d ecart-type par rapport a la moyenne de KIa (nb sigma)",
- "PalierDuctile_KIa" : "palier deterministe de K1a quand modele RCC-M (MPa(m^0.5))",
- "CoefficientVariation_KIa" : "coef de variation de la loi normale de K1a",
- "ChoixCoefficientChargement" : "prise en compte de coefficients sur le chargement (OUI/NON)",
- "CoefficientDuctile" : "coefficient multiplicateur pour rupture ductile",
- "CoefficientFragile" : "coefficient multiplicateur pour rupture fragile",
- "InstantInitialisation" : "instant initial (s)",
- "ConditionLimiteThermiqueREV" : "Option 'ENTHALPIE' ou 'CHALEUR'",
- "TemperatureDeformationNulleREV" : "temperature de deformation nulle (degC)",
- "TemperaturePourCoefDilatThermREV" : "temperature de definition du coefficient de dilatation thermique (degC)",
- "CoefficientPoissonREV" : "coefficient de Poisson",
- "ConditionLimiteThermiqueMDB" : "Option 'ENTHALPIE' ou 'CHALEUR'",
- "TemperatureDeformationNulleMDB" : "temperature de deformation nulle (degC)",
- "TemperaturePourCoefDilatThermMDB" : "temperature de definition du coefficient de dilatation thermique (degC)",
- "CoefficientPoissonMDB" : "coefficient de Poisson",
- "TypeConditionLimiteThermique" : "Type de condition thermique en paroi interne {TEMP_IMPO,FLUX_REP,ECHANGE,DEBIT,TEMP_FLU,APRP}",
- "Instant_1" : "Borne superieure de l intervalle de temps du 1er palier TACCU",
- "Instant_2" : "Borne superieure de l intervalle de temps du 2nd palier T1",
- "Instant_3" : "Borne superieure de l intervalle de temps du 3eme palier TIS",
- "DebitAccumule" : "Debit accumule (en m3/h)",
- "DebitInjectionSecurite" : "Debit injection de securite (en m3/h)",
- "TempInjectionSecurite" : "Temperature injection de securite (en degC)",
- "TempInjectionSecurite_mess" : "affichage ecran de la temperature injection de securite",
- "DiametreHydraulique" : "Diametre hydraulique (m)",
- "DiametreHydraulique_mess" : "affichage ecran du diametre hydraulique (m)",
- "SectionEspaceAnnulaire" : "Section espace annulaire (m2)",
- "SectionEspaceAnnulaire_mess" : "affichage ecran de la section espace annulaire (m2)",
- "HauteurCaracConvectionNaturelle" : "Hauteur caracteristique convection naturelle (m)",
- "HauteurCaracConvectionNaturelle_mess" : "affichage ecran de la hauteur caracteristique convection naturelle (m)",
- "CritereConvergenceRelative" : "Critere convergence relative (-)",
- "CoefficientsVestale" : "Application des coefs de Vestale {OUI;NON}",
- "VolumeMelange_CREARE" : "Transitoire de volume de melange CREARE (m3)",
- "TemperatureInitiale_CREARE" : "Temperature initiale CREARE (degC)",
- "TemperatureInitiale_CREARE_mess" : "affichage ecran de la temperature initiale CREARE (degC)",
- "SurfaceEchange_FluideStructure" : "Surface d'echange fluide/structure (m2)",
- "SurfaceEchange_FluideStructure_mess" : "affichage ecran de la surface d'echange fluide/structure (m2)",
- "InstantPerteCirculationNaturelle" : "Instant de perte de circulation naturelle",
- }
-
- # Ce dictionnaire liste la valeur par defaut des variables utilisees dans le script
- self.default = {
- "NiveauImpression" : "1",
- "FichierDataIn" : "NON",
- "FichierTempSigma" : "NON",
- "FichierCSV" : "NON",
- "FichierRESTART" : "NON",
- "FichierEXTR" : "NON",
- "ChoixPlugin" : "NON",
- "GrandeurEvaluee" : "FM_KICSURKCP",
- "IncrementTemporel" : "1",
- "IncrementMaxTemperature" : "0.1",
- "ChoixExtractionTransitoires" : "NON",
- "IncrementMaxTempsAffichage" : "1000.",
- "traitementGeometrie" : "GEOMETRIE",
- "RayonInterne" : "1.994",
- "RayonInterne_mess" : "NON",
- "RayonExterne" : "2.2015",
- "RayonExterne_mess" : "NON",
- "EpaisseurRevetement" : "0.0075",
- "EpaisseurRevetement_mess" : "NON",
- "LigamentExterneMin" : "0.75",
- "LigamentExterneMin_mess" : "NON",
- "NombreNoeudsMaillage" : "300",
- "TypeInitial" : "DSR",
- "Position" : "VIROLE",
- "ProfondeurRadiale" : "0.006",
- "ProfondeurRadiale_mess" : "NON",
- "ModeCalculLongueur" : "VALEUR",
- "Longueur" : "0.060",
- "Longueur_mess" : "NON",
- "CoefDirecteur" : "10.",
- "CoefDirecteur_mess" : "NON",
- "Constante" : "0.",
- "ModeCalculDecalage" : "VALEUR",
- "DecalageNormalise" : "0.1",
- "DecalageNormalise_mess" : "NON",
- "DecalageRadial" : "0.",
- "DecalageRadial_mess" : "NON",
- "Azimut" : "0.",
- "Azimut_mess" : "NON",
- "Altitude" : "-4.",
- "Altitude_mess" : "NON",
- "Pointe" : "B",
- "ModeleFluence" : "Reglementaire",
- "ZoneActiveCoeur_AltitudeSup" : "-3.536",
- "ZoneActiveCoeur_AltitudeInf" : "-7.194",
- "FluenceMax" : "6.5",
- "KPFrance" : "12.7",
- "KPUS" : "9.4488",
- "Azimut_0deg" : "5.8",
- "Azimut_5deg" : "5.48",
- "Azimut_10deg" : "4.46",
- "Azimut_15deg" : "3.41",
- "Azimut_20deg" : "3.37",
- "Azimut_25deg" : "3.16",
- "Azimut_30deg" : "2.74",
- "Azimut_35deg" : "2.25",
- "Azimut_40deg" : "1.89",
- "Azimut_45deg" : "1.78",
- "TypeIrradiation" : "RTNDT",
- "RTNDT" : "64.",
- "ModeleIrradiation" : "HOUSSIN",
- "TeneurCuivre" : "0.0972",
- "TeneurCuivre_mess" : "NON",
- "TeneurNickel" : "0.72",
- "TeneurNickel_mess" : "NON",
- "TeneurPhosphore" : "0.00912",
- "TeneurPhosphore_mess" : "NON",
- "MoyenneRTndt" : "-12.0",
- "MoyenneRTndt_mess" : "NON",
- "CoefVariationRTndt" : "0.1",
- "CoefVariationRTndt_mess" : "NON",
- "EcartTypeRTndt" : "-2.",
- "EcartTypeRTndt_mess" : "NON",
- "NombreEcartTypeRTndt" : "2.",
- "NombreEcartTypeRTndt_mess" : "NON",
- "ModeleTenacite" : "RCC-M",
- "NombreCaracteristique" : "Quantile",
- "NbEcartType_MoyKIc" : "-2.",
- "NbEcartType_MoyKIc_mess" : "NON",
- "PalierDuctile_KIc" : "195.",
- "CoefficientVariation_KIc" : "0.15",
- "Fractile_KIc" : "5.",
- "Fractile_KIc_mess" : "NON",
- "Temperature_KIc100" : "-27.",
- "A1" : "21.263",
- "A2" : "9.159",
- "A3" : "0.04057",
- "B1" : "17.153",
- "B2" : "55.089",
- "B3" : "0.0144",
- "C1" : "4.",
- "C2" : "0.",
- "C3" : "0.",
- "ChoixCorrectionLongueur" : "OUI",
- "AttnCorrBeta" : "NON",
- "CorrIrwin" : "NON",
- "ArretDeFissure" : "NON",
- "IncrementTailleFissure" : "0.",
- "IncrementTailleFissure_mess" : "NON",
- "NbEcartType_MoyKIa" : "0.",
- "PalierDuctile_KIa" : "0.",
- "CoefficientVariation_KIa" : "0.",
- "ChoixCoefficientChargement" : "NON",
- "CoefficientDuctile" : "1.0",
- "CoefficientFragile" : "1.0",
- "InstantInitialisation" : "-1.",
- "ConditionLimiteThermiqueREV" : "CHALEUR",
- "TemperatureDeformationNulleREV" : "20.",
- "TemperaturePourCoefDilatThermREV" : "287.",
- "CoefficientPoissonREV" : "0.3",
- "ConditionLimiteThermiqueMDB" : "CHALEUR",
- "TemperatureDeformationNulleMDB" : "20.",
- "TemperaturePourCoefDilatThermMDB" : "287.",
- "CoefficientPoissonMDB" : "0.3",
- "TypeConditionLimiteThermique" : "TEMP_IMPO",
- "Instant_1" : "21.",
- "Instant_2" : "45.",
- "Instant_3" : "5870.",
- "DebitAccumule" : "2.3",
- "DebitInjectionSecurite" : "0.375",
- "TempInjectionSecurite" : "9.",
- "TempInjectionSecurite_mess" : "NON",
- "DiametreHydraulique" : "0.3816",
- "DiametreHydraulique_mess" : "NON",
- "SectionEspaceAnnulaire" : "0.21712",
- "SectionEspaceAnnulaire_mess" : "NON",
- "HauteurCaracConvectionNaturelle" : "6.",
- "HauteurCaracConvectionNaturelle_mess" : "NON",
- "CritereConvergenceRelative" : "0.00001",
- "CoefficientsVestale" : "NON",
-# "VolumeMelange_CREARE" : "14.9",
- "TemperatureInitiale_CREARE" : "250.",
- "TemperatureInitiale_CREARE_mess" : "NON",
- "SurfaceEchange_FluideStructure" : "0.",
- "SurfaceEchange_FluideStructure_mess" : "NON",
- "InstantPerteCirculationNaturelle" : "400.",
- }
-
- # Ce dictionnaire liste la rubrique d'appartenance des variables utilisees dans le script
- self.bloc = {
- "NiveauImpression" : "OPTIONS",
- "FichierDataIn" : "OPTIONS",
- "FichierTempSigma" : "OPTIONS",
- "FichierCSV" : "OPTIONS",
- "FichierRESTART" : "OPTIONS",
- "FichierEXTR" : "OPTIONS",
- "ChoixPlugin" : "OPTIONS",
- "GrandeurEvaluee" : "OPTIONS",
- "IncrementTemporel" : "OPTIONS",
- "IncrementMaxTemperature" : "OPTIONS",
- "ChoixExtractionTransitoires" : "OPTIONS",
- "IncrementMaxTempsAffichage" : "OPTIONS",
- "traitementGeometrie" : "DONNEES DE LA CUVE",
- "RayonInterne" : "DONNEES DE LA CUVE",
- "RayonInterne_mess" : "DONNEES DE LA CUVE",
- "RayonExterne" : "DONNEES DE LA CUVE",
- "RayonExterne_mess" : "DONNEES DE LA CUVE",
- "EpaisseurRevetement" : "DONNEES DE LA CUVE",
- "EpaisseurRevetement_mess" : "DONNEES DE LA CUVE",
- "LigamentExterneMin" : "DONNEES DE LA CUVE",
- "LigamentExterneMin_mess" : "DONNEES DE LA CUVE",
- "NombreNoeudsMaillage" : "DONNEES DE LA CUVE",
- "TypeInitial" : "CARACTERISTIQUES DU DEFAUT",
- "Orientation" : "CARACTERISTIQUES DU DEFAUT",
- "Position" : "CARACTERISTIQUES DU DEFAUT",
- "ProfondeurRadiale" : "CARACTERISTIQUES DU DEFAUT",
- "ProfondeurRadiale_mess" : "CARACTERISTIQUES DU DEFAUT",
- "ModeCalculLongueur" : "CARACTERISTIQUES DU DEFAUT",
- "Longueur" : "CARACTERISTIQUES DU DEFAUT",
- "Longueur_mess" : "CARACTERISTIQUES DU DEFAUT",
- "CoefDirecteur" : "CARACTERISTIQUES DU DEFAUT",
- "CoefDirecteur_mess" : "CARACTERISTIQUES DU DEFAUT",
- "Constante" : "CARACTERISTIQUES DU DEFAUT",
- "ModeCalculDecalage" : "CARACTERISTIQUES DU DEFAUT",
- "DecalageNormalise" : "CARACTERISTIQUES DU DEFAUT",
- "DecalageNormalise_mess" : "CARACTERISTIQUES DU DEFAUT",
- "DecalageRadial" : "CARACTERISTIQUES DU DEFAUT",
- "DecalageRadial_mess" : "CARACTERISTIQUES DU DEFAUT",
- "Azimut" : "CARACTERISTIQUES DU DEFAUT",
- "Azimut_mess" : "CARACTERISTIQUES DU DEFAUT",
- "Altitude" : "CARACTERISTIQUES DU DEFAUT",
- "Altitude_mess" : "CARACTERISTIQUES DU DEFAUT",
- "Pointe" : "CARACTERISTIQUES DU DEFAUT",
- "ModeleFluence" : "MODELES",
- "ZoneActiveCoeur_AltitudeSup" : "MODELES",
- "ZoneActiveCoeur_AltitudeInf" : "MODELES",
- "FluenceMax" : "MODELES",
- "KPFrance" : "MODELES",
- "KPUS" : "MODELES",
- "Azimut_0deg" : "MODELES",
- "Azimut_5deg" : "MODELES",
- "Azimut_10deg" : "MODELES",
- "Azimut_15deg" : "MODELES",
- "Azimut_20deg" : "MODELES",
- "Azimut_25deg" : "MODELES",
- "Azimut_30deg" : "MODELES",
- "Azimut_35deg" : "MODELES",
- "Azimut_40deg" : "MODELES",
- "Azimut_45deg" : "MODELES",
- "TypeIrradiation" : "MODELES",
- "RTNDT" : "MODELES",
- "ModeleIrradiation" : "MODELES",
- "TeneurCuivre" : "MODELES",
- "TeneurCuivre_mess" : "MODELES",
- "TeneurNickel" : "MODELES",
- "TeneurNickel_mess" : "MODELES",
- "TeneurPhosphore" : "MODELES",
- "TeneurPhosphore_mess" : "MODELES",
- "MoyenneRTndt" : "MODELES",
- "MoyenneRTndt_mess" : "MODELES",
- "CoefVariationRTndt" : "MODELES",
- "CoefVariationRTndt_mess" : "MODELES",
- "EcartTypeRTndt" : "MODELES",
- "EcartTypeRTndt_mess" : "MODELES",
- "NombreEcartTypeRTndt" : "MODELES",
- "NombreEcartTypeRTndt_mess" : "MODELES",
- "ModeleTenacite" : "MODELES",
- "NombreCaracteristique" : "MODELES",
- "NbEcartType_MoyKIc" : "MODELES",
- "NbEcartType_MoyKIc_mess" : "MODELES",
- "PalierDuctile_KIc" : "MODELES",
- "CoefficientVariation_KIc" : "MODELES",
- "Fractile_KIc" : "MODELES",
- "Fractile_KIc_mess" : "MODELES",
- "Temperature_KIc100" : "MODELES",
- "A1" : "MODELES",
- "A2" : "MODELES",
- "A3" : "MODELES",
- "B1" : "MODELES",
- "B2" : "MODELES",
- "B3" : "MODELES",
- "C1" : "MODELES",
- "C2" : "MODELES",
- "C3" : "MODELES",
- "ChoixCorrectionLongueur" : "MODELES",
- "AttnCorrBeta" : "MODELES",
- "CorrIrwin" : "MODELES",
- "ArretDeFissure" : "MODELES",
- "IncrementTailleFissure" : "MODELES",
- "IncrementTailleFissure_mess" : "MODELES",
- "NbEcartType_MoyKIa" : "MODELES",
- "PalierDuctile_KIa" : "MODELES",
- "CoefficientVariation_KIa" : "MODELES",
- "ChoixCoefficientChargement" : "ETAT INITIAL",
- "CoefficientDuctile" : "ETAT INITIAL",
- "CoefficientFragile" : "ETAT INITIAL",
- "InstantInitialisation" : "ETAT INITIAL",
- "ConditionLimiteThermiqueREV" : "CARACTERISTIQUES DU REVETEMENT",
- "TemperatureDeformationNulleREV" : "CARACTERISTIQUES DU REVETEMENT",
- "TemperaturePourCoefDilatThermREV" : "CARACTERISTIQUES DU REVETEMENT",
- "CoefficientPoissonREV" : "CARACTERISTIQUES DU REVETEMENT",
- "ConditionLimiteThermiqueMDB" : "CARACTERISTIQUES DU MDB",
- "TemperatureDeformationNulleMDB" : "CARACTERISTIQUES DU MDB",
- "TemperaturePourCoefDilatThermMDB" : "CARACTERISTIQUES DU MDB",
- "CoefficientPoissonMDB" : "CARACTERISTIQUES DU MDB",
- "TypeConditionLimiteThermique" : "TRANSITOIRE",
- "Instant_1" : "TRANSITOIRE",
- "Instant_2" : "TRANSITOIRE",
- "Instant_3" : "TRANSITOIRE",
- "DebitAccumule" : "TRANSITOIRE",
- "DebitInjectionSecurite" : "TRANSITOIRE",
- "TempInjectionSecurite" : "TRANSITOIRE",
- "TempInjectionSecurite_mess" : "TRANSITOIRE",
- "DiametreHydraulique" : "TRANSITOIRE",
- "DiametreHydraulique_mess" : "TRANSITOIRE",
- "SectionEspaceAnnulaire" : "TRANSITOIRE",
- "SectionEspaceAnnulaire_mess" : "TRANSITOIRE",
- "HauteurCaracConvectionNaturelle" : "TRANSITOIRE",
- "HauteurCaracConvectionNaturelle_mess" : "TRANSITOIRE",
- "CritereConvergenceRelative" : "TRANSITOIRE",
- "CoefficientsVestale" : "TRANSITOIRE",
- "VolumeMelange_CREARE" : "TRANSITOIRE",
- "TemperatureInitiale_CREARE" : "TRANSITOIRE",
- "TemperatureInitiale_CREARE_mess" : "TRANSITOIRE",
- "SurfaceEchange_FluideStructure" : "TRANSITOIRE",
- "SurfaceEchange_FluideStructure_mess" : "TRANSITOIRE",
- "InstantPerteCirculationNaturelle" : "TRANSITOIRE",
- }
-
- def gener(self,obj,format='brut'):
- self.text=''
- self.textCuve=''
- self.texteTFDEBIT=''
- self.dico_mot={}
- self.dico_genea={}
- self.text=PythonGenerator.gener(self,obj,format)
- return self.text
-
- def generMCSIMP(self,obj) :
- self.dico_mot[obj.nom]=obj.valeur
- clef=""
- for i in obj.getGenealogie() :
- clef=clef+"_"+i
- self.dico_genea[clef]=obj.valeur
- s=PythonGenerator.generMCSIMP(self,obj)
- return s
-
- def writeCuve2DG(self, filename, file2):
- print "je passe dans writeCuve2DG"
- self.genereTexteCuve()
- f = open( filename, 'wb')
- print self.texteCuve
- f.write( self.texteCuve )
- f.close()
- ftmp = open( "/tmp/data_template", 'wb')
- ftmp.write( self.texteCuve )
- ftmp.close()
-
- self.genereTexteTFDEBIT()
- f2 = open( file2, 'wb')
- print self.texteTFDEBIT
- f2.write( self.texteTFDEBIT )
- f2.close()
-
-
- def entete(self):
- '''
- Ecrit l'entete du fichier data_template
- '''
- texte = "############################################################################################"+"\n"
- texte += "#"+"\n"
- texte += "# OUTIL D'ANALYSE PROBABILISTE DE LA DUREE DE VIE DES CUVES REP"+"\n"
- texte += "# ---------------"+"\n"
- texte += "# FICHIER DE MISE EN DONNEES"+"\n"
- texte += "#"+"\n"
- texte += "# SI CALCUL DETERMINISTE :"+"\n"
- texte += "# - fixer INCRTPS=1, nbectDRTNDT=2., nbectKIc=-2."+"\n"
- texte += "# - les calculs ne sont possibles qu'en une seule pointe du defaut (POINDEF<>BOTH)"+"\n"
- texte += "# SI CALCUL PROBABILISTE :"+"\n"
- texte += "# - fixer ARRETFISSURE=NON"+"\n"
- texte += "#"+"\n"
- texte += "############################################################################################"+"\n"
- texte += "#"+"\n"
- return texte
-
- def rubrique(self, titre):
- '''
- Rubrique
- '''
- texte = "#"+"\n"
- texte += "############################################################################################"+"\n"
- texte += "# " + titre + "\n"
- texte += "############################################################################################"+"\n"
- texte += "#"+"\n"
- return texte
-
- def sousRubrique(self, soustitre, numtitre):
- '''
- Sous-rubrique
- '''
- texte = "#"+"\n"
- texte += "# " + numtitre + soustitre + "\n"
- texte += "#==========================================================================================="+"\n"
- texte += "#"+"\n"
- return texte
-
- def ecritLigne(self, variablelue):
- '''
- Ecrit l'affectation d'une valeur a sa variable, suivie d'un commentaire
- '''
- texte = "%s = %s # %s\n" % (self.variable[variablelue], str(self.dico_mot[variablelue]), self.comment[variablelue])
- return texte
-
- def affecteValeurDefaut(self, variablelue):
- '''
- Affecte une valeur par defaut a une variable, suivie d'un commentaire
- '''
- print "Warning ==> Dans la rubrique",self.bloc[variablelue],", valeur par defaut pour ",variablelue," = ",self.default[variablelue]
- texte = "%s = %s # %s\n" % (self.variable[variablelue], self.default[variablelue], self.comment[variablelue])
- return texte
-
- def affecteValeur(self, variablelue, valeuraffectee):
- '''
- Affecte une valeur a une variable, suivie d'un commentaire
- '''
- texte = "%s = %s # %s\n" % (self.variable[variablelue], valeuraffectee, self.comment[variablelue])
- return texte
-
- def ecritVariable(self, variablelue):
- if self.dico_mot.has_key(variablelue):
- texte = self.ecritLigne(variablelue)
- else :
- texte = self.affecteValeurDefaut(variablelue)
- return texte
-
- def amontAval(self, amont, aval):
- if str(self.dico_mot[amont])=='Continu':
- if str(self.dico_mot[aval])=='Continu':
- texte = 'CC'+"\n"
- if str(self.dico_mot[aval])=='Lineaire':
- texte = 'CL'+"\n"
- if str(self.dico_mot[aval])=='Exclu':
- texte = 'CE'+"\n"
- if str(self.dico_mot[amont])=='Lineaire':
- if str(self.dico_mot[aval])=='Continu':
- texte = 'LC'+"\n"
- if str(self.dico_mot[aval])=='Lineaire':
- texte = 'LL'+"\n"
- if str(self.dico_mot[aval])=='Exclu':
- texte = 'LE'+"\n"
- if str(self.dico_mot[amont])=='Exclu':
- if str(self.dico_mot[aval])=='Continu':
- texte = 'EC'+"\n"
- if str(self.dico_mot[aval])=='Lineaire':
- texte = 'EL'+"\n"
- if str(self.dico_mot[aval])=='Exclu':
- texte = 'EE'+"\n"
- return texte
-
- def genereTexteCuve(self):
- self.texteCuve = ""
- self.texteCuve += self.entete()
-
- # Rubrique OPTIONS
- self.texteCuve += self.rubrique('OPTIONS')
-
- self.texteCuve += self.sousRubrique('Impression a l ecran', '')
- if self.dico_mot.has_key('NiveauImpression'):
- self.texteCuve += self.affecteValeur('NiveauImpression', self.valeurproposee[str(self.dico_mot["NiveauImpression"])])
-
- self.texteCuve += self.sousRubrique('Generation de fichiers', '')
- self.texteCuve += self.ecritVariable('FichierDataIn')
- self.texteCuve += self.ecritVariable('FichierTempSigma')
- self.texteCuve += self.ecritVariable('FichierCSV')
- self.texteCuve += self.ecritVariable('FichierRESTART')
- self.texteCuve += self.ecritVariable('FichierEXTR')
- self.texteCuve += self.ecritVariable('ChoixPlugin')
-
- self.texteCuve += self.sousRubrique('Grandeur evaluee', '')
- if self.dico_mot.has_key('GrandeurEvaluee'):
- self.texteCuve += self.affecteValeur('GrandeurEvaluee', self.valeurproposee[str(self.dico_mot["GrandeurEvaluee"])])
-
- self.texteCuve += self.sousRubrique('Divers', '')
- self.texteCuve += self.ecritVariable('IncrementTemporel')
- self.texteCuve += self.ecritVariable('IncrementMaxTemperature')
-
- #self.texteCuve += self.ecritVariable('ChoixExtractionTransitoires')
- if self.dico_mot.has_key('ChoixExtractionTransitoires'):
- self.texteCuve += self.ecritVariable('ChoixExtractionTransitoires')
- if str(self.dico_mot["ChoixExtractionTransitoires"])=='OUI':
- if self.dico_mot.has_key('ListeAbscisses'):
- self.texteCuve += "# liste des abscisses pour ecriture des transitoires de T et SIG (5 ou moins)"+"\n"
- self.imprime(1,(self.dico_mot["ListeAbscisses"]))
- self.texteCuve+="#"+"\n"
- else :
- print "Warning ==> Dans la rubrique OPTIONS, fournir ListeAbscisses."
- self.texteCuve += "# liste des abscisses pour ecriture des transitoires de T et SIG (5 ou moins)"+"\n"
- self.texteCuve += " 1.994\n"
- self.texteCuve += " 2.000\n"
- self.texteCuve+="#"+"\n"
- else :
- self.texteCuve+="#"+"\n"
-
- self.texteCuve += self.ecritVariable('IncrementMaxTempsAffichage')
- if self.dico_mot.has_key('ListeInstants'):
- self.texteCuve += "# liste des instants pour ecriture des resultats (s)"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- self.imprime(1,(self.dico_mot["ListeInstants"]))
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- self.texteCuve+="#"+"\n"
- else :
- print "Warning ==> Dans la rubrique OPTIONS, fournir ListeInstants."
- self.texteCuve += "# liste des instants pour ecriture des resultats (s)"+"\n"
- self.texteCuve += " 0.\n"
- self.texteCuve += " 1.\n"
- self.texteCuve+="#"+"\n"
-
-
- # Rubrique DONNEES DE LA CUVE
- self.texteCuve += self.rubrique('DONNEES DE LA CUVE')
- if self.dico_mot.has_key('traitementGeometrie'):
- self.texteCuve += self.affecteValeur('traitementGeometrie', self.valeurproposee[str(self.dico_mot["traitementGeometrie"])])
- if str(self.dico_mot["traitementGeometrie"])=='Topologie':
- self.texteCuve+="# - si MAILLAGE, fournir NBNO et liste des abscisses (m)"+"\n"
- self.texteCuve+="# - si GEOMETRIE, fournir (RINT, RINT_MESSAGE),"+"\n"
- self.texteCuve+="# (REXT, REXT_MESSAGE),"+"\n"
- self.texteCuve+="# (LREV, LREV_MESSAGE),"+"\n"
- self.texteCuve+="# (LIGMIN, LIGMIN_MESSAGE),"+"\n"
- self.texteCuve+="# NBNO"+"\n"
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('RayonInterne')
- self.texteCuve += self.ecritVariable('RayonInterne_mess')
- self.texteCuve += self.ecritVariable('RayonExterne')
- self.texteCuve += self.ecritVariable('RayonExterne_mess')
- self.texteCuve += self.ecritVariable('EpaisseurRevetement')
- self.texteCuve += self.ecritVariable('EpaisseurRevetement_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('LigamentExterneMin')
- self.texteCuve += self.ecritVariable('LigamentExterneMin_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('NombreNoeudsMaillage')
- if str(self.dico_mot["traitementGeometrie"])=='Maillage':
- self.texteCuve+="# - si MAILLAGE, fournir NBNO et liste des abscisses (m)"+"\n"
- self.texteCuve+="# - si GEOMETRIE, fournir (RINT, RINT_MESSAGE),"+"\n"
- self.texteCuve+="# (REXT, REXT_MESSAGE),"+"\n"
- self.texteCuve+="# (LREV, LREV_MESSAGE),"+"\n"
- self.texteCuve+="# (LIGMIN, LIGMIN_MESSAGE),"+"\n"
- self.texteCuve+="# NBNO"+"\n"
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('NombreNoeudsMaillage')
- self.imprime(1,(self.dico_mot["ListeAbscisses"]))
- else :
- self.texteCuve += self.affecteValeurDefaut('traitementGeometrie')
- self.texteCuve+="# - si MAILLAGE, fournir NBNO et liste des abscisses (m)"+"\n"
- self.texteCuve+="# - si GEOMETRIE, fournir (RINT, RINT_MESSAGE),"+"\n"
- self.texteCuve+="# (REXT, REXT_MESSAGE),"+"\n"
- self.texteCuve+="# (LREV, LREV_MESSAGE),"+"\n"
- self.texteCuve+="# (LIGMIN, LIGMIN_MESSAGE),"+"\n"
- self.texteCuve+="# NBNO"+"\n"
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.affecteValeurDefaut('RayonInterne')
- self.texteCuve += self.affecteValeurDefaut('RayonInterne_mess')
- self.texteCuve += self.affecteValeurDefaut('RayonExterne')
- self.texteCuve += self.affecteValeurDefaut('RayonExterne_mess')
- self.texteCuve += self.affecteValeurDefaut('EpaisseurRevetement')
- self.texteCuve += self.affecteValeurDefaut('EpaisseurRevetement_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.affecteValeurDefaut('LigamentExterneMin')
- self.texteCuve += self.affecteValeurDefaut('LigamentExterneMin_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.affecteValeurDefaut('NombreNoeudsMaillage')
-
-
- # Rubrique CARACTERISTIQUES DU DEFAUT
- self.texteCuve += self.rubrique('CARACTERISTIQUES DU DEFAUT')
-
- if self.dico_mot.has_key('TypeInitial'):
- self.texteCuve += self.affecteValeur('TypeInitial', self.valeurproposee[str(self.dico_mot["TypeInitial"])])
- else :
- self.texteCuve += self.affecteValeurDefaut('TypeInitial')
-
- self.texteCuve+="# Fournir ORIEDEF, (PROFDEF, PROFDEF_MESSAGE)"+"\n"
- self.texteCuve+="# - Si DSR, fournir OPTLONG, (LONGDEF,LONGDEF_MESSAGE) ou (PROFSURLONG,PROFSURLONG_MESSAGE,LONGCONST)"+"\n"
- self.texteCuve+="# - Si DECALE, fournir OPTLONG, (LONGDEF,LONGDEF_MESSAGE) ou (PROFSURLONG,PROFSURLONG_MESSAGE,LONGCONST), DECATYP, (DECANOR,DECANOR_MESSAGE) ou (DECADEF,DECADEF_MESSAGE)"+"\n"
- self.texteCuve+="# - Si DEBOUCHANT, fournir IRWIN"+"\n"
- self.texteCuve+="# Fournir (ANGLDEF, ANGLDEF_MESSAGE), (ALTIDEF, ALTIDEF_MESSAGE)"+"\n"
- self.texteCuve+="# - Si DSR ou DECALE, fournir POINDEF"+"\n"
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Remarque :"+"\n"
- self.texteCuve+="# - si DSR ou DECALE, dans la rubrique 'Modele de tenacite', fournir ATTNCORRBETA (ne pas fournir CORRIRWIN)"+"\n"
- self.texteCuve+="# - si DEBOUCHANT, dans la rubrique 'Modele de tenacite', fournir CORRIRWIN (ne pas fournir ATTNCORRBETA)"+"\n"
-
- self.texteCuve+="#"+"\n"
-
- if self.dico_mot.has_key('Orientation'):
- self.texteCuve += self.affecteValeur('Orientation', self.valeurproposee[str(self.dico_mot["Orientation"])])
- else :
- self.texteCuve += self.affecteValeurDefaut('Orientation')
-
- if self.dico_mot.has_key('Position'):
- self.texteCuve += self.affecteValeur('Position', self.valeurproposee[str(self.dico_mot["Position"])])
- else :
- self.texteCuve += self.affecteValeurDefaut('Position')
-
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('ProfondeurRadiale')
- self.texteCuve += self.ecritVariable('ProfondeurRadiale_mess')
-
- self.texteCuve+="#"+"\n"
- if self.dico_mot.has_key('TypeInitial'):
- if str(self.dico_mot["TypeInitial"])!='Defaut Debouchant':
- if self.dico_mot.has_key('ModeCalculLongueur'):
- self.texteCuve += self.affecteValeur('ModeCalculLongueur', self.valeurproposee[str(self.dico_mot["ModeCalculLongueur"])])
- if str(self.dico_mot["ModeCalculLongueur"])=='Valeur':
- self.texteCuve+="# - Si VALEUR, fournir (LONGDEF, LONGDEF_MESSAGE)"+"\n"
- self.texteCuve+="# - Si FCTAFFINE, fournir (PROFSURLONG, PROFSURLONG_MESSAGE) et LONGCONST : LONGDEF=PROFDEF/PROFSURLONG + LONGCONST"+"\n"
- self.texteCuve += self.ecritVariable('Longueur')
- self.texteCuve += self.ecritVariable('Longueur_mess')
- if str(self.dico_mot["ModeCalculLongueur"])=='Fonction affine de la profondeur':
- self.texteCuve+="# - Si VALEUR, fournir (LONGDEF, LONGDEF_MESSAGE)"+"\n"
- self.texteCuve+="# - Si FCTAFFINE, fournir (PROFSURLONG, PROFSURLONG_MESSAGE) et LONGCONST : LONGDEF=PROFDEF/PROFSURLONG + LONGCONST"+"\n"
- self.texteCuve += self.ecritVariable('CoefDirecteur')
- self.texteCuve += self.ecritVariable('CoefDirecteur_mess')
- self.texteCuve += self.ecritVariable('Constante')
- else :
- self.texteCuve += self.affecteValeurDefaut('ModeCalculLongueur')
- self.texteCuve+="# - Si VALEUR, fournir (LONGDEF, LONGDEF_MESSAGE)"+"\n"
- self.texteCuve+="# - Si FCTAFFINE, fournir (PROFSURLONG, PROFSURLONG_MESSAGE) et LONGCONST : LONGDEF=PROFDEF/PROFSURLONG + LONGCONST"+"\n"
- self.texteCuve += self.affecteValeurDefaut('Longueur')
- self.texteCuve += self.affecteValeurDefaut('Longueur_mess')
-
- if self.dico_mot.has_key('TypeInitial'):
- if str(self.dico_mot["TypeInitial"])=='Defaut Decale':
- self.texteCuve+="#"+"\n"
- if self.dico_mot.has_key('ModeCalculDecalage'):
- self.texteCuve += self.affecteValeur('ModeCalculDecalage', self.valeurproposee[str(self.dico_mot["ModeCalculDecalage"])])
- if str(self.dico_mot["ModeCalculDecalage"])=='Valeur normalisee':
- self.texteCuve+="# - Si NORMALISE, fournir (DECANOR, DECANOR_MESSAGE)"+"\n"
- self.texteCuve+="# - Si VALEUR, fournir (DECADEF, DECADEF_MESSAGE)"+"\n"
- self.texteCuve += self.ecritVariable('DecalageNormalise')
- self.texteCuve += self.ecritVariable('DecalageNormalise_mess')
- if str(self.dico_mot["ModeCalculDecalage"])=='Valeur':
- self.texteCuve+="# - Si NORMALISE, fournir (DECANOR, DECANOR_MESSAGE)"+"\n"
- self.texteCuve+="# - Si VALEUR, fournir (DECADEF, DECADEF_MESSAGE)"+"\n"
- self.texteCuve += self.ecritVariable('DecalageRadial')
- self.texteCuve += self.ecritVariable('DecalageRadial_mess')
- else :
- self.texteCuve += self.affecteValeurDefaut('ModeCalculDecalage')
- self.texteCuve+="# - Si NORMALISE, fournir (DECANOR, DECANOR_MESSAGE)"+"\n"
- self.texteCuve+="# - Si VALEUR, fournir (DECADEF, DECADEF_MESSAGE)"+"\n"
- self.texteCuve += self.affecteValeurDefaut('DecalageRadial')
- self.texteCuve += self.affecteValeurDefaut('DecalageRadial_mess')
-
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('Azimut')
- self.texteCuve += self.ecritVariable('Azimut_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('Altitude')
- self.texteCuve += self.ecritVariable('Altitude_mess')
- self.texteCuve+="#"+"\n"
- if self.dico_mot.has_key('Pointe'):
- self.texteCuve += self.affecteValeur('Pointe', self.valeurproposee[str(self.dico_mot["Pointe"])])
- #else :
- # self.texteCuve += self.affecteValeurDefaut('Pointe')
-
- # Rubrique MODELES FLUENCE, IRRADIATION, TENACITE
- self.texteCuve += self.rubrique('MODELES FLUENCE, IRRADIATION, TENACITE')
- self.texteCuve += self.sousRubrique('Modele d attenuation de la fluence dans l epaisseur','A.')
-
- if self.dico_mot.has_key('ModeleFluence'):
- self.texteCuve += self.affecteValeur('ModeleFluence', self.valeurproposee[str(self.dico_mot["ModeleFluence"])])
- else :
- self.texteCuve += self.affecteValeurDefaut('ModeleFluence')
-
- self.texteCuve+="# - si France, fournir KPFRANCE"+"\n"
- self.texteCuve+="# - si USNRC, fournir KPUS"+"\n"
- self.texteCuve+="# - si modele GD_Cuve, fournir COEFFLUENCE1, COEFFLUENCE2, ..., COEFFLUENCE9, COEFFLUENCE10"+"\n"
- self.texteCuve+="#"+"\n"
-
- self.texteCuve += self.ecritVariable('ZoneActiveCoeur_AltitudeSup')
- self.texteCuve += self.ecritVariable('ZoneActiveCoeur_AltitudeInf')
- self.texteCuve += self.ecritVariable('FluenceMax')
- if self.dico_mot.has_key('ModeleFluence'):
- if str(self.dico_mot["ModeleFluence"])=='Exponentiel sans revetement k=12.7 (France)':
- self.texteCuve += self.ecritVariable('KPFrance')
- if str(self.dico_mot["ModeleFluence"])=='Regulatory Guide 1.99 rev 2 (USNRC)':
- self.texteCuve += self.ecritVariable('KPUS')
- if str(self.dico_mot["ModeleFluence"])=='Grand developpement (GD_Cuve)':
- self.texteCuve += self.ecritVariable('Azimut_0deg')
- self.texteCuve += self.ecritVariable('Azimut_5deg')
- self.texteCuve += self.ecritVariable('Azimut_10deg')
- self.texteCuve += self.ecritVariable('Azimut_15deg')
- self.texteCuve += self.ecritVariable('Azimut_20deg')
- self.texteCuve += self.ecritVariable('Azimut_25deg')
- self.texteCuve += self.ecritVariable('Azimut_30deg')
- self.texteCuve += self.ecritVariable('Azimut_35deg')
- self.texteCuve += self.ecritVariable('Azimut_40deg')
- self.texteCuve += self.ecritVariable('Azimut_45deg')
-
- self.texteCuve += self.sousRubrique('Irradiation','B.')
-
- if self.dico_mot.has_key('TypeIrradiation'):
- self.texteCuve += self.affecteValeur('TypeIrradiation', self.valeurproposee[str(self.dico_mot["TypeIrradiation"])])
-
- if str(self.dico_mot["TypeIrradiation"])=='RTndt de la cuve a l instant de l analyse':
- self.texteCuve+="# - si RTNDT, fournir RTNDT"+"\n"
- self.texteCuve+="# - si FLUENCE, fournir MODELIRR, et autres parametres selon MODELIRR (voir ci-dessous)"+"\n"
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('RTNDT')
-
- if str(self.dico_mot["TypeIrradiation"])=='Modele d irradiation':
- self.texteCuve+="# - si RTNDT, fournir RTNDT"+"\n"
- self.texteCuve+="# - si FLUENCE, fournir MODELIRR, et autres parametres selon MODELIRR (voir ci-dessous)"+"\n"
- self.texteCuve+="#"+"\n"
- if self.dico_mot.has_key('ModeleIrradiation'):
- self.texteCuve += self.affecteValeur('ModeleIrradiation', self.valeurproposee[str(self.dico_mot["ModeleIrradiation"])])
- else :
- self.texteCuve += self.affecteValeurDefaut('ModeleIrradiation')
- self.texteCuve+="# - pour tout modele, fournir (CU, CU_MESSAGE),"+"\n"
- self.texteCuve+="# (NI, NI_MESSAGE),"+"\n"
- self.texteCuve+="# - si HOUSSIN, PERSOZ, LEFEBVRE, BRILLAUD, LEFEBnew, fournir (P, P_MESSAGE)"+"\n"
- self.texteCuve+="# - pour tout modele, fournir (RTimoy, RTimoy_MESSAGE),"+"\n"
- self.texteCuve+="# - si USNRCsoud ou USNRCmdb, fournir (RTicov, RTicov_MESSAGE)"+"\n"
- self.texteCuve+="# (USectDRT, USectDRT_MESSAGE)"+"\n"
- self.texteCuve+="# - pour tout modele, fournir (nbectDRTNDT, nbectDRTNDT_MESSAGE)"+"\n"
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('TeneurCuivre')
- self.texteCuve += self.ecritVariable('TeneurCuivre_mess')
- self.texteCuve += self.ecritVariable('TeneurNickel')
- self.texteCuve += self.ecritVariable('TeneurNickel_mess')
- if str(self.dico_mot["ModeleIrradiation"])=='Metal de Base : formule de FIM/FIS Houssin' or str(self.dico_mot["ModeleIrradiation"])=='Metal de Base : formule de FIM/FIS Persoz' or str(self.dico_mot["ModeleIrradiation"])=='Metal de Base : formule de FIM/FIS Lefebvre' or str(self.dico_mot["ModeleIrradiation"])=='Joint Soude : formulation de FIM/FIS Brillaud' or str(self.dico_mot["ModeleIrradiation"])=='Formule de FIM/FIS Lefebvre modifiee':
- self.texteCuve += self.ecritVariable('TeneurPhosphore')
- self.texteCuve += self.ecritVariable('TeneurPhosphore_mess')
- self.texteCuve += self.ecritVariable('MoyenneRTndt')
- self.texteCuve += self.ecritVariable('MoyenneRTndt_mess')
- if str(self.dico_mot["ModeleIrradiation"])=='Metal de Base : Regulatory Guide 1.00 rev 2' or str(self.dico_mot["ModeleIrradiation"])=='Joint Soude : Regulatory Guide 1.00 rev 2':
- self.texteCuve += self.ecritVariable('CoefVariationRTndt')
- self.texteCuve += self.ecritVariable('CoefVariationRTndt_mess')
- self.texteCuve += self.ecritVariable('EcartTypeRTndt')
- self.texteCuve += self.ecritVariable('EcartTypeRTndt_mess')
- self.texteCuve += self.ecritVariable('NombreEcartTypeRTndt')
- self.texteCuve += self.ecritVariable('NombreEcartTypeRTndt_mess')
- else :
- self.texteCuve += self.affecteValeurDefaut('TypeIrradiation')
- self.texteCuve+="# - si RTNDT, fournir RTNDT"+"\n"
- self.texteCuve+="# - si FLUENCE, fournir MODELIRR, et autres parametres selon MODELIRR (voir ci-dessous)"+"\n"
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.affecteValeurDefaut('RTNDT')
-
- self.texteCuve += self.sousRubrique('Modele de tenacite','C.')
- self.texteCuve+="# tenacite d amorcage"+"\n"
-
- if self.dico_mot.has_key('ModeleTenacite'):
- self.texteCuve += self.affecteValeur('ModeleTenacite', self.valeurproposee[str(self.dico_mot["ModeleTenacite"])])
- else :
- self.texteCuve += self.affecteValeurDefaut('ModeleTenacite')
- self.texteCuve+="# - si RCC-M, RCC-M_pal, Houssin_RC, fournir (nbectKIc, nbectKIc_MESSAGE), KICPAL, KICCDV"+"\n"
- self.texteCuve+="# - si RCC-M_exp, fournir (nbectKIc, nbectKIc_MESSAGE), KICCDV"+"\n"
- self.texteCuve+="# - si RCC-M_simpl, ne rien fournir"+"\n"
- self.texteCuve+="# - si Frama, LOGWOLF, fournir (nbectKIc, nbectKIc_MESSAGE)"+"\n"
- self.texteCuve+="# - si REME, ORNL, WEIB3, WEIB2, fournir NBCARAC, puis (nbectKIc, nbectKIc_MESSAGE) ou (fractKIc, fractKIc_MESSAGE) selon valeur de NBCARAC"+"\n"
- self.texteCuve+="# - si Wallin, fournir NBCARAC, puis (nbectKIc, nbectKIc_MESSAGE) ou (fractKIc, fractKIc_MESSAGE) selon valeur de NBCARAC,"+"\n"
- self.texteCuve+="# puis T0WALLIN"+"\n"
- self.texteCuve+="# - si WEIB-GEN, fournir NBCARAC, puis (nbectKIc, nbectKIc_MESSAGE) ou (fractKIc, fractKIc_MESSAGE) selon valeur de NBCARAC,"+"\n"
- self.texteCuve+="# puis A1, A2, A3, B1, B2, B3, C1, C2, C3"+"\n"
- self.texteCuve+="# loi de Weibull P(K<x) = 1 - exp{-[ (x-a(T)) / b(T) ]^c(T) }"+"\n"
- self.texteCuve+="# avec a(T) = A1 + A2*exp[A3*(T-RTNDT)]"+"\n"
- self.texteCuve+="# b(T) = B1 + B2*exp[B3*(T-RTNDT)]"+"\n"
- self.texteCuve+="# c(T) = C1 + C2*exp[C3*(T-RTNDT)]"+"\n"
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Correction de la longueur"+"\n"
- self.texteCuve += self.ecritVariable('ChoixCorrectionLongueur')
- self.texteCuve+="#"+"\n"
- if self.dico_mot.has_key('ModeleTenacite'):
- if str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve' or str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve (REME)' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb01 (etude ORNL)' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb03' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb02' or str(self.dico_mot["ModeleTenacite"])=='Weibull generalisee' :
- if self.dico_mot.has_key('NombreCaracteristique'):
- self.texteCuve += self.affecteValeur('NombreCaracteristique', self.valeurproposee[str(self.dico_mot["NombreCaracteristique"])])
- else :
- self.texteCuve += self.affecteValeurDefaut('NombreCaracteristique')
- self.texteCuve+="# - Si NBCARAC = QUANTILE, fournir (nbectKIc, nbectKIc_MESSAGE)"+"\n"
- self.texteCuve+="# - Si NBCARAC = ORDRE, fournir (fractKIc, fractKIc_MESSAGE)"+"\n"
-
- if str(self.dico_mot["ModeleTenacite"])=='RCC-M/ASME coefficient=2' or str(self.dico_mot["ModeleTenacite"])=='RCC-M/ASME avec KI=KIpalier' or str(self.dico_mot["ModeleTenacite"])=='RCC-M/ASME coefficient=2.33 (Houssin)' :
- self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc')
- self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc_mess')
- self.texteCuve += self.ecritVariable('PalierDuctile_KIc')
- self.texteCuve += self.ecritVariable('CoefficientVariation_KIc')
-
- if str(self.dico_mot["ModeleTenacite"])=='Exponentielle n\xb01 (Frama)' or str(self.dico_mot["ModeleTenacite"])=='Exponentielle n\xb02 (LOGWOLF)' :
- self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc')
- self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc_mess')
-
- if str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve (REME)' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb01 (etude ORNL)' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb03' or str(self.dico_mot["ModeleTenacite"])=='Weibull n\xb02' or str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve' or str(self.dico_mot["ModeleTenacite"])=='Weibull generalisee':
- if str(self.dico_mot["NombreCaracteristique"])=='Quantile' :
- self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc')
- self.texteCuve += self.ecritVariable('NbEcartType_MoyKIc_mess')
- if str(self.dico_mot["NombreCaracteristique"])=='Ordre' :
- self.texteCuve += self.ecritVariable('Fractile_KIc')
- self.texteCuve += self.ecritVariable('Fractile_KIc_mess')
-
- if str(self.dico_mot["ModeleTenacite"])=='Weibull basee sur la master cuve' :
- self.texteCuve += self.ecritVariable('Temperature_KIc100')
-
- if str(self.dico_mot["ModeleTenacite"])=='Weibull generalisee' :
- self.texteCuve += self.ecritVariable('A1')
- self.texteCuve += self.ecritVariable('A2')
- self.texteCuve += self.ecritVariable('A3')
- self.texteCuve += self.ecritVariable('B1')
- self.texteCuve += self.ecritVariable('B2')
- self.texteCuve += self.ecritVariable('B3')
- self.texteCuve += self.ecritVariable('C1')
- self.texteCuve += self.ecritVariable('C2')
- self.texteCuve += self.ecritVariable('C3')
- else :
- self.texteCuve += self.affecteValeurDefaut('NbEcartType_MoyKIc')
- self.texteCuve += self.affecteValeurDefaut('NbEcartType_MoyKIc_mess')
- self.texteCuve += self.affecteValeurDefaut('PalierDuctile_KIc')
- self.texteCuve += self.affecteValeurDefaut('CoefficientVariation_KIc')
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Correction plastique"+"\n"
-
- #DTV if self.dico_mot.has_key('TypeInitial'):
- #DTV if str(self.dico_mot["TypeInitial"])!='Defaut Debouchant':
- if self.dico_mot.has_key('CorrectionPlastique'):
- if str(self.dico_mot["CorrectionPlastique"])=='Correction plastique BETA (pour DSR et defaut decale)':
- self.texteCuve += self.affecteValeur('AttnCorrBeta','NON')
- if str(self.dico_mot["CorrectionPlastique"])=='Correction plastique BETA attenuee (pour DSR et defaut decale)':
- self.texteCuve += self.affecteValeur('AttnCorrBeta','OUI')
- if str(self.dico_mot["CorrectionPlastique"])=='Correction plastique IRWIN (pour defaut debouchant)':
- self.texteCuve += self.affecteValeur('CorrIrwin','OUI')
- else :
- self.texteCuve += self.affecteValeurDefaut('AttnCorrBeta')
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Prise en compte de l'arret de fissure si DETERMINISTE"+"\n"
-
- self.texteCuve += self.ecritVariable('ArretDeFissure')
- self.texteCuve+="# - si ARRETFISSURE=OUI, fournir (INCRDEF, INCRDEF_MESSAGE), nbectKIa, KIAPAL, KIACDV"+"\n"
- if self.dico_mot.has_key('ArretDeFissure'):
- if str(self.dico_mot["ArretDeFissure"])=='OUI':
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('IncrementTailleFissure')
- self.texteCuve += self.ecritVariable('IncrementTailleFissure_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Parametres pour le calcul de la tenacite a l arret"+"\n"
- self.texteCuve += self.ecritVariable('NbEcartType_MoyKIa')
- self.texteCuve += self.ecritVariable('PalierDuctile_KIa')
- self.texteCuve += self.ecritVariable('CoefficientVariation_KIa')
-
- # Rubrique Etat initial
- self.texteCuve += self.rubrique('ETAT INITIAL')
-
- self.texteCuve+="# Profil radial de la temperature initiale dans la cuve"+"\n"
- self.texteCuve+="# abscisse (m) / temp initiale dans la cuve"+"\n"
- self.texteCuve+="# Prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- if self.dico_mot.has_key('ProfilRadial_TemperatureInitiale'):
- self.imprime(2,(self.dico_mot["ProfilRadial_TemperatureInitiale"]))
- self.texteCuve += self.amontAval('Amont_TemperatureInitiale','Aval_TemperatureInitiale')
- else :
- self.texteCuve+=" 1.9940 287."+"\n"
- self.texteCuve+="CC"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Profils radiaux des contraintes residuelles dans la cuve"+"\n"
- self.texteCuve+="# abscisse (m) / sigma rr / sigma tt / sigma zz"+"\n"
- self.texteCuve+="# Prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
- if self.dico_mot.has_key('ProfilRadial_ContraintesInitiales'):
- self.imprime(4,(self.dico_mot["ProfilRadial_ContraintesInitiales"]))
- self.texteCuve += self.amontAval('Amont_ContraintesInitiales','Aval_ContraintesInitiales')
- else :
- self.texteCuve+="1.994 0. 0. 0."+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Prise en compte de coefficients sur les contraintes"+"\n"
- self.texteCuve += self.ecritVariable('ChoixCoefficientChargement')
- if str(self.dico_mot["ChoixCoefficientChargement"])=='OUI':
- self.texteCuve += self.ecritVariable('CoefficientDuctile')
- self.texteCuve += self.ecritVariable('CoefficientFragile')
- else :
- self.texteCuve+="#"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Instant initial"+"\n"
- self.texteCuve += self.ecritVariable('InstantInitialisation')
-
- # Rubrique CARACTERISTIQUES DU REVETEMENT
- self.texteCuve += self.rubrique('CARACTERISTIQUES DU REVETEMENT')
-
- if self.dico_mot.has_key('ConditionLimiteThermiqueREV'):
- self.texteCuve += self.affecteValeur('ConditionLimiteThermiqueREV', self.valeurproposee[str(self.dico_mot["ConditionLimiteThermiqueREV"])])
- else :
- self.texteCuve += self.affecteValeurDefaut('ConditionLimiteThermiqueREV')
- self.texteCuve+="# - si CHALEUR, fournir Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
- self.texteCuve+="# - si ENTHALPIE, fournir Temperature (degC) / enthalpie (J/kg)"+"\n"
- self.texteCuve+="# Finir chacune des listes par la prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
- self.texteCuve+="#"+"\n"
- if self.dico_mot.has_key('ChaleurREV_Fct_Temperature'):
- self.texteCuve+="# Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
- self.imprime(2,(self.dico_mot["ChaleurREV_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_ChaleurREV','Aval_ChaleurREV')
- elif self.dico_mot.has_key('EnthalpieREV_Fct_Temperature'):
- self.texteCuve+="# Temperature (degC) / enthalpie (J/kg)"+"\n"
- self.imprime(2,(self.dico_mot["EnthalpieREV_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_EnthalpieREV','Aval_EnthalpieREV')
- else :
- self.texteCuve+="# Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
- self.texteCuve+="0. 36.03E5 "+"\n"
- self.texteCuve+="20. 36.03E5 "+"\n"
- self.texteCuve+="200. 41.65E5 "+"\n"
- self.texteCuve+="350. 43.47E5 "+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Temperature (degC) / conductivite thermique (W/m/degC)"+"\n"
- if self.dico_mot.has_key('ConductiviteREV_Fct_Temperature'):
- self.imprime(2,(self.dico_mot["ConductiviteREV_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_ConductiviteREV','Aval_ConductiviteREV')
- else :
- self.texteCuve+="0. 14.7 "+"\n"
- self.texteCuve+="20. 14.7 "+"\n"
- self.texteCuve+="200. 17.2 "+"\n"
- self.texteCuve+="350. 19.3 "+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Temperature (degC) / module d'Young (MPa)"+"\n"
- if self.dico_mot.has_key('ModuleYoungREV_Fct_Temperature'):
- self.imprime(2,(self.dico_mot["ModuleYoungREV_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_ModuleYoungREV','Aval_ModuleYoungREV')
- else :
- self.texteCuve+="0. 198500. "+"\n"
- self.texteCuve+="20. 197000. "+"\n"
- self.texteCuve+="200. 184000. "+"\n"
- self.texteCuve+="350. 172000. "+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Temperature (degC) / coefficient de dilatation thermique (degC-1)"+"\n"
- if self.dico_mot.has_key('CoeffDilatThermREV_Fct_Temperature'):
- self.imprime(2,(self.dico_mot["CoeffDilatThermREV_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_CoeffDilatThermREV','Aval_CoeffDilatThermREV')
- else :
- self.texteCuve+="0. 16.40E-6 "+"\n"
- self.texteCuve+="20. 16.40E-6 "+"\n"
- self.texteCuve+="200. 17.20E-6 "+"\n"
- self.texteCuve+="350. 17.77E-6 "+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Temperature (degC) / limite d'elasticite (MPa)"+"\n"
- if self.dico_mot.has_key('LimiteElasticiteREV_Fct_Temperature'):
- self.imprime(2,(self.dico_mot["LimiteElasticiteREV_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_LimiteElasticiteREV','Aval_LimiteElasticiteREV')
- else :
- self.texteCuve+="0. 380. "+"\n"
- self.texteCuve+="20. 370. "+"\n"
- self.texteCuve+="100. 330. "+"\n"
- self.texteCuve+="300. 270. "+"\n"
- self.texteCuve+="LL"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('TemperatureDeformationNulleREV')
- self.texteCuve += self.ecritVariable('TemperaturePourCoefDilatThermREV')
- self.texteCuve += self.ecritVariable('CoefficientPoissonREV')
-
- # Rubrique CARACTERISTIQUES DU METAL DE BASE
- self.texteCuve += self.rubrique('CARACTERISTIQUES DU METAL DE BASE')
-
- if self.dico_mot.has_key('ConditionLimiteThermiqueMDB'):
- self.texteCuve += self.affecteValeur('ConditionLimiteThermiqueMDB', self.valeurproposee[str(self.dico_mot["ConditionLimiteThermiqueMDB"])])
- else :
- self.texteCuve += self.affecteValeurDefaut('ConditionLimiteThermiqueMDB')
-
- self.texteCuve+="# - si CHALEUR, fournir Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
- self.texteCuve+="# - si ENTHALPIE, fournir Temperature (degC) / enthalpie (J/kg)"+"\n"
- self.texteCuve+="# Finir chacune des listes par la prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
- self.texteCuve+="#"+"\n"
-
- if self.dico_mot.has_key('ChaleurMDB_Fct_Temperature'):
- self.texteCuve+="# Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
- self.imprime(2,(self.dico_mot["ChaleurMDB_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_ChaleurMDB','Aval_ChaleurMDB')
- elif self.dico_mot.has_key('EnthalpieMDB_Fct_Temperature'):
- self.texteCuve+="# Temperature (degC) / enthalpie (J/kg)"+"\n"
- self.imprime(2,(self.dico_mot["EnthalpieMDB_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_EnthalpieMDB','Aval_EnthalpieMDB')
- else :
- self.texteCuve+="# Temperature (degC) / chaleur volumique (J/kg/K)"+"\n"
- self.texteCuve+="0. 34.88E+05 "+"\n"
- self.texteCuve+="20. 34.88E+05 "+"\n"
- self.texteCuve+="200. 40.87E+05 "+"\n"
- self.texteCuve+="350. 46.02E+05 "+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Temperature (degC) / conductivite thermique (W/m/degC)"+"\n"
- if self.dico_mot.has_key('ConductiviteMDB_Fct_Temperature'):
- self.imprime(2,(self.dico_mot["ConductiviteMDB_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_ConductiviteMDB','Aval_ConductiviteMDB')
- else :
- self.texteCuve+="0. 37.7 "+"\n"
- self.texteCuve+="20. 37.7 "+"\n"
- self.texteCuve+="200. 40.5 "+"\n"
- self.texteCuve+="350. 38.7 "+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Temperature (degC) / module d'Young (MPa)"+"\n"
- if self.dico_mot.has_key('ModuleYoungMDB_Fct_Temperature'):
- self.imprime(2,(self.dico_mot["ModuleYoungMDB_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Aval_ModuleYoungMDB','Aval_ModuleYoungMDB')
- else :
- self.texteCuve+="0. 205000. "+"\n"
- self.texteCuve+="20. 204000. "+"\n"
- self.texteCuve+="200. 193000. "+"\n"
- self.texteCuve+="350. 180000. "+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Temperature (degC) / coefficient de dilatation thermique (degC-1)"+"\n"
- if self.dico_mot.has_key('CoeffDilatThermMDB_Fct_Temperature'):
- self.imprime(2,(self.dico_mot["CoeffDilatThermMDB_Fct_Temperature"]))
- self.texteCuve += self.amontAval('Amont_CoeffDilatThermMDB','Aval_CoeffDilatThermMDB')
- else :
- self.texteCuve+="0. 11.22E-6 "+"\n"
- self.texteCuve+="20. 11.22E-6 "+"\n"
- self.texteCuve+="200. 12.47E-6 "+"\n"
- self.texteCuve+="350. 13.08E-6 "+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('TemperatureDeformationNulleMDB')
- self.texteCuve += self.ecritVariable('TemperaturePourCoefDilatThermMDB')
- self.texteCuve += self.ecritVariable('CoefficientPoissonMDB')
-
- # Rubrique CARACTERISTIQUES DU TRANSITOIRE MECANIQUE-THERMOHYDRAULIQUE
- self.texteCuve += self.rubrique('CARACTERISTIQUES DU TRANSITOIRE MECANIQUE-THERMOHYDRAULIQUE')
- self.texteCuve += self.sousRubrique('Chargement mecanique : transitoire de pression','')
-
- self.texteCuve+="# instant (s) / pression (MPa)"+"\n"
- self.texteCuve+="# Prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- if self.dico_mot.has_key('ProfilTemporel_Pression'):
- self.imprime(2,(self.dico_mot["ProfilTemporel_Pression"]))
- self.texteCuve += self.amontAval('Amont_Pression','Aval_Pression')
- else :
- self.texteCuve+="0. 15.5 "+"\n"
- self.texteCuve+="20. 0.1 "+"\n"
- self.texteCuve+="200. 0.1 "+"\n"
- self.texteCuve+="1000. 0.1 "+"\n"
- self.texteCuve+="CC"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
-
- self.texteCuve += self.sousRubrique('Chargement thermo-hydraulique','')
- if self.dico_mot.has_key('TypeConditionLimiteThermique'):
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- self.texteCuve += self.affecteValeur('TypeConditionLimiteThermique', self.valeurproposee[str(self.dico_mot["TypeConditionLimiteThermique"])])
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- else :
- self.texteCuve += self.affecteValeurDefaut('TypeConditionLimiteThermique')
-
- self.texteCuve+="# - si TEMP_IMPO, fournir Instant (s) / Temperature imposee (degC)"+"\n"
- self.texteCuve+="# - si FLUX_REP, fournir Instant (s) / Flux de chaleur impose (W/m2)"+"\n"
- self.texteCuve+="# - si ECHANGE, fournir Instant (s) / Temperature impose (degC)"+"\n"
- self.texteCuve+="# puis Instant (s) / Coefficient d echange (W/m2/K)"+"\n"
- self.texteCuve+="# - si DEBIT, fournir Instant (s) / Debit massique (kg/s)"+"\n"
- self.texteCuve+="# puis Instant (s) / Temperature d injection de securite (degC)"+"\n"
- self.texteCuve+="# puis Modele VESTALE : (DH, DH_MESSAGE), (SECTION, SECTION_MESSAGE), (DELTA, DELTA_MESSAGE), EPS, COEFVESTALE"+"\n"
- self.texteCuve+="# puis Modele CREARE : "+"\n"
- self.texteCuve+="# Instants(s) / Volume de melange CREARE (m3)"+"\n"
- self.texteCuve+="# puis (T0, T0_MESSAGE), (SE, SE_MESSAGE)"+"\n"
- self.texteCuve+="# - si TEMP_FLU, fournir Instant (s) / Temperature du fluide (degC)"+"\n"
- self.texteCuve+="# puis Instant (s) / Debit d injection de securite (kg/s)"+"\n"
- self.texteCuve+="# puis Modele VESTALE : (DH, DH_MESSAGE), (SECTION, SECTION_MESSAGE), (DELTA, DELTA_MESSAGE), EPS, COEFVESTALE"+"\n"
- self.texteCuve+="# - si TFDEBIT, fournir INST_PCN et TIS"+"\n"
- self.texteCuve+="# fournir Instant (s) / Temperature du fluide (degC)"+"\n"
- self.texteCuve+="# puis Instant (s) / Debit d injection de securite (kg/s)"+"\n"
- self.texteCuve+="# puis Modele VESTALE : (DH, DH_MESSAGE), (SECTION, SECTION_MESSAGE), (DELTA, DELTA_MESSAGE), EPS, COEFVESTALE"+"\n"
- self.texteCuve+="# puis Modele CREARE : "+"\n"
- self.texteCuve+="# Instants(s) / Volume de melange CREARE (m3)"+"\n"
- self.texteCuve+="# puis (T0, T0_MESSAGE), (SE, SE_MESSAGE)"+"\n"
- self.texteCuve+="# - si APRP, fournir INSTANT1, INSTANT2, INSTANT3, QACCU, QIS, (TIS, TIS_MESSAGE)"+"\n"
- self.texteCuve+="# puis Instant (s) / Temperature du fluide (degC) tel que dans l'exemple ci-dessous"+"\n"
- self.texteCuve+="# 0. 286."+"\n"
- self.texteCuve+="# 12. 20. # 1er palier à T=TACCU"+"\n"
- self.texteCuve+="# 20. 20. # idem que ci-dessus : T=TACCU"+"\n"
- self.texteCuve+="# 21. 999999. # 2nd palier à T=T1 : sera remplace par nouvelle valeur calculee par fonction idoine"+"\n"
- self.texteCuve+="# 45. 999999. # idem que ci-dessus : T=T1"+"\n"
- self.texteCuve+="# 46. 9. # 3eme palier à T=TIS, temperature d injection de securite : sa valeur est reactualisee avec la donnee de TIS ci-dessous"+"\n"
- self.texteCuve+="# 1870. 9. # idem que ci-dessus : T=TIS"+"\n"
- self.texteCuve+="# 1871. 80."+"\n"
- self.texteCuve+="# 3871. 80."+"\n"
- self.texteCuve+="# CC # C pour Constant, E pour Exclu, L pour Lineaire"+"\n"
- self.texteCuve+="# puis Instant (s) / Debit d injection de securite (kg/s)"+"\n"
- self.texteCuve+="# puis Modele VESTALE : (DH, DH_MESSAGE), (SECTION, SECTION_MESSAGE), (DELTA, DELTA_MESSAGE), EPS, COEFVESTALE"+"\n"
- self.texteCuve+="# Finir chacune des listes par la prolongation aux frontieres amont et aval: C = constant / E = exclu / L = lineaire"+"\n"
- self.texteCuve+="#"+"\n"
-
- if self.dico_mot.has_key('TypeConditionLimiteThermique'):
-
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#"+"\n"
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- self.texteCuve += self.ecritVariable('InstantPerteCirculationNaturelle')
- self.texteCuve += self.ecritVariable('TempInjectionSecurite')
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
-
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Courbe APRP':
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Definition de parametres pour le cas d un transitoire APRP"+"\n"
- self.texteCuve += self.ecritVariable('Instant_1')
- self.texteCuve += self.ecritVariable('Instant_2')
- self.texteCuve += self.ecritVariable('Instant_3')
- self.texteCuve += self.ecritVariable('DebitAccumule')
- self.texteCuve += self.ecritVariable('DebitInjectionSecurite')
- self.texteCuve += self.ecritVariable('TempInjectionSecurite')
- self.texteCuve += self.ecritVariable('TempInjectionSecurite_mess')
-
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee en paroi' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et coefficient echange' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et debit d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Courbe APRP' :
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# instant (s) / temperature imposee du fluide (degC)"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- if self.dico_mot.has_key('ProfilTemporel_TemperatureImposeeFluide'):
- self.imprime(2,(self.dico_mot["ProfilTemporel_TemperatureImposeeFluide"]))
- self.texteCuve += self.amontAval('Amont_TemperatureImposeeFluide','Aval_TemperatureImposeeFluide')
- else :
- self.texteCuve+="0. 286. "+"\n"
- self.texteCuve+="20. 20. "+"\n"
- self.texteCuve+="200. 7. "+"\n"
- self.texteCuve+="1000. 80. "+"\n"
- self.texteCuve+="CC"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
-
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Flux de chaleur impose en paroi':
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# instant (s) / flux de chaleur impose (W/m2)"+"\n"
- if self.dico_mot.has_key('ProfilTemporel_FluxChaleur'):
- self.imprime(2,(self.dico_mot["ProfilTemporel_FluxChaleur"]))
- self.texteCuve += self.amontAval('Amont_FluxChaleur','Aval_FluxChaleur')
- self.texteCuve+="#"+"\n"
- else :
- self.texteCuve+="0. -0. "+"\n"
- self.texteCuve+="20. -366290. "+"\n"
- self.texteCuve+="200. -121076. "+"\n"
- self.texteCuve+="1000. -56372."+"\n"
- self.texteCuve+="CC"+"\n"
-
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et debit d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Courbe APRP':
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# instant (s) / Debit d injection de securite (kg/s)"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- if self.dico_mot.has_key('ProfilTemporel_DebitInjection'):
- self.imprime(2,(self.dico_mot["ProfilTemporel_DebitInjection"]))
- self.texteCuve += self.amontAval('Amont_DebitInjection','Aval_DebitInjection')
- else :
- self.texteCuve+="0. 4590. "+"\n"
- self.texteCuve+="20. 4590. "+"\n"
- self.texteCuve+="200. 340. "+"\n"
- self.texteCuve+="1000. 31.1 "+"\n"
- self.texteCuve+="CC"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
-
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et coefficient echange' :
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# instant (s) / Coefficient d echange (W/m2/K)"+"\n"
- if self.dico_mot.has_key('ProfilTemporel_CoefficientEchange'):
- self.imprime(2,(self.dico_mot["ProfilTemporel_CoefficientEchange"]))
- self.texteCuve += self.amontAval('Amont_CoefficientEchange','Aval_CoefficientEchange')
- else :
- self.texteCuve+="0. 138454. "+"\n"
- self.texteCuve+="20. 19972. "+"\n"
- self.texteCuve+="200. 2668. "+"\n"
- self.texteCuve+="1000. 2668. "+"\n"
- self.texteCuve+="CC"+"\n"
-
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Debit massique et temperature d injection de securite' :
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# instant (s) / Debit massique (kg/s)"+"\n"
- if self.dico_mot.has_key('ProfilTemporel_DebitMassique'):
- self.imprime(2,(self.dico_mot["ProfilTemporel_DebitMassique"]))
- self.texteCuve += self.amontAval('Amont_DebitMassique','Aval_DebitMassique')
- else :
- self.texteCuve+="0. 18.4 "+"\n"
- self.texteCuve+="20. 18.4 "+"\n"
- self.texteCuve+="200. 31.1 "+"\n"
- self.texteCuve+="1000. 31.1 "+"\n"
- self.texteCuve+="CC"+"\n"
-
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# instant (s) / Temperature d injection de securite (degC)"+"\n"
- if self.dico_mot.has_key('ProfilTemporel_TemperatureInjection'):
- self.imprime(2,(self.dico_mot["ProfilTemporel_TemperatureInjection"]))
- self.texteCuve += self.amontAval('Amont_TemperatureInjection','Aval_TemperatureInjection')
- else :
- self.texteCuve+="0. 7.0 "+"\n"
- self.texteCuve+="20. 7.0 "+"\n"
- self.texteCuve+="200. 7.0 "+"\n"
- self.texteCuve+="1000. 7.0 "+"\n"
- self.texteCuve+="CC"+"\n"
-
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Debit massique et temperature d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Temperature imposee du fluide et debit d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Courbe APRP' :
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Transitoire des coefficients d echange : modele VESTALE"+"\n"
- self.texteCuve+="#"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- self.texteCuve += self.ecritVariable('DiametreHydraulique')
- self.texteCuve += self.ecritVariable('DiametreHydraulique_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('SectionEspaceAnnulaire')
- self.texteCuve += self.ecritVariable('SectionEspaceAnnulaire_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('HauteurCaracConvectionNaturelle')
- self.texteCuve += self.ecritVariable('HauteurCaracConvectionNaturelle_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('CritereConvergenceRelative')
- self.texteCuve += self.ecritVariable('CoefficientsVestale')
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
-
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Debit massique et temperature d injection de securite' or str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' :
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# Transitoire de temperature fluide locale : modele CREARE"+"\n"
- self.texteCuve+="#"+"\n"
- #self.texteCuve += self.ecritVariable('VolumeMelange_CREARE')
- self.texteCuve+="# instant (s) / Volume de melange CREARE (m3)"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- if self.dico_mot.has_key('ProfilTemporel_VolumeMelange_CREARE'):
- self.imprime(2,(self.dico_mot["ProfilTemporel_VolumeMelange_CREARE"]))
- self.texteCuve += self.amontAval('Amont_VolumeMelange_CREARE','Aval_VolumeMelange_CREARE')
- else :
- self.texteCuve+="0. 14.3 "+"\n"
- self.texteCuve+="20. 14.2 "+"\n"
- self.texteCuve+="CC"+"\n"
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- else :
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('TemperatureInitiale_CREARE')
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- self.texteCuve += self.ecritVariable('TemperatureInitiale_CREARE_mess')
- self.texteCuve+="#"+"\n"
- self.texteCuve += self.ecritVariable('SurfaceEchange_FluideStructure')
- self.texteCuve += self.ecritVariable('SurfaceEchange_FluideStructure_mess')
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT':
- self.texteCuve+="#BLOC_TFDEBIT"+"\n"
- else :
- self.texteCuve+="#"+"\n"
- self.texteCuve+="# instant (s) / temperature imposee du fluide (degC)"+"\n"
- self.texteCuve+="0. 286. "+"\n"
- self.texteCuve+="20. 20. "+"\n"
- self.texteCuve+="200. 7. "+"\n"
- self.texteCuve+="1000. 80. "+"\n"
- self.texteCuve+="CC"+"\n"
- self.texteCuve+="#"+"\n"
- self.texteCuve+="############################################################################################"+"\n"
-
-
- def genereTexteTFDEBIT(self):
-
- self.texteTFDEBIT = ""
-
- if self.dico_mot.has_key('TypeConditionLimiteThermique'):
- if str(self.dico_mot["TypeConditionLimiteThermique"])=='Calcul TEMPFLU puis DEBIT' :
- self.texteTFDEBIT+="# instant (s) / pression (MPa)"+"\n"
- self.texteTFDEBIT+=" "+"\n"
- self.imprime2(2,(self.dico_mot["ProfilTemporel_Pression"]))
- self.texteTFDEBIT += self.amontAval('Amont_Pression','Aval_Pression')
-
- # self.texteTFDEBIT+=" "+"\n"
- # self.texteTFDEBIT += self.affecteValeur('TypeConditionLimiteThermique', self.valeurproposee[str(self.dico_mot["TypeConditionLimiteThermique"])])
-
- self.texteTFDEBIT+=" "+"\n"
- self.imprime2(2,(self.dico_mot["ProfilTemporel_TemperatureImposeeFluide"]))
- self.texteTFDEBIT += self.amontAval('Amont_TemperatureImposeeFluide','Aval_TemperatureImposeeFluide')
-
- self.texteTFDEBIT+=" "+"\n"
- self.imprime2(2,(self.dico_mot["ProfilTemporel_DebitInjection"]))
- self.texteTFDEBIT += self.amontAval('Amont_DebitInjection','Aval_DebitInjection')
-
- self.texteTFDEBIT+=" "+"\n"
- self.texteTFDEBIT += self.ecritVariable('DiametreHydraulique')
- self.texteTFDEBIT += self.ecritVariable('DiametreHydraulique_mess')
- self.texteTFDEBIT+="#"+"\n"
- self.texteTFDEBIT += self.ecritVariable('SectionEspaceAnnulaire')
- self.texteTFDEBIT += self.ecritVariable('SectionEspaceAnnulaire_mess')
- self.texteTFDEBIT+="#"+"\n"
- self.texteTFDEBIT += self.ecritVariable('HauteurCaracConvectionNaturelle')
- self.texteTFDEBIT += self.ecritVariable('HauteurCaracConvectionNaturelle_mess')
- self.texteTFDEBIT+="#"+"\n"
- self.texteTFDEBIT += self.ecritVariable('CritereConvergenceRelative')
- self.texteTFDEBIT += self.ecritVariable('CoefficientsVestale')
-
- self.texteTFDEBIT+=" "+"\n"
- self.imprime2(2,(self.dico_mot["ProfilTemporel_VolumeMelange_CREARE"]))
- self.texteTFDEBIT += self.amontAval('Amont_VolumeMelange_CREARE','Aval_VolumeMelange_CREARE')
-
- self.texteTFDEBIT+=" "+"\n"
- self.texteTFDEBIT += self.ecritVariable('SurfaceEchange_FluideStructure')
- self.texteTFDEBIT += self.ecritVariable('SurfaceEchange_FluideStructure_mess')
- self.texteTFDEBIT += self.ecritVariable('InstantPerteCirculationNaturelle')
- self.texteTFDEBIT += self.ecritVariable('TempInjectionSecurite')
- else :
- self.texteTFDEBIT+="Fichier inutile"+"\n"
-
-
- def imprime(self,nbdeColonnes,valeur):
- self.liste=[]
- self.transforme(valeur)
- i=0
- while i < len(self.liste):
- for k in range(nbdeColonnes) :
- self.texteCuve+=str(self.liste[i+k]) +" "
- self.texteCuve+="\n"
- i=i+k+1
-
- def imprime2(self,nbdeColonnes,valeur):
- self.liste=[]
- self.transforme(valeur)
- i=0
- while i < len(self.liste):
- for k in range(nbdeColonnes) :
- self.texteTFDEBIT+=str(self.liste[i+k]) +" "
- self.texteTFDEBIT+="\n"
- i=i+k+1
-
-
- def transforme(self,valeur):
- for i in valeur :
- if type(i) == tuple :
- self.transforme(i)
- else :
- self.liste.append(i)
-
-
-
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-from __future__ import absolute_import
-try :
- from builtins import str
-except : pass
-import os
-
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
-from .generator_python import PythonGenerator
-import six
-
-def entryPoint():
- """
- Return a dictionary containing the description needed to load the plugin
- """
- return {'name' : 'file_from_template',
- 'factory' : FileFromTemplateGenerator}
-
-
-class FileFromTemplateGenerator(PythonGenerator):
- """
- This generator creates an output file from a template (file with holes) in
- addition to Eficas .comm file. The parts to replace in the template must be
- in the form %KEYWORD%, where KEYWORD may be either the name of the Eficas
- element (short form, for instance MY_MCSIMP) or the "path" to the Eficas
- element (long form, for instance MYPROC.MYBLOC.MY_MCSIMP).
-
- To use this generator, the configuration of the code must implement two
- methods: get_extension() that must return the extension of the output file
- and get_template_file() that must return the path of the template file. Be
- sure also that your catalog is coherent with your template file.
- """
-
- def gener(self, obj, format = 'brut', config = None):
- self.config = config
- self.kw_dict = {}
- self.text = PythonGenerator.gener(self, obj, format)
- return self.text
-
- def generate_output_from_template(self) :
- """
- Generate the output text from the template file and the keywords
- """
- templateFileName = self.config.get_template_file()
- if not os.path.isfile(templateFileName):
- raise EficasException(tr("Fichier patron %s n'existe pas.",
- str( templateFileName)))
- f = open(templateFileName, "r")
- template = f.read()
- f.close()
- self.output_text = self.replace_keywords(template)
-
- def generMCSIMP(self, obj) :
- """
- Save object value in the keyword dict for further use, then generate
- the text corresponding to the MCSIMP element.
- """
- short_keyword = obj.nom.strip()
- long_keyword = ""
- for i in obj.getGenealogie()[:-1]:
- long_keyword += i + "."
- long_keyword += short_keyword
- self.kw_dict[short_keyword] = obj.valeur
- self.kw_dict[long_keyword] = obj.valeur
- return PythonGenerator.generMCSIMP(self, obj)
-
- def replace_keywords(self, template_string):
- result = template_string
- for item in six.iteritems(self.kw_dict):
- replace_str = "%" + item[0] + "%"
- result = result.replace(replace_str, str(item[1]))
- return result
-
- def writeDefault(self, basefilename):
- self.generate_output_from_template()
- output_filename = os.path.splitext(basefilename)[0] + \
- self.config.get_extension()
- f = open(output_filename, 'w')
- f.write(self.output_text)
- f.close()
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- homard pour EFICAS.
-
-"""
-import traceback
-import types,string,re
-
-from Noyau import N_CR
-from Noyau.N_utils import repr_float
-from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
-from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
-from Accas import GEOM,ASSD,MCNUPLET
-from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
-from Formatage import Formatage
-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' : 'homard',
- # La factory pour creer une instance du plugin
- 'factory' : HomardGenerator,
- }
-
-
-class HomardGenerator(PythonGenerator):
- """
- 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 preconis�es
- 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 homard pour homard',
- fin='fin CR format homard pour homard')
- # Le texte au format homard est stock� dans l'attribut text
- self.dico_mot_clef={}
- self.assoc={}
- self.init_assoc()
- self.text=''
- self.textehomard=[]
-
- def init_assoc(self):
- self.lmots_clef_calcules = ('SuivFron','TypeBila','ModeHOMA','CCAssoci', 'CCNoChaI','HOMaiN__','HOMaiNP1','CCNumOrI', 'CCNumPTI')
- self.lmot_clef = ('CCMaiN__', 'CCNoMN__', 'CCIndica', 'CCSolN__', 'CCFronti', 'CCNoMFro', 'CCMaiNP1',
- 'CCNoMNP1', 'CCSolNP1', 'TypeRaff', 'TypeDera', 'NiveauMa', 'SeuilHau', 'SeuilHRe',
- 'SeuilHPE', 'NiveauMi', 'SeuilBas', 'SeuilBRe', 'SeuilBPE', 'ListeStd', 'NumeIter',
- 'Langue ', 'CCGroFro', 'CCNoChaI', 'CCNumOrI', 'CCNumPTI', 'SuivFron', 'TypeBila',
- 'ModeHOMA', 'HOMaiN__', 'HOMaiNP1','CCCoChaI')
-
-# Bizarre demander a Gerald :
-# CVSolNP1
- self.assoc['CCMaiN__']='FICHIER_MED_MAILLAGE_N'
- self.assoc['CCNoMN__']='NOM_MED_MAILLAGE_N'
- self.assoc['CCIndica']='FICHIER_MED_MAILLAGE_N'
- self.assoc['CCSolN__']='FICHIER_MED_MAILLAGE_N'
- self.assoc['CCFronti']='FIC_FRON'
- self.assoc['CCNoMFro']='NOM_MED_MAILLAGE_FRONTIERE'
- self.assoc['CCMaiNP1']='FICHIER_MED_MAILLAGE_NP1'
- self.assoc['CCNoMNP1']='NOM_MED_MAILLAGE_NP1'
- self.assoc['CCSolNP1']='FICHIER_MED_MAILLAGE_NP1'
- self.assoc['TypeRaff']='RAFFINEMENT'
- self.assoc['TypeDera']='DERAFFINEMENT'
- self.assoc['NiveauMa']='NIVE_MAX'
- self.assoc['SeuilHau']='CRIT_RAFF_ABS'
- self.assoc['SeuilHRe']='CRIT_RAFF_REL'
- self.assoc['SeuilHPE']='CRIT_RAFF_PE'
- self.assoc['NiveauMi']='NIVE_MIN'
- self.assoc['SeuilBas']='CRIT_DERA_ABS'
- self.assoc['SeuilBRe']='CRIT_DERA_REL'
- self.assoc['SeuilBPE']='CRIT_DERA_PE'
- self.assoc['ListeStd']='MESSAGES'
- self.assoc['NumeIter']='NITER'
- self.assoc['Langue ']='LANGUE'
- self.assoc['CCGroFro']='GROUP_MA'
-# self.assoc['CCNoChaI']='NOM_MED' (on doit aussi ajouter 'COMPOSANTE')
- self.assoc['CCNumOrI']='NUME_ORDRE'
- self.assoc['CCNumPTI']='NUME_PAS_TEMPS'
- self.assoc['CCCoChaI']='COMPOSANTE'
-
- self.dico_mot_depend={}
-
- # Attention a la synthaxe
- self.dico_mot_depend['CCIndica'] ='self.dico_mot_clef["RAFFINEMENT"] == "LIBRE" or self.dico_mot_clef["DERAFFINEMENT"] == "LIBRE"'
- self.dico_mot_depend['CCSolN__'] ='self.dico_mot_clef.has_key("NITER")'
- self.dico_mot_depend['CCSolNP1'] ='self.dico_mot_clef.has_key("NITER")'
-
- def gener(self,obj,format='brut',config=None):
- self.text=PythonGenerator.gener(self,obj,format)
- self.genereConfiguration()
- return self.text
-
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en une liste de chaines de caract�res � la
- syntaxe homard
- """
- s=PythonGenerator.generMCSIMP(self,obj)
- clef=obj.nom
- self.dico_mot_clef[clef]=obj.val
- return s
-
- def cherche_dependance(self,mot):
- b_eval = 0
- a_eval=self.dico_mot_depend[mot]
- try :
- b_eval=eval(self.dico_mot_depend[mot])
- except :
- for l in a_eval.split(" or "):
- try:
- b_eval=eval(l)
- if not (b_eval == 0 ):
- break
- except :
- pass
- return b_eval
-
-
- def genereConfiguration(self):
- ligbla=31*' '
- self.textehomard=[]
- for mot in self.lmot_clef:
-
-# on verifie d'abord que le mot clef doit bien etre calcule
- if self.dico_mot_depend.has_key(mot) :
- if self.cherche_dependance(mot) == 0 :
- continue
-
- if mot not in self.lmots_clef_calcules :
- clef_eficas=self.assoc[mot]
- if self.dico_mot_clef.has_key(clef_eficas):
- val=self.dico_mot_clef[clef_eficas]
- if val != None:
- try :
- ligne=mot+' '+val
- except:
- ligne=mot+' '+repr(val)
- ligne.rjust(32)
- self.textehomard.append(ligne)
- else:
- val=apply(HomardGenerator.__dict__[mot],(self,))
- if val != None:
- mot.rjust(8)
- ligne=mot+' '+val
- ligne.rjust(32)
- self.textehomard.append(ligne)
-
- def get_homard(self):
- return self.textehomard
-
- def SuivFron(self):
- val="non"
- if self.dico_mot_clef.has_key('NOM_MED_MAILLAGE_FRONTIERE'):
- if self.dico_mot_clef['NOM_MED_MAILLAGE_FRONTIERE'] != None:
- val="oui"
- return val
-
- def TypeBila(self):
- inttypeBilan = 1
- retour=None
- dict_val={'NOMBRE':7,'INTERPENETRATION':3,'QUALITE':5,'CONNEXITE':11,'TAILLE':13}
- for mot in ('NOMBRE','QUALITE','INTERPENETRATION','CONNEXITE','TAILLE'):
- if self.dico_mot_clef.has_key(mot):
- if (self.dico_mot_clef[mot] == "OUI"):
- inttypeBilan=inttypeBilan*dict_val[mot]
- retour = repr(inttypeBilan)
- return retour
-
-
- def ModeHOMA(self):
- intModeHOMA=1
- if self.dico_mot_clef.has_key('INFORMATION'):
- if self.dico_mot_clef['INFORMATION'] == "OUI":
- intModeHOMA=2
- return repr(intModeHOMA)
-
- def CCAssoci(self):
- return 'MED'
-
- def CCNoChaI(self):
- if not (self.dico_mot_clef.has_key('NOM_MED')):
- return None
- if (self.dico_mot_clef['NOM_MED']== None):
- return None
- if not (self.dico_mot_clef.has_key('COMPOSANTE')):
- return None
- if (self.dico_mot_clef['COMPOSANTE']== None):
- return None
- chaine=self.dico_mot_clef['COMPOSANTE']+' '+self.dico_mot_clef['NOM_MED']
- return chaine
-
- def HOMaiN__(self):
- chaine=None
- if self.dico_mot_clef.has_key('NITER'):
- if self.dico_mot_clef['NITER'] != None :
- num="M"+repr(self.dico_mot_clef['NITER'])
- chaine=num+" "+num+".hom"
- return chaine
-
- def HOMaiNP1(self):
- chaine=None
- if self.dico_mot_clef.has_key('NITER'):
- if self.dico_mot_clef['NITER'] != None :
- num="M"+repr(self.dico_mot_clef['NITER']+1)
- chaine=num+" "+num+".hom"
- return chaine
-
- def CCNumOrI(self):
- chaine=repr(1)
- if self.dico_mot_clef.has_key('NUME_ORDRE'):
- if self.dico_mot_clef['NUME_ORDRE'] != None :
- chaine=repr(self.dico_mot_clef['NUME_ORDRE'])
- return chaine
-
- def CCNumPTI(self):
- chaine=repr(1)
- if self.dico_mot_clef.has_key('NUME_PAS_TEMPS'):
- if self.dico_mot_clef['NUME_PAS_TEMPS'] != None :
- chaine=repr(self.dico_mot_clef['NUME_PAS_TEMPS'])
- return chaine
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier
- au format ini pour EFICAS.
-"""
-from __future__ import absolute_import
-try :
- from builtins import str
- from builtins import object
-except : pass
-
-import traceback
-import types
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
-
-
-from Noyau import N_CR
-from Accas import MCSIMP,MCFACT,MCList
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'ini',
- # La factory pour creer une instance du plugin
- 'factory' : IniGenerator,
- }
-
-
-class IniGenerator(object):
- """
- Ce generateur parcourt un objet de type MCFACT et produit
- un fichier au format ini
- L'acquisition et le parcours sont realises par le methode
- generator.gener(objet_mcfact)
- 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=('.ini','.conf')
-
- 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 ini',
- fin='fin CR format ini')
- # Le texte au format ini 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,config=None):
- """
- Tous les mots-cles simples du niveau haut sont mis dans la section DEFAUT
- Tous les mots-cles facteurs sont convertis en sections
- Un mot-cle facteur ne peut contenir que des mots-cles simples. Sinon => erreur
- """
- listeMcFact=[]
- sect_defaut=''
- if isinstance(obj,MCList):
- if len(obj.data) > 1:
- raise EficasException(tr("Pas supporte"))
- else:
- obj=obj.data[0]
-
- for mocle in obj.mc_liste:
- if isinstance(mocle,MCList):
- if len(mocle.data) > 1:
- raise EficasException(tr("Pas supporte"))
- else:
- listeMcFact.append(self.generMCFACT(mocle.data[0]))
- elif isinstance(mocle,MCFACT):
- listeMcFact.append(self.generMCFACT(mocle))
- elif isinstance(mocle,MCSIMP):
- sect_defaut=sect_defaut+self.generMCSIMP(mocle)
- else:
- self.cr.fatal(tr("Entite inconnue ou interdite :%s",repr(mocle)))
-
- self.text=''
- if sect_defaut != '':
- self.text="[DEFAULT]\n"+sect_defaut
- self.text=self.text + ''.join(listeMcFact,'\n')
- return self.text
-
- def generMCFACT(self,obj):
- """
- Cette methode convertit un mot-cle facteur ne contenant que des mots-cles
- simples en une chaine de caracteres
- """
- sect_text='[%s]\n' % obj.nom
- for mocle in obj.mc_liste:
- if isinstance(mocle,MCSIMP):
- sect_text=sect_text+self.generMCSIMP(mocle)
- else:
- self.cr.fatal(tr("Entite inconnue ou interdite :%s. Elle est ignoree",repr(mocle)))
- return sect_text
-
- def generMCSIMP(self,obj):
- """
- Cette methode convertit un mot-cle simple en une chaine de caracteres
- au format ini
- """
- s=''
- if type(obj.valeur) == tuple :
- self.cr.fatal(tr("Les tuples ne sont pas supportes pour le format ini :%s ", obj.nom))
- s="%s = %s\n" % (obj.nom,"ERREUR")
- else :
- try:
- s="%s = %s\n" % (obj.nom,obj.valeur)
- except Exception as e :
- self.cr.fatal(tr("Type de valeur non supportee par le format ini :%(nom)s\n%(exception)s", \
- {'nom': obj.nom, 'exception': str(e)}))
- return s
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- 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
-except : pass
-
-import traceback
-import types,re,os
-import Accas
-
-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' : '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
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- 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
-except : pass
-
-import traceback
-import types,re,os
-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
-
- 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
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- openturns pour EFICAS.
-
-"""
-import traceback
-import types,string,re
-from Extensions.i18n import tr
-
-
-from generator_python import PythonGenerator
-from OpenturnsBase import Generateur
-#from OpenturnsXML import XMLGenerateur
-#from OpenturnsSTD import STDGenerateur
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
-
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'openturns',
- # La factory pour creer une instance du plugin
- 'factory' : OpenturnsGenerator,
- }
-
-
-class OpenturnsGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format xml
-
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
-
- def initDico(self):
- self.dictMCVal={}
- self.listeVariables=[]
- self.listeFichiers=[]
- self.dictMCLois={}
- self.dictTempo={}
- self.TraiteMCSIMP=1
-
- def gener(self,obj,format='brut',config=None):
- #print "IDM: gener dans generator_openturns.py"
- self.initDico()
- self.text=PythonGenerator.gener(self,obj,format)
- self.genereXML()
- self.genereSTD()
- return self.text
-
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en texte python
- Remplit le dictionnaire des MCSIMP si nous ne sommes pas ni dans une loi, ni dans une variable
- """
- s=PythonGenerator.generMCSIMP(self,obj)
- if self.TraiteMCSIMP == 1 :
- self.dictMCVal[obj.nom]=obj.valeur
- else :
- self.dictTempo[obj.nom]=obj.valeur
- return s
-
- def generMCFACT(self,obj):
- # Il n est pas possible d utiliser obj.valeur qui n est pas
- # a jour pour les nouvelles variables ou les modifications
- if obj.nom == "Variables" or "Files":
- self.TraiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generMCFACT(self,obj)
- if obj.nom == "Variables" :
- self.listeVariables.append(self.dictTempo)
- self.dictTempo={}
- else :
- self.listeFichiers.append(self.dictTempo)
- self.TraiteMCSIMP=1
- return s
-
- def generETAPE(self,obj):
- if obj.nom == "DISTRIBUTION" :
- self.TraiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generETAPE(self,obj)
- if obj.nom == "DISTRIBUTION" :
- self.dictMCLois[obj.sd]=self.dictTempo
- self.dictTempo={}
- self.TraiteMCSIMP=1
- return s
-
- def genereXML(self):
- #print "IDM: genereXML dans generator_openturns.py"
- if self.listeFichiers != [] :
- self.dictMCVal["exchange_file"]=self.listeFichiers
- MonBaseGenerateur=Generateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
- MonGenerateur=MonBaseGenerateur.getXMLGenerateur()
- #try :
- if 1== 1 :
- self.texteXML=MonGenerateur.CreeXML()
- #except :
- else :
- self.texteXML=tr("Il y a un pb a la Creation du XML")
-
- def genereSTD(self):
- MonBaseGenerateur=Generateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
- MonGenerateur=MonBaseGenerateur.getSTDGenerateur()
- #try :
- if 1== 1 :
- self.texteSTD=MonGenerateur.CreeSTD()
- #except :
- else :
- self.texteSTD=tr("Il y a un pb a la Creation du STD")
-
- def getOpenturnsXML(self):
- return self.texteXML
-
- def getOpenturnsSTD(self):
- return self.texteSTD
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- openturns pour EFICAS.
-
-"""
-import traceback
-import types,string,re
-from Extensions.i18n import tr
-
-
-from generator_python import PythonGenerator
-from OpenturnsBase import Generateur
-#from OpenturnsXML import XMLGenerateur
-#from OpenturnsSTD import STDGenerateur
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
-
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'openturns_study',
- # La factory pour creer une instance du plugin
- 'factory' : OpenturnsGenerator,
- }
-
-
-class OpenturnsGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format xml
-
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
-
- def initDico(self):
- self.dictMCVal={}
- self.listeVariables=[]
- self.listeFichiers=[]
- self.dictMCLois={}
- self.dictTempo={}
- self.TraiteMCSIMP=1
- self.texteSTD="""#!/usr/bin/env python
- import sys
- print "Invalid file. Check build process."
- sys.exit(1)
- """
-
- def gener(self,obj,format='brut',config=None):
- print "IDM: gener dans generator_openturns_study.py"
- self.initDico()
- self.text=PythonGenerator.gener(self,obj,format)
- self.genereSTD()
- return self.text
-
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en texte python
- Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
- """
- s=PythonGenerator.generMCSIMP(self,obj)
- if self.TraiteMCSIMP == 1 :
- self.dictMCVal[obj.nom]=obj.valeur
- else :
- self.dictTempo[obj.nom]=obj.valeur
- return s
-
-
- def generETAPE(self,obj):
- print "IDM: generETAPE dans generator_openturns_study.py"
- print "IDM: obj.nom=", obj.nom
- if obj.nom in ( "DISTRIBUTION", ) :
- self.TraiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generETAPE(self,obj)
- if obj.nom in ( "DISTRIBUTION", ) :
- self.dictMCLois[obj.sd]=self.dictTempo
- self.dictTempo={}
- self.TraiteMCSIMP=1
- return s
-
- def generPROC_ETAPE(self,obj):
- print "IDM: generPROC_ETAPE dans generator_openturns_study.py"
- print "IDM: obj.nom=", obj.nom
- if obj.nom in ( "VARIABLE", ) :
- self.TraiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generPROC_ETAPE(self,obj)
- if obj.nom in ( "VARIABLE", ) :
- self.listeVariables.append(self.dictTempo)
- self.dictTempo={}
- self.TraiteMCSIMP=1
- return s
-
- def genereSTD(self):
- print "IDM: genereSTD dans generator_openturns_study.py"
- print "IDM: self.listeVariables=", self.listeVariables
- MonGenerateur=self.getGenerateur()
- #try :
- if 1== 1 :
- self.texteSTD=MonGenerateur.CreeSTD()
- #except :
- else :
- self.texteSTD=tr("Il y a un pb a la Creation du STD")
-
- def writeDefault(self, fn):
- fileSTD = fn[:fn.rfind(".")] + '.py'
- with open(fileSTD, 'w') as f:
- f.write(self.texteSTD)
-
- def getGenerateur (self):
- print "IDM: getGenerateur dans generator_openturns_study.py"
- print "IDM: self.dictMCVal=", self.dictMCVal
- print "IDM: self.listeVariables=", self.listeVariables
- print "IDM: self.dictMCLois=", self.dictMCLois
- MonBaseGenerateur=Generateur(self.appli,self.dictMCVal, self.listeVariables, self.dictMCLois)
- MonGenerateur=MonBaseGenerateur.getSTDGenerateur()
- return MonGenerateur
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- openturns pour EFICAS.
-
-"""
-import traceback
-import types,string,re
-from Extensions.i18n import tr
-
-
-from generator_python import PythonGenerator
-from OpenturnsBase import Generateur
-#from OpenturnsXML import XMLGenerateur
-#from OpenturnsSTD import STDGenerateur
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
-
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'openturns_wrapper',
- # La factory pour creer une instance du plugin
- 'factory' : OpenturnsGenerator,
- }
-
-
-class OpenturnsGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format xml
-
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
-
- def initDico(self):
- self.dictMCVal={}
- self.dictVariables={}
- self.listeFichiers=[]
- self.dictTempo={}
- self.traiteMCSIMP=1
- self.numOrdre=0
- self.texteSTD="""#!/usr/bin/env python
- import sys
- print "Invalid file. Check build process."
- sys.exit(1)
- """
- self.wrapperXML=None
-
- def gener(self,obj,format='brut',config=None):
- #print "IDM: gener dans generator_openturns_wrapper.py"
- self.initDico()
- self.text=PythonGenerator.gener(self,obj,format)
- self.genereXML()
- #self.genereSTD()
- return self.text
-
- def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en texte python
- Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
- """
- s=PythonGenerator.generMCSIMP(self,obj)
- if not( type(obj.valeur) in (list, tuple)) and (obj.getMinMax()[1] != 1):
- valeur=(obj.valeur,)
- else :
- valeur=obj.valeur
- if self.traiteMCSIMP == 1 :
- self.dictMCVal[obj.nom]=valeur
- else :
- self.dictTempo[obj.nom]=valeur
- return s
-
- def generETAPE(self,obj):
- #print "generETAPE" , obj.nom
- if obj.nom == "VARIABLE" :
- self.traiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generETAPE(self,obj)
- if obj.nom == "VARIABLE" :
- self.dictTempo["numOrdre"]=self.numOrdre
- self.numOrdre = self.numOrdre +1
- if obj.sd == None :
- self.dictVariables["SansNom"]=self.dictTempo
- else :
- self.dictVariables[obj.sd.nom]=self.dictTempo
- self.dictTempo={}
- self.traiteMCSIMP=1
- return s
-
- def generMCFACT(self,obj):
- # Il n est pas possible d utiliser obj.valeur qui n est pas
- # a jour pour les nouvelles variables ou les modifications
- if obj.nom in ( "Files", ) :
- self.traiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generMCFACT(self,obj)
- self.listeFichiers.append(self.dictTempo)
- self.traiteMCSIMP=1
- return s
-
- def genereXML(self):
- print "IDM: genereXML dans generator_openturns_wrapper.py"
- #print "appli.maConfiguration=",self.appli.maConfiguration.__dict__
- if self.listeFichiers != [] :
- self.dictMCVal["Files"]=self.listeFichiers
- print "dictMCVal", self.dictMCVal, "dictVariables", self.dictVariables
- MonBaseGenerateur=Generateur(self.appli,self.dictMCVal, [], {} ,self.dictVariables)
- MonGenerateur=MonBaseGenerateur.getXMLGenerateur()
- try :
- #if 1== 1 :
- self.wrapperXML=MonGenerateur.CreeXML()
- except :
- #else :
- self.wrapperXML=None
-
- def writeDefault(self, filename):
- fileXML = filename[:filename.rfind(".")] + '.xml'
- self.wrapperXML.writeFile( str(fileXML) )
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format pyth pour EFICAS.
-
-
-"""
-try :
- from builtins import str
- from builtins import object
-except : pass
-
-import traceback
-import types
-
-from Noyau import N_CR
-from Accas import MCSIMP,MCFACT,MCList
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
-
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
-
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'pyth',
- # La factory pour creer une instance du plugin
- 'factory' : PythGenerator,
- }
-
-
-class PythGenerator(object):
- """
- Ce generateur parcourt un objet de type MCFACT et produit
- un fichier au format pyth
-
- L'acquisition et le parcours sont realises par la methode
- generator.gener(objet_mcfact)
-
- 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=('.py','.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 ini',
- fin='fin CR format ini')
- # Le texte au format pyth 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='standard',config=None):
- """
- Tous les mots-cles simples du niveau haut sont transformes en variables
-
- Tous les mots-cles facteurs sont convertis en dictionnaires
-
- Les mots-cles multiples ne sont pas traites
- """
- s=''
- if isinstance(obj,MCList):
- if len(obj.data) > 1:
- raise EficasException(tr("Pas supporte"))
- else:
- obj=obj.data[0]
-
- for mocle in obj.mc_liste:
- if isinstance(mocle,MCList):
- if len(mocle.data) > 1:
- raise EficasException(tr("Pas supporte"))
- else:
- valeur=self.generMCFACT(mocle.data[0])
- s=s+"%s = %s\n" % (mocle.nom,valeur)
- elif isinstance(mocle,MCFACT):
- valeur=self.generMCFACT(mocle)
- s=s+"%s = %s\n" % (mocle.nom,valeur)
- elif isinstance(v,MCSIMP):
- valeur = self.generMCSIMP(mocle)
- s=s+"%s = %s\n" % (mocle.nom,valeur)
- else:
- self.cr.fatal("Entite inconnue ou interdite : "+repr(mocle))
-
- self.text=s
- return self.text
-
- def generMCFACT(self,obj):
- """
- Cette methode convertit un mot-cle facteur
- en une chaine de caracteres representative d'un dictionnaire
- """
- s = '{'
- for mocle in obj.mc_liste:
- if isinstance(mocle,MCSIMP):
- valeur = self.generMCSIMP(mocle)
- s=s+"'%s' : %s,\n" % (mocle.nom,valeur)
- elif isinstance(mocle,MCFACT):
- valeur=self.generMCFACT(mocle)
- s=s+"'%s' : %s,\n" % (mocle.nom,valeur)
- else:
- self.cr.fatal(tr("Entite inconnue ou interdite : %s. Elle est ignoree", repr(mocle)))
-
- s=s+'}'
- return s
-
- def generMCSIMP(self,obj):
- """
- Cette methode convertit un mot-cle simple en une chaine de caracteres
- au format pyth
- """
- try:
- s="%s" % obj.valeur
- except Exception as e :
- self.cr.fatal(tr("Type de valeur non supporte par le format pyth : n %(exception)s", \
- {'nom': obj.nom, 'exception': str(e)}))
-
-
- s="ERREUR"
- return s
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- python pour EFICAS.
-
-"""
-import traceback
-import types,string,re
-
-from Noyau import N_CR
-from Noyau.N_utils import repr_float
-from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
-from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
-from Accas import GEOM,ASSD,MCNUPLET
-from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
-from Formatage import Formatage
-
-import generator_python
-
-def entryPoint():
- """
- Retourne les informations nécessaires pour le chargeur de plugins
-
- Ces informations sont retournées dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'python6',
- # La factory pour créer une instance du plugin
- 'factory' : PythonGenerator,
- }
-
-
-class PythonGenerator(generator_python.PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un fichier au format python6
-
- L'acquisition et le parcours sont réalisés par la méthode
- generator.gener(objet_jdc,format)
-
- L'écriture du fichier au format python6 par appel de la méthode
- generator.writefile(nom_fichier)
-
- Ses caractéristiques principales sont exposées dans des attributs
- de classe :
- - extensions : qui donne une liste d'extensions de fichier préconisées
-
- """
- # Les extensions de fichier préconisées
- extensions=('.comm',)
-
- def generFORM_ETAPE(self,obj):
- """
- Méthode particulière pour les objets de type FORMULE
- """
- l=[]
- nom = obj.getNom()
- if nom == '' : nom = 'sansnom'
- l.append(nom + ' = FORMULE(')
- for v in obj.mc_liste:
- text=self.generator(v)
- l.append(v.nom+'='+text)
- l.append(');')
- return l
-
- def gen_formule(self,obj):
- """
- Méthode particuliere aux objets de type FORMULE
- """
- try:
- if obj.sd == None:
- sdname=''
- else:
- sdname= self.generator(obj.sd)
- except:
- sdname='sansnom'
- l=[]
- label=sdname + ' = FORMULE('
- l.append(label)
- for v in obj.mc_liste:
- s=''
- s= v.nom+':'+sdname+'('+v.valeur+')'
- l.append(s)
- if len(l) == 1:
- l[0]=label+');'
- else :
- l.append(');')
- return l
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module contient le plugin generateur de fichier au format
- python pour EFICAS.
- PN
-
-"""
-from __future__ import absolute_import
-from __future__ import print_function
-from __future__ import division
-try :
- from builtins import range
-except :
- pass
-import traceback
-import types,re
-import math
-
-from Noyau import N_CR
-from Noyau.N_utils import repr_float
-import Accas
-import Extensions
-from Extensions.parametre import ITEM_PARAMETRE
-from .Formatage import Formatage
-from .generator_python import PythonGenerator
-from six.moves import range
-#from Editeur.widgets import showerror
-
-def entryPoint():
- """
- 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,
- }
-
-
-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
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-import traceback
-import types,string,re,os
-from Extensions.i18n import tr
-from generator_python import PythonGenerator
-
-# Groupes de mailles dont les types sont definis par des prefixes dans leur nom
-usePrefix = False # les noms ont des prefixes (True) ou non (False)
-# liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom
-# Ce prefixe (et caractere _) doivent etre supprimes dans le fichier .phys
-listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",
- "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",
- "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",
- "PORT_OMEGA","POST_PHI","PB_GRID",
- "SCUTE","SCUTN","ZS","ZJ","ZT")
-# liste des prefixes des groupes de mailles, sans le separateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire
-dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'),
- 'CONDUCTOR':('COND',),
- 'STRANDED_INDUCTOR':('CURRENT', ),
- 'EPORT':('EPORT', ),
- 'HPORT':('HPORT', ),
- 'ZSURFACIC':('ZS', ),
- 'ZINSULATOR':('ZJ', ),
- 'NILMAT':('NILMAT', )}
-# separateur entre le prefixe et le reste du nom du groupe de maille
-sepNomGroupeMaille = '_'
-
-
-# types de problemes
-HARMONIC = 'HARMONIC' # probleme frequentiel
-TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
-
-# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
-nomPlugin = 'CARMEL3DFV0'
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : nomPlugin,
- # La factory pour creer une instance du plugin
- 'factory' : CARMEL3DFV0Generator,
- }
-
-
-
-class CARMEL3DFV0Generator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
-
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
-
-#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None):
-
- self.initDico()
-
- #self.debug = True
-
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
-
- if self.debug:
- print "self.text = %s" % self.text
-
- # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
- # si le jdc est valide (sinon cela n a pas de sens)
- if obj.isValid() :
- try :
- # constitution du bloc VERSION du fichier PHYS (existe toujours)
- self.generBLOC_VERSION(obj)
- # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
- self.generBLOC_MATERIALS()
- # constitution du bloc SOURCES du fichier PHYS (existe toujours)
- self.generBLOC_SOURCES()
-
- except ValueError, err:
- raise ValueError(str(err))
-
-# print "texte carmel3d :\n",self.texteCarmel3D
-# print "dictMaterDielectric : ",self.dictMaterDielectric
- if self.debug:
- print "dictMaterDielectric : %s" % repr(self.dictMaterDielectric)
- print "dictMaterConductor : %s" % repr(self.dictMaterConductor)
-
- return self.text
-
-
-
-
-#----------------------------------------------------------------------------------------
-# initialisations
-#----------------------------------------------------------------------------------------
-
- def initDico(self) :
- self.texteCarmel3D=""
- self.texteCarmel3D_PARAM=""
- self.texteCarmel3D_PARAM_SOLV=""
- self.texteCarmel3D_SH=""
- self.texteCarmel3D_INFC=""
- self.texteCarmel3D_CMD=""
- self.texteCarmel3D_INGEND1=""
- self.texteCarmel3D_INGEND2=""
- self.texteCarmel3D_INGEND3=""
- self.texteCarmel3D_INPOST=""
- self.debug = True # affichage de messages pour deboguage (.true.) ou non
- self.dicoEtapeCourant=None
- self.dicoMCFACTCourant=None
- self.dicoCourant=None
- self.dictGroupes = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[], 'ordreStrandJdC':[], 'ordreListeJdC':[], 'ordreDomaineJdC':[]} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
- self.dictMaterConductor={}
- self.dictMaterDielectric={}
- self.dictMaterZsurfacic={}
- self.dictMaterEmIso={}
- self.dictMaterEmAnIso={}
- self.dictMaterNilmat={}
- self.dictMaterZinsulator={}
- self.dictSourceStInd={}
- self.dictSourceEport={}
- self.dictSourceHport={}
- self.dictStrand={}
- self.dictDomaine={}
- self.dictPort={}
- self.cutlineValeur=[]
- self.cutplaneValeur=[]
- self.visu3dValeur=[]
- self.fieldmapValeur=[]
- self.fielddumpValeur=[]
- self.repertory=""
- self.frequency=""
- self.domaine=""
- self.direction=""
- self.section=""
- self.forme=""
- self.centre=""
- self.echelle=""
- self.visu=False
- self.post_global=False
- self.visu_format=""
- self.visu_type=""
- self.gendof=""
- self.fcarmel=""
- self.postprocess=""
- self.formulation=""
- # on force le probleme a etre frequentiel, seul possible en l'etat des choses
- self.problem = HARMONIC
- self.fichierMaillage = "" # chemin absolu ou relatif du fichier contenant le maillage, défini dans PARAMETERS.Fichier_maillage.
- self.nomFichierMaillage = "" # nom du fichier de maillage, sans le chemin
- self.projet = "" # nom du projet, utilisé un peu partout, i.e., nom du fichier de maillage sans l'extension
- self.materiauxGroupesTousHomogenes = True # Tous les groupes sont associés a priori à des matériaux tous homogènes mais pas forcément isotropes. On le vérifie ou modifie ci-dessous.
- self.materiauxGroupesTousIsotropes = True # Tous les groupes sont associés a priori à des matériaux tous isotropes mais pas forcément homogènes. On le vérifie ou modifie ci-dessous.
-
-#----------------------------------------------------------------------------------------
-# ecriture
-#----------------------------------------------------------------------------------------
-
- def writeDefault(self,fn) :
- """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
-
- # fn est le chemin complet du fichier de l'étude, e.g., /home/toto/foo.comm
- #file = fn[:fn.rfind(".")] # chemin complet du fichier de l'étude sans l'extension, e.g., /home/toto/foo
- repertory=os.path.dirname(fn) # répertoire de l'étude, e.g., /home/toto/
- file = os.path.join(repertory, self.projet) # on crée le chemin complet des fichiers de configuration sans extension, à partir du nom du projet.
- namefile=os.path.basename(file) # nom du projet e.g., foo
-
-
- if self.debug:
- print "ecriture du fichier de parametres (PHYS)"
- filePHYS = file + '.phys'
- typeBloc = 'PHYS_FILES'
- f = open( str(filePHYS), 'w')
- f.write( self.texteCarmel3D)
- f.close()
-
-
- if self.debug:
- print "ecriture du fichier de parametres (PARAM)"
- filePARAM = file + '.param'
- f = open( str(filePARAM), 'w')
- f.write('[VERSION \n'
- ' NUM 1\n'
- ' FILETYPE PARAM\n]\n'
- '[PROBLEM\n'
- ' NAME HARMONIC\n]\n'
- )
- typeBloc = 'CAR_FILES'
- self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
- self.texteCarmel3D_PARAM+=" NAME "+self.projet+".car"
- self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
- typeBloc = 'PHYS_FILES'
- self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
- self.texteCarmel3D_PARAM+=" NAME "+self.projet+".phys"
- self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
- self.texteCarmel3D_PARAM+="[FREQUENCY\n"
- self.texteCarmel3D_PARAM+=" SINGLE %g \n" % (self.frequency )
- self.texteCarmel3D_PARAM+="] \n"
- f.write( self.texteCarmel3D_PARAM)
- f.write(self.texteCarmel3D_PARAM_SOLV)
- f.close()
-
- # ecriture du fichier de commandes du post-traitement (.cmd), à partir du texte self.textCarmel3D défini dans la routine generPOST_COMMANDS
- if self.debug:
- print "ecriture du fichier de parametres (CMD)"
- fileCMD =file + '.cmd'
- f = open( str(fileCMD), 'w')
- f.write(self.texteCarmel3D_CMD)
- f.close()
-
-
- if self.debug:
- print "ecriture du fichier de parametres (INGENDOF)"
- fileINGEND = file + '.ingendof'
- f = open(fileINGEND, 'w')
- self.texteCarmel3D_INGEND1+=""+self.nomFichierMaillage # nom du fichier de maillage (chemin relatif)
-
- nomsGroupes = self.dictGroupes['ordreStrandJdC'][:]
- nomsGroupes.sort()
-
- #if self.dictDomaine !={}:
- try:
- self.creaBLOC_STRANDED_INDUCTOR_GEOMETRY(nomsGroupes)
- except ValueError, err:
- raise ValueError(str(err))
- if self.dictPort != {} :
- self.creaBLOC_PORTS_GEOMETRY(nomsGroupes)
- if self.formulation=="APHI": self.texteCarmel3D_INGEND3+="\n1"
- if self.formulation=="TOMEGA": self.texteCarmel3D_INGEND3+="\n2"
- f.write(self.texteCarmel3D_INGEND1)
- f.write(self.texteCarmel3D_INGEND2)
- f.write(self.texteCarmel3D_INGEND3)
- f.close()
-
- if self.debug:
- print "ecriture du fichier de parametres (INFCARMEL) "
- fileINFC = file + '.infcarmel'
- f = open(fileINFC, 'w')
- self.texteCarmel3D_INFC+= self.projet+".param"
- f.write(self.texteCarmel3D_INFC)
- f.close()
-
- if self.debug:
- print "ecriture du fichier de parametres (INPOSTPROCESS) "
- fileINPOST = file + '.inpostprocess'
- f = open(fileINPOST, 'w')
- self.texteCarmel3D_INPOST+= self.projet+".param"
- self.texteCarmel3D_INPOST+="\n"+self.projet+".xmat"
- self.texteCarmel3D_INPOST+="\n"+self.projet+".cmd"
- f.write(self.texteCarmel3D_INPOST)
- f.close()
-
- print "dictionnaire complet=%s" %self.dictGroupes
- print "dictionnaire des ports =%s" %self.dictPort
- if self.debug:
- print "ecriture du fichier d'execution (SH)"
- print"LISTE DES DOMAINES=%s" %(self.dictGroupes['ordreDomaineJdC'])
- RepCarmel= os.path.join(repertory,"lancer.sh")
- f = open( str(RepCarmel), 'wb')
- self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
- if self.gendof=="TRUE":
- self.texteCarmel3D_SH+='echo "Debut execution gendof" \n'
- if self.echelle=="Millimetre":
- self.texteCarmel3D_SH+=self.repertory+"/gendof.exe -scale 0.001 < " + self.projet + ".ingendof\n"
- else:
- self.texteCarmel3D_SH+=self.repertory+"/gendof.exe < " + self.projet + ".ingendof\n"
- if self.fcarmel=="TRUE":
- self.texteCarmel3D_SH+='echo "Debut execution fcarmel" \n'
- self.texteCarmel3D_SH+=self.repertory+"/fcarmel.exe < " + self.projet + ".infcarmel\n"
- if self.postprocess=="TRUE":
- self.texteCarmel3D_SH+= 'echo "Debut execution postprocess" \n'
- self.texteCarmel3D_SH+= self.repertory+"/postprocess.exe < " + self.projet + ".inpostprocess\n"
- f.write(self.texteCarmel3D_SH)
- f.close()
-
-#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
-#----------------------------------------------------------------------------------------
-
- def generMCSIMP(self,obj) :
- """recuperation de l objet MCSIMP"""
- if self.debug:
- print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
- s=PythonGenerator.generMCSIMP(self,obj)
- try:
- self.dicoCourant[obj.nom]=obj.valeurFormatee
- except:
- print "Oubli des messages texte homo='information'"
- return s
-
-
-#----------------------------------------------------------------------------------------
- def generMCFACT(self,obj) :
- """recuperation de l objet MCFACT"""
- if self.debug:
- print "MCFACT debut %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
- dico={}
- self.dicoMCFACTCourant=dico
- self.dicoCourant=self.dicoMCFACTCourant
- s=PythonGenerator.generMCFACT(self,obj)
- # sauvegarde, dans self.dicoEtapeCourant, de la valeur du FACT courant, pour utilisation ultérieure dans generETAPE et generPROC_ETAPE
- # traitement des FACT CUTLINE et CUTPLANE multiples (max='**' dans le catalogue)
- # Ce traitement spécial est nécessaire pour le moment car le générateur bogue sinon au niveau des matériaux (non-linéaires ?)
- if obj.nom in ('FIELDDUMP','CUTLINE', 'CUTPLANE', 'FIELDMAP', 'VISU3D' ):
- # Remplissage se self.dicoEtapeCourant pour le nom du FACT courant
- # Il ne contient qu'une seule valeur (un dictionnaire) par défaut lorsque le FACT est unique (max=1 dans le catalogue),
- # mais il peut aussi contenir plusieurs valeurs (tableau) dans le cas contraire, e.g., max='**' dans le catalogue
- if self.dicoEtapeCourant.has_key(obj.nom): # plusieurs valeurs
- print "self.dicoEtapeCourant= %s"%self.dicoEtapeCourant
- if type(self.dicoEtapeCourant[obj.nom]) == types.DictType: # une seule valeur entrée jusqu'à présent
- dicoMCFACTprecedent = self.dicoEtapeCourant[obj.nom] # sauvegarde de la valeur précédente
- print "dicoMCFACTpreceden= %s self.dicoEtapeCourant= %s"%(dicoMCFACTprecedent,self.dicoEtapeCourant)
- self.dicoEtapeCourant[obj.nom] = [ dicoMCFACTprecedent, self.dicoMCFACTCourant ] # restructuration en liste et insertion de la valeur précédente et de la valeur courant
- print "self.dicoEtapeCourant[obj.nom]= %s"%self.dicoEtapeCourant[obj.nom]
- else: # plusieurs valeurs entrées jusqu'à présent, sous la forme d'une liste de dictionnaires
- self.dicoEtapeCourant[obj.nom].append(self.dicoMCFACTCourant) # extension de la liste avec cette valeur, placée en dernier
- else: # une seule valeur ou première valeur
- self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
- else: # traitement usuel des FACT uniques, pour ignorer le bogue décrit plus haut
- self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
- self.dicoMCFACTCourant=None
- self.dicoCourant=self.dicoEtapeCourant
- if self.debug:
- print "MCFACT fin %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
- return s
-
-
-#----------------------------------------------------------------------------------------
- def generPROC_ETAPE(self,obj):
- """analyse des PROC du catalogue ( VERSION )"""
- if self.debug:
- print "PROC_ETAPE initial: %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- s=PythonGenerator.generPROC_ETAPE(self,obj)
- obj.valeur=self.dicoEtapeCourant # on passe à obj la bonne structure générée par PythonGenerator.generPROC_ETAPE, pour le traitement de chaque partie ci-dessous
- if self.debug:
- print "PROC_ETAPE mis a jour: %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
- if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
- if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
- if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
- s=PythonGenerator.generPROC_ETAPE(self,obj) # obj.valeur a été modifiée pour le traitement ci-dessus, alors il faut tout remettre en ordre en appelant de nouveau PythonGenerator.generPROC_ETAPE
- return s
-
-
-
-#----------------------------------------------------------------------------------------
- def generETAPE(self,obj):
- """analyse des OPER du catalogue"""
- if self.debug:
- print "ETAPE mis a jour: obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- s=PythonGenerator.generETAPE(self,obj)
- obj.valeur=self.dicoEtapeCourant # cf. generPROC_ETAPE
- if self.debug:
- print "ETAPE mis a jour: obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
- if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
- if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
- if obj.nom=="SOURCE" : self.generSOURCE(obj)
- if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
- if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
- s=PythonGenerator.generETAPE(self,obj) # cf. generPROC_ETAPE
- return s
-
-#----------------------------------------------------------------------------------------
- def generMACRO_ETAPE(self,obj):
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- import generator
- monGenerateur=generator.plugins[nomPlugin]()
- jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
- if self.debug:
- print "jdc_aux_texte : %s" % jdc_aux_texte
-
- for cle in monGenerateur.dictMaterConductor:
- self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
- for cle in monGenerateur.dictMaterDielectric:
- self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
- for cle in monGenerateur.dictMaterZsurfacic:
- self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
- for cle in monGenerateur.dictMaterEmIso:
- self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
- for cle in monGenerateur.dictMaterEmAnIso:
- self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
- for cle in monGenerateur.dictMaterNilmat:
- self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
- for cle in monGenerateur.dictMaterZinsulator:
- self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
-
- print "________FIN MACRO______________________________________"
- s=PythonGenerator.generMACRO_ETAPE(self,obj)
- return s
-
-#----------------------------------------------------------------------------------------
-#----------------------------------------------------------------------------------------
- def generMESHGROUP(self,obj):
- """preparation de la ligne NAME referencant le groupe de mailles
- associe le groupe de mailles au materiau ou a la source utilisateur
- on sauvegarde aussi les noms des groupes de maillage
- """
- try:
- if usePrefix:
- nomGroupe = self.nomReelGroupe(obj.getSdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
- print "liste des noms sans prefixes %s" %(nomGroupe)
- else:
- nomGroupe = obj.getSdname() # nom du groupe de maillage, i.e. nom du concept
- print "liste des noms sans prefixes %s" %(nomGroupe)
-
- # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
- # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
- #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
- #
- # on utilise le fait que obj.valeur est un dictionnaire
- self.dictGroupes[nomGroupe] = {}
-# nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
- if self.debug:
- print "obj.valeur.keys()= %s" % obj.valeur.keys()
- if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
- raise ValueError, nomGroupe + tr(" : ce groupe de maillage ne peut pas etre associe a un materiau et une source a la fois.")
- # association a un materiau
- if 'MATERIAL' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
- # association a une source
- if 'SOURCE' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
- # erreur ni materiau ni source associee
- if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['STRAND'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
- if 'Domaine' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
- self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
- texte=""
- texte+="%s"%(obj.valeur['Domaine'])
- print"le texte=%s" %(texte)
- self.dictDomaine[obj.getSdname()]=texte
- print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
-
-# else:
-# raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
- if self.debug:
- print "self.dictGroupes= %s" % repr(self.dictGroupes)
- except ValueError, err:
- raise ValueError, str(err)
-
- def generMACRO_GROUPE(self, obj):
- """preparation de la ligne NAME referencant le groupe de mailles
- associe le groupe de mailles au materiau ou a la source utilisateur
- on sauvegarde aussi les noms des macros groupes
- """
- try:
- #nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
- if usePrefix:
- nomGroupe = self.nomReelGroupe(obj.getSdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
- print "liste des noms sans prefixes %s" %(nomGroupe)
- else:
- nomGroupe = obj.getSdname() # nom du macro groupe
- print "liste des noms sans prefixes %s" %(nomGroupe)
- self.dictGroupes[nomGroupe] = {}
-
- # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
- # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
- #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
- #
- # on utilise le fait que obj.valeur est un dictionnaire
- if self.debug:
- print "obj.valeur.keys()= %s" % obj.valeur.keys()
- if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
- raise ValueError, nomgroupe + tr(" : ce MACRO_GROUPE ne peut pas contenir a la fois un MATERIAL et une SOURCE.")
- # association a une source
- if 'SOURCE' in obj.valeur.keys():
- self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
- # erreur ni materiau ni source associee
- if 'LISTE_MESHGROUP' in obj.valeur.keys():
- listeStrandedInductorGeometry = True # indicateur du fait que tous les groupes de la liste sont des inducteurs bobinés ou topologiques, en morceaux ou entier (True), ou non (False). Utilisé pour savoir si le Domaine est nécessaire ou non.
- listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- self.dictGroupes[nomGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
- for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
- groupe = groupe.replace("'", "") # suppression des guillement simpes
- groupe = groupe.replace('"', "") # suppression des guillement doubles
- self.dictGroupes[nomGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
- if not self.dictGroupes[groupe].has_key('STRAND'): listeStrandedInductorGeometry = False # au moins un groupe de la liste n'est pas un inducteur bobiné ou topologique (morceau ou entier).
- self.dictGroupes['ordreListeJdC'].append(nomGroupe) # sauvegarde du nom du macro groupe associe a une source, dans l'ordre du JdC
- if not listeStrandedInductorGeometry: # Erreur en cas de liste ne définissant pas que des inducteurs bobinés ou topologiques en morceaux
- raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE ne doit contenir, dans LISTE_MESHGROUP, que des morceaux d'inducteurs bobines ou topologiques.")
- # test de présence du domaine pour les cas appropriés d'inducteur bobiné ou topologique en morceau.
- if 'Domaine' in obj.valeur.keys():
- if listeStrandedInductorGeometry: # Domaine seulement en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
- self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
- self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
- texte=""
- texte+="%s"%(obj.valeur['Domaine'])
- print"le texte=%s" %(texte)
- self.dictDomaine[obj.getSdname()]=texte
- else: # Erreur si Domaine et macro-groupe pas complètement inducteur
- raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE ne doit pas contenir de Domaine car il contient, dans LISTE_MESHGROUP, des groupes qui ne sont pas que des morceaux d'inducteurs bobines ou topologiques.")
- else: # Domaine manquant
- if listeStrandedInductorGeometry: # Erreur en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
- raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE de morceaux d'inducteurs bobines ou topologiques doit contenir aussi un Domaine.")
- else:
- raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE doit contenir une liste de groupes LISTE_MESHGROUP.")
- if self.debug:
- print "self.dictGroupes= %s" % repr(self.dictGroupes)
- print "self.dictDomaine=%s" %(self.dictDomaine)
- except ValueError, err:
- raise ValueError, str(err)
-
-
- def generSOLVEUR(self, obj):
- if self.debug:
- print "generation material obj.valeur = %s" % obj.valeur
- try :
- nature = obj.valeur['Type']
- if nature == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
- except ValueError, err:
- raise ValueError, str(err)
-
- def generSOLVEUR_LINEAIRE(self, obj):
- if self.debug:
- print "generation material obj.valeur = %s" % obj.valeur
- try :
- nature = obj.valeur['Methode_lineaire']
- if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
- if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
- except ValueError, err:
- raise ValueError, str(err)
-
- def generMETHODE_ITERATIVE_BICGCR(self, obj):
- texte=""
- if self.debug:
- print "_____________iter_____________"
-
- self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
- self.texteCarmel3D_PARAM_SOLV+=" NAME BICGCR\n"
- self.texteCarmel3D_PARAM_SOLV+=" [ITERATIVE_PARAM \n"
- self.texteCarmel3D_PARAM_SOLV+=" NITERMAX "+str(obj.valeur["Nombre_iterations_max"])+"\n"
- self.texteCarmel3D_PARAM_SOLV+=" EPSILON "+str(obj.valeur["Precision"])+"\n"
- self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
- if self.debug:
- print "texte = %s", texte
-
-
- def generMETHODE_DIRECTE_MUMPS(self, obj):
- texte=""
- if self.debug:
- print "_____________directe_____________"
-
- self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
- self.texteCarmel3D_PARAM_SOLV+=" NAME MUMPS\n"
- self.texteCarmel3D_PARAM_SOLV+=" [MUMPS_PARAMETER \n"
- self.texteCarmel3D_PARAM_SOLV+=" SYM "+str(obj.valeur["Type_de_matrice"])+"\n"
- self.texteCarmel3D_PARAM_SOLV+=" ICNTL "+str(obj.valeur["ICNTL_Control_Parameters"])+" "+str(obj.valeur["CNTL_Control_Parameters"])+"\n"
- self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
- if self.debug:
- print "texte = %s", texte
-
-
-
- def generMATERIAL(self,obj):
- """preparation du bloc correspondant a un materiau du fichier PHYS"""
- texte=""
- if self.debug:
- print "generation material obj.valeur = %s" % obj.valeur
- try :
- nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
- if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
- if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
- if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
- if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
- if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
- if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
- if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
- except ValueError, err:
- raise ValueError, str(err)
-
- def generMATERIAL_CONDUCTOR(self,obj):
- """preparation du sous bloc CONDUCTOR"""
- texte=""
- if self.debug:
- print "_____________cond_____________"
- # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
- if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
- print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.getSdname()
- raise ValueError, obj.getSdname() + tr(" : ce materiau conducteur (CONDUCTOR) doit contenir les proprietes PERMEABILITY et CONDUCTIVITY.")
- else:
- # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
- for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
- # debut du sous bloc de propriete du DIELECTRIC
- texte+=" ["+keyN1+"\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
- # car sinon ces valeurs sont definies dans des fichiers annexes
- homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
- isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
- if homogeneous and isotropic:
- # loi (lineaire ou non)
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
- # valeur de la loi lineaire
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
- # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
- # seuls les reels sont pris en compte
- if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
- texte+=" [NONLINEAR \n"
- texte+=" ISOTROPY TRUE\n"
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
- # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
- for keyN2 in obj.valeur[keyN1] :
- if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
- # fin du sous-bloc NONLINEAR
- texte+=" ]"+"\n"
- # fin du sous bloc de propriete
- texte+=" ]"+"\n"
- if self.debug:
- print "texte = %s", texte
- self.dictMaterConductor[obj.getSdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
-
- def generMATERIAL_DIELECTRIC(self,obj):
- """preparation du sous bloc DIELECTRIC"""
- texte=""
- if self.debug:
- print "______________nocond_____________"
- # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
- if 'PERMITTIVITY' not in obj.valeur:
- print "obj.valeur=%s" %obj.valeur
- obj.valeur["PERMITTIVITY"]={'HOMOGENEOUS': 'TRUE', 'LAW': 'LINEAR', 'ISOTROPIC': 'TRUE', 'VALUE': 1}
-
- # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
- for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
- # debut du sous bloc de propriete du DIELECTRIC
- texte+=" ["+keyN1+"\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
- # car sinon ces valeurs sont definies dans des fichiers annexes
- homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
- isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
- if homogeneous and isotropic:
- # loi (lineaire ou non)
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
- # valeur de la loi lineaire
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
- # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
- # seuls les reels sont pris en compte
- if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
- texte+=" [NONLINEAR \n"
- texte+=" ISOTROPY TRUE\n"
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
- # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
- for keyN2 in obj.valeur[keyN1] :
- if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
- # fin du sous-bloc NONLINEAR
- texte+=" ]"+"\n"
- # fin du sous bloc de propriete
- texte+=" ]"+"\n"
- if self.debug:
- print "texte = %s" % texte
- self.dictMaterDielectric[obj.getSdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
-
- def generMATERIAL_ZSURFACIC(self,obj):
- """preparation du sous bloc ZSURFACIC"""
- texte=""
- if self.debug:
- print "______________zsurf_____________"
- # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
- if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
- print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.getSdname()
- raise ValueError, obj.getSdname() + tr(" : ce materiau impedance de surface (ZSURFACIC) doit contenir les proprietes PERMEABILITY et CONDUCTIVITY.")
- else:
- # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
- for keyN1 in obj.valeur :
- if keyN1=='TYPE': continue
- # print "type loi = ", obj.valeur[keyN1]['LAW']
- # debut du sous bloc de propriete du DIELECTRIC
- texte+=" ["+keyN1+"\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
- # car sinon ces valeurs sont definies dans des fichiers annexes
- homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
- isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
- if homogeneous and isotropic:
- # loi (lineaire ou non)
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
- # valeur de la loi lineaire
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
- # fin du sous bloc de propriete
- texte+=" ]"+"\n"
- if self.debug:
- print "texte = %s", texte
- self.dictMaterZsurfacic[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
-
- def generMATERIAL_EMISO(self,obj):
- """preparation du sous bloc EM_ISOTROPIC_FILES.
- Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
- ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
- """
- if "CONDUCTIVITY_File" in obj.valeur:
- texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
- if "PERMEABILITY_File" in obj.valeur:
- texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
- # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
- #from os.path import basename
- #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
- #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
- # print "obj get sdname= ", obj.getSdname()
- # if obj.getSdname() in self.dictMaterEmIso.keys() :
- # self.dictMaterEmIso[obj.getSdname()].append(texte)
- # else :
- self.dictMaterEmIso[obj.getSdname()]=texte
-
- def generMATERIAL_EMANISO(self,obj):
- """preparation du sous bloc EM_ANISOTROPIC_FILES.
- Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
- ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
- """
- if "CONDUCTIVITY_File" in obj.valeur:
- texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
- if "PERMEABILITY_File" in obj.valeur:
- texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
- # print "obj get sdname= ", obj.getSdname()
- # if obj.getSdname() in self.dictMaterEmAnIso.keys() :
- # self.dictMaterEmAnIso[obj.getSdname()].append(texte)
- # else :
- self.dictMaterEmAnIso[obj.getSdname()]=texte
-
- def generMATERIAL_NILMAT(self,obj):
- """preparation du sous bloc NILMAT"""
- texte=""
- self.dictMaterNilmat[obj.getSdname()]=texte
-
- def generMATERIAL_ZINSULATOR(self,obj):
- """"preparation du sous bloc ZINSULATOR"""
- texte=""
- self.dictMaterZinsulator[obj.getSdname()]=texte
-
-#-------------------------------------------------------------------
-
- def generSOURCE(self,obj):
- """preparation du bloc correspondant a une source du fichier PHYS"""
- if self.debug:
- print "generation source obj valeur = %s" % obj.valeur
- texte=""
- try :
- # test de la presence des types de sources reconnus
- # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
- # la source ne peut contenir au plus qu'un type de source.
- if "STRANDED_INDUCTOR" in obj.valeur:
- self.generSOURCE_STRANDED_INDUCTOR(obj)
- elif "HPORT" in obj.valeur:
- self.generSOURCE_HPORT(obj)
- elif "EPORT" in obj.valeur:
- self.generSOURCE_EPORT(obj)
- else:
- print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
- except ValueError, err:
- raise ValueError, str(err)
-
- def generSOURCE_STRANDED_INDUCTOR(self,obj):
- """preparation du sous bloc STRANDED_INDUCTOR"""
- texte=""
- sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
- try :
- texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
- self.nturns=sdict['NTURNS']
- # test de la presence d'une forme de source reconnue
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
- # la source ne peut contenir au plus qu'un type de source.
- if "WAVEFORM_CONSTANT" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
- elif "WAVEFORM_SINUS" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
- self.dictSourceStInd[obj.getSdname()]=texte
- if self.debug:
- print texte
- except ValueError, err:
- raise ValueError, str(err)
-
- def generSOURCE_HPORT(self,obj):
- """preparation du sous bloc HPORT"""
- texte=""
- sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
- nomPort = obj.getSdname()
- self.dictPort[nomPort] = {}
- self.dictPort[nomPort]['HPORT']=str(sdict['TYPE'])
- try :
- texte+=" TYPE %s\n" % str(sdict['TYPE'])
- # test de la presence d'une forme de source reconnue
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
- # la source ne peut contenir au plus qu'un type de source.
- if "WAVEFORM_CONSTANT" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
- elif "WAVEFORM_SINUS" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
- self.dictSourceHport[obj.getSdname()]=texte
- if self.debug:
- print texte
- except ValueError, err:
- raise ValueError, str(err)
-
- def generSOURCE_EPORT(self,obj):
-
-
- """preparation du sous bloc EPORT"""
- texte=""
- sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
- nomPort = obj.getSdname()
- self.dictPort[nomPort] = {}
- self.dictPort[nomPort]['EPORT']=str(sdict['TYPE'])
- print "sdict=%s" %(sdict)
- try :
- texte+=" TYPE %s\n" % str(sdict['TYPE'])
- # test de la presence d'une forme de source reconnue
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
- # la source ne peut contenir au plus qu'un type de source.
- if "WAVEFORM_CONSTANT" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
- elif "WAVEFORM_SINUS" in obj.valeur:
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
- if self.problem == HARMONIC:
- texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
- self.dictSourceEport[obj.getSdname()]=texte
- if self.debug:
- print texte
- except ValueError, err:
- raise ValueError, str(err)
-
-#
- def generPARAM_CIRCULAIRE(self, obj):
- if self.debug:
- print "generation stranded inductor geometry obj.valeur = %s" % obj.valeur
- self.centre=obj.valeur["Centre"]
-
- def generPOST_COMMANDS(self, obj):
- """Création du texte de commandes de post-traitement toto.cmd"""
- if self.debug:
- print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
-
- if obj.valeur.has_key('GLOBAL'):
- self.texteCarmel3D_CMD+="[\nGLOBAL\n]\n"
-
- if obj.valeur.has_key('DUMP'):
- champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
- self.texteCarmel3D_CMD+="[\nDUMP"
- self.texteCarmel3D_CMD+="\n"+self.projet + '_postgroups.txt'
- self.texteCarmel3D_CMD+="\n"+champsFieldkind[obj.valeur["DUMP"]["fieldkind"]]+"\n]\n"
-
- if obj.valeur.has_key('FIELDDUMP'):
- champs = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD', 'pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'}
- champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
- self.texteCarmel3D_CMD+="[\nFIELDDUMP"
- if type(obj.valeur["FIELDDUMP"]) == types.DictType: # correspondance sur une 'Fielddump'
- self.fielddumpValeur.append(obj.valeur["FIELDDUMP"])
- else:
- self.fielddumpValeur=obj.valeur["FIELDDUMP"] # correspondance sur plusieurs 'Fielddump'
- for indexFielddump in self.fielddumpValeur:
- self.texteCarmel3D_CMD+="\n [\n" +" "+ champs[indexFielddump["field"]]
- self.texteCarmel3D_CMD+="\n" + " " + champsFieldkind[indexFielddump["fieldkind"]] + "\n ]"
- self.texteCarmel3D_CMD+="\n]\n"
-
-
- if obj.valeur.has_key('VISU'):
- self.texteCarmel3D_CMD+="[\nVISU"
- # test de fichier de maillage bien lu
- if self.fichierMaillage == "": raise ValueError, tr("Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au-dessus du bloc POST_COMMANDS.")
- self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
- self.texteCarmel3D_CMD+=obj.valeur["VISU"]["visu_format"]+"\n"
- self.texteCarmel3D_CMD+=obj.valeur["VISU"]["visu_type"]+"\n]\n"
-
- if obj.valeur.has_key('VISU3D'):
- champsField = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD', 'pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
- champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
- if type(obj.valeur["VISU3D"])==types.DictType: # correspondance sur une 'VISU3D'
- self.visu3dValeur.append(obj.valeur["VISU3D"])
- else:
- self.visu3dValeur=obj.valeur["VISU3D"] # correspondance sur plusieurs 'VISU3D'
- self.texteCarmel3D_CMD+="[\nVISU3D"
- if self.fichierMaillage == "": raise ValueError, tr("Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au-dessus du bloc POST_COMMANDS.")
- self.texteCarmel3D_CMD+="\n"+ self.projet
- self.texteCarmel3D_CMD+="\n" + self.visu3dValeur[0]["visu_format"]
- for indexVisu3d in self.visu3dValeur:
- if indexVisu3d["visu_format"]!=self.visu3dValeur[0]["visu_format"]:
- print "ERREUR! Dans les multiples VISU3D du bloc POST_COMMANDS, le parametre visu_format doit prendre la meme valeur."
- raise ValueError, tr("Dans les multiples VISU3D du bloc POST_COMMANDS, le parametre visu_format doit prendre la meme valeur.")
- self.texteCarmel3D_CMD+="\n [\n " + champsField[indexVisu3d["field"]]
- self.texteCarmel3D_CMD+="\n "+ champsFieldkind[indexVisu3d["fieldkind"]]
- self.texteCarmel3D_CMD+="\n "+ indexVisu3d["visu_type"]+"\n ]"
- self.texteCarmel3D_CMD+="\n]\n"
-
- if obj.valeur.has_key('ASTER_RMS_LOSSES'):
- self.texteCarmel3D_CMD+="[\nASTER_RMS_LOSSES"
- if self.fichierMaillage == "": raise ValueError, tr("Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au-dessus du bloc POST_COMMANDS.")
- self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
- self.texteCarmel3D_CMD+= obj.valeur["ASTER_RMS_LOSSES"]["rms_losses_format"] +"\n]\n"
-
- if obj.valeur.has_key('CUTLINE'):
- # création du champ, renommé par rapport à l'interface
- champsField = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD', 'pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD', 'T':'TFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
- champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
- champsOutput={'xgraphic':'XGRAPHIC', 'gnuplot':'GNUPLOT', 'gmsh':'GMSH'}
- champsLissage={'aucun':'NONE', 'un seul point par element':'1PTELT'}
- if type(obj.valeur["CUTLINE"]) == types.DictType: # correspondance sur une 'Cutline'
- self.cutlineValeur.append(obj.valeur["CUTLINE"]) # transfert d'une dictionnaire à une liste
- else:
- self.cutlineValeur=obj.valeur["CUTLINE"] # correspondance sur plusieurs 'Cutline'
- for indexCutline in self.cutlineValeur:
- self.texteCarmel3D_CMD+="[\nCUTLINE"
- self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexCutline["first_point"]), )
- self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexCutline["last_point"]), )
- self.texteCarmel3D_CMD+="\n%d" % (indexCutline["number_of_points"], )
- self.texteCarmel3D_CMD+="\n" +indexCutline["name"]
- self.texteCarmel3D_CMD+="\n" + champsField[indexCutline["field"]]
- if indexCutline.has_key('fieldkind'):
- self.texteCarmel3D_CMD+="\nFIELDKIND " + champsFieldkind[indexCutline["fieldkind"]]
- if indexCutline.has_key('output'):
- self.texteCarmel3D_CMD+="\nOUTPUT " +champsOutput[indexCutline["output"]]
- if indexCutline.has_key('lissage'):
- self.texteCarmel3D_CMD+="\nSMOOTHLEVEL " +champsLissage[indexCutline["lissage"]]
- self.texteCarmel3D_CMD+="\n]\n"
-
- if obj.valeur.has_key('CUTPLANE'):
- champs = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD','pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
- champsFieldkind= {'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
- champsOutput={'xgraphic':'XGRAPHIC', 'gnuplot':'GNUPLOT', 'gmsh':'GMSH'}
- champsLissage={'aucun':'NONE', 'un seul point par element':'1PTELT'}
- axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
- if type(obj.valeur["CUTPLANE"]) == types.DictType:
- self.cutplaneValeur.append(obj.valeur["CUTPLANE"]) # correspondance sur une 'Cutplane'
- else:
- self.cutplaneValeur=obj.valeur["CUTPLANE"] # correspondance sur plusieurs 'Cutplane'
- for indexCutplane in self.cutplaneValeur:
- self.texteCarmel3D_CMD+="[\nCUTPLANE"
- self.texteCarmel3D_CMD+="\n%d" % (axes[indexCutplane["normal_vector"]], )
- self.texteCarmel3D_CMD+="\n%f" % (indexCutplane["plane_position"], )
- self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexCutplane["number_of_points"]))
- self.texteCarmel3D_CMD+="\n" + indexCutplane["name"]
- self.texteCarmel3D_CMD+="\n" + champs[indexCutplane["field"]]
- if indexCutplane.has_key('fieldkind'):
- self.texteCarmel3D_CMD+="\nFIELDKIND " + champsFieldkind[indexCutplane["fieldkind"]]
- if indexCutplane.has_key('output'):
- self.texteCarmel3D_CMD+="\nOUTPUT " +champsOutput[indexCutplane["output"]]
- if indexCutplane.has_key('lissage'):
- self.texteCarmel3D_CMD+="\nSMOOTHLEVEL " +champsLissage[indexCutplane["lissage"]]
- self.texteCarmel3D_CMD+="\n]\n"
-
- if obj.valeur.has_key('FIELDMAP'):
- champs = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD','pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
- champsFieldkind= {'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
- champsOutput={'xgraphic':'XGRAPHIC', 'gnuplot':'GNUPLOT', 'gmsh':'GMSH'}
- champsFieldmap_type={'equation':'EQUATION', 'fichier':'FILE'}
- champsType={'plane':'PLANE', 'line':'LINE'}
- axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
- if type(obj.valeur["FIELDMAP"]) == types.DictType:
- self.fieldmapValeur.append(obj.valeur["FIELDMAP"]) # correspondance sur une 'Fieldmap'
- else:
- self.fieldmapValeur=obj.valeur["FIELDMAP"]# correspondance sur plusieurs 'Fieldmap'
- for indexFieldmap in self.fieldmapValeur:
- self.texteCarmel3D_CMD+="[\nFIELDMAP"
- self.texteCarmel3D_CMD+="\n" + champsFieldmap_type[indexFieldmap["fieldmap_type"]]
- if indexFieldmap["fieldmap_type"]=="equation":
- self.texteCarmel3D_CMD+="\n" + champsType[indexFieldmap["type"]]
- if indexFieldmap["type"]=="line":
- self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexFieldmap["first_point"]), )
- self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexFieldmap["last_point"]), )
- self.texteCarmel3D_CMD+="\n%d" % (indexFieldmap["number_of_points"], )
- if indexFieldmap["type"]=="plane":
- self.texteCarmel3D_CMD+="\n%d" % (axes[indexFieldmap["normal_vector"]], )
- self.texteCarmel3D_CMD+="\n%f" % (indexFieldmap["plane_position"], )
- self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexFieldmap["number_of_points"]))
- if indexFieldmap["fieldmap_type"]=="fichier":
- self.fichierFieldmap=indexFieldmap["filename"]
- self.nomFichierFieldmap = os.path.basename(self.fichierFieldmap) # nom du fichier de fieldmap, sans le chemin
- self.texteCarmel3D_CMD+="\n" + self.nomFichierFieldmap
- self.texteCarmel3D_CMD+="\n" + champs[indexFieldmap["field"]]
- self.texteCarmel3D_CMD+="\n" + champsFieldkind[indexFieldmap["fieldkind"]]
- self.texteCarmel3D_CMD+="\n" +indexFieldmap["name"] # nom systématique, quel que soit le fieldmap_type, placé entre fieldkind et output
- self.texteCarmel3D_CMD+="\n" +champsOutput[indexFieldmap["output"]]
- self.texteCarmel3D_CMD+="\n]\n"
-
-
-
-
-#---------------------------------------------------------------------------------------
-# traitement fichier PHYS
-#---------------------------------------------------------------------------------------
- def generBLOC_VERSION(self,obj) :
- # constitution du bloc VERSION du fichier PHYS
- # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
- # dans le du catalogue
- version=obj.addEntite('VERSION',pos=None)
- self.generPROC_ETAPE(obj.etapes[0])
- self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
- for cle in obj.etapes[0].valeur :
- self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
- self.texteCarmel3D+="]\n"
- # destruction de l entite creee
- obj.suppEntite(version)
- #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
- #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
-
-
- def generBLOC_PARAMETERS(self,obj):
- if self.debug:
- print "generation parameters obj.valeur = %s" % obj.valeur
-
- self.frequency=obj.valeur["FREQUENCY"]
- self.repertory=obj.valeur["RepCarmel"]
- self.fichierMaillage=obj.valeur["Fichier_maillage"]
- self.nomFichierMaillage = os.path.basename(self.fichierMaillage) # nom du fichier de maillage, sans le chemin
- self.projet = self.nomFichierMaillage.split(".")[0] # nom du projet, utilisé un peu partout, équivalent au nom du fichier de maillage sans l'extension
- self.echelle=obj.valeur["Echelle_du_maillage"]
- self.gendof=obj.valeur["Realiser_topologie_gendof"]
- self.fcarmel=obj.valeur["Resoudre_probleme"]
- self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
- self.formulation=obj.valeur["Formulation"]
-#----------------------------------------------------------------------------------------
- def generBLOC_MATERIALS(self) :
- """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
- Le bloc MATERIALS existe toujours !
- """
- if self.debug:
- print "cle dictionnaire materconductor : %s" % self.dictMaterConductor.keys()
- print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()
- # constitution du bloc MATERIALS du fichier PHYS
- self.texteCarmel3D+="[MATERIALS\n"
- # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
- nomsGroupes = self.dictGroupes['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
- nomsGroupes.sort() # tri alphabetique, avec les prefixes eventuels
- if self.debug:
- print "noms groupes de mailles associes a des materiaux \
- (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \
- {'v_1': self.dictGroupes['ordreMateriauxJdC'], \
- 'v_2': nomsGroupes}
- try: # mise à jour du fichier .phys selon les matériaux trouvés
- # constitution du bloc CONDUCTOR du fichier PHYS si existe
- if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupes)
- # constitution du bloc DIELECTRIC du fichier PHYS si exixte
- if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupes)
- # constitution du bloc ZSURFACIC du fichier PHYS si exixte
- if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupes)
- # constitution du bloc NILMAT du fichier PHYS si exixte
- if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupes)
- # constitution du bloc ZINSULATOR du fichier PHYS si exixte
- if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupes)
- # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
- # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
- if self.dictMaterEmIso != {} and self.materiauxGroupesTousIsotropes and not self.materiauxGroupesTousHomogenes : self.creaBLOC_EMISO() # bloc isotrope si au moins un matériau isotrope et non homogene
- # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
- if self.dictMaterEmAnIso != {} and not self.materiauxGroupesTousIsotropes : self.creaBLOC_EMANISO() # bloc non isotrope si au moins un matériau non isotrope
- except ValueError, err:
- raise ValueError(str(err))
-
-
- # fin du bloc MATERIALS du fichier PHYS
- self.texteCarmel3D+="]\n"
-
-
-
- def creaBLOC_CONDUCTOR(self, nomsGroupes) :
- """Constitution du bloc CONDUCTOR du fichier PHYS"""
- typeBloc = 'CONDUCTOR' # initialisation du type de bloc
- dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
- if self.debug:
- print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
- for nom in nomsGroupes: # parcours des noms des groupes de maillage
- if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
- print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
- raise ValueError, self.dictGroupes[nom]['MATERIAL'][:] + ',' + nom + tr(" : ce materiau (nom, groupe associe) doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement.")
- if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE' \
- or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
- self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
- if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE' \
- or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
- self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupe(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_DIELECTRIC(self, nomsGroupes) :
- """Constitution du bloc DIELECTRIC du fichier PHYS"""
- typeBloc = 'DIELECTRIC' # initialisation du type de bloc
- dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
- if self.debug:
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
- for nom in nomsGroupes: # parcours des noms des groupes de maillage
- print "jdc materiaux= %s" %(self.dictGroupes['ordreMateriauxJdC'])
- if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
- print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
- raise ValueError, self.dictGroupes[nom]['MATERIAL'][:] + ',' + nom + tr(" : ce materiau (nom, groupe associe) doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement.")
- if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
- self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
- if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
- self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_ZSURFACIC(self, nomsGroupes) :
- """Constitution du bloc ZSURFACIC du fichier PHYS"""
- typeBloc = 'ZSURFACIC' # initialisation du type de bloc
- dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
- if self.debug:
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
- for nom in nomsGroupes: # parcours des noms des groupes de maillage
- if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupe(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_EMISO(self) :
- """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
- for cle in self.dictMaterEmIso.keys():
- self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
- self.texteCarmel3D+= self.dictMaterEmIso[cle]
- self.texteCarmel3D+=" ]\n"
-
- def creaBLOC_EMANISO(self) :
- """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
- for cle in self.dictMaterEmAnIso.keys():
- self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
- self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
- self.texteCarmel3D+=" ]\n"
-
- def creaBLOC_ZINSULATOR(self, nomsGroupes) :
- """Constitution du bloc ZINSULATOR du fichier PHYS"""
- typeBloc = 'ZINSULATOR' # initialisation du type de bloc
- dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
- if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
- for nom in nomsGroupes: # parcours des noms des groupes de maillage
- if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupe(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_NILMAT(self, nomsGroupes) :
- """Constitution du bloc NILMAT du fichier PHYS"""
- typeBloc = 'NILMAT' # initialisation du type de bloc
- dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
- if self.debug:
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
- for nom in nomsGroupes: # parcours des noms des groupes de maillage
- if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupe(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]] # ecriture des proprietes du type associe
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
-#----------------------------------------------------------------------------------------
- def generBLOC_SOURCES(self):
- """constitution du bloc SOURCES du fichier PHYS"""
- self.texteCarmel3D+="[SOURCES\n"
-# # tri alphabetique de tous les groupes de maillage associes a des sources
- nomsGroupes = self.dictGroupes['ordreSourcesJdC'][:]
- nomsGroupes.sort()
- # print "RESULTAT APRES FUSION self.dictGroupes= %s" %(self.dictGroupesnomsGroupes)
-
- if self.debug:
- print 'noms groupes de mailles associes a des sources \
- (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \
- {'g_maillage_orig': self.dictGroupes['ordreSourcesJdC'], \
- 'g_maillage_trie': nomsGroupes}
- if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupes)
- if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupes)
- if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupes)
- # fin du bloc SOURCES du fichier PHYS
- self.texteCarmel3D+="]\n"
-
-
- def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupes) :
- """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
- if self.debug:
- print 'cles sources STRANDED_INDUCTOR= %s' % self.dictSourceStInd.keys()
- typeBloc = 'STRANDED_INDUCTOR'
-# print "liste des NOM=%s" %(nom)
- for nom in nomsGroupes: # parcours des noms des groupes de maillage
- if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
- # ecriture du bloc de l'inducteur bobine
- self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes de l'inducteur bobine
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_EPORT(self, nomsGroupes) :
- """constitution du bloc EPORT du fichier PHYS"""
- if self.debug:
- print 'cles sources EPORT= %s' % self.dictSourceEport.keys()
- typeBloc = 'EPORT'
- for nom in nomsGroupes: # parcours des noms des groupes de maillage
- if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
- # ecriture du bloc du port electrique
- self.texteCarmel3D+=" [EPORT\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupe(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= self.dictSourceEport[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes du port electrique
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_HPORT(self, nomsGroupes) :
- """constitution du bloc HPORT du fichier PHYS"""
- if self.debug:
- print 'cles sources HPORT= %s' % self.dictSourceHport.keys()
- typeBloc = 'HPORT'
- for nom in nomsGroupes: # parcours des noms des groupes de maillage
- if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
- # ecriture du bloc du port magnetique
- self.texteCarmel3D+=" [HPORT\n" # debut de bloc
- if usePrefix:
- nomReel = self.nomReelGroupe(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
- self.texteCarmel3D+= self.dictSourceHport[self.dictGroupes[nom]['SOURCE'][:]] # ecriture des proprietes du port magnetique
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
- """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
-
- texte=""
- self.direction=obj.valeur["Direction"]
- self.section=obj.valeur["Section"]
- self.forme=obj.valeur["Forme"]
-# texte+="\n%s" %(self.domaine)
-
- if self.forme=="Circulaire" : self.generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(obj)
- else:
- texte+="\n1"
- texte+="\n%s" % ' '.join(map(str, self.direction))
- texte+="\n%g" % (self.section)
- self.dictStrand[obj.getSdname()]=texte
- if self.debug:
- print texte
-
- def generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(self, obj):
- texte=""
- self.centre=obj.valeur["Centre"]
- texte+="\n2"
- texte+="\n%s" % ' '.join(map(str,self.direction))
- texte+="\n%s" % ' '.join(map(str, self.centre))
- texte+="\n%g" % (self.section)
- self.dictStrand[obj.getSdname()]=texte
- if self.debug:
- print texte
-
-
- def creaBLOC_STRANDED_INDUCTOR_GEOMETRY(self, nomsGroupes):
- """Ecriture de chaque inducteur bobiné dans le in.gendof. Gestion des inducteurs en un ou plusieurs morceaux, avec le domaine.
- Attention! L'argument nomSGroupes n'est pas utile ici. A supprimer. Routine à renommer aussi.
- """
- if self.debug:
- print 'dictGroupes=', self.dictGroupes
- print 'cles sources STRANDED_INDUCTOR_GEOMETRY= %s' % self.dictStrand.keys()
- print "nomsGroupes=%s" %(nomsGroupes)
- nomsSources=self.dictGroupes['ordreDomaineJdC']
- nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
- if self.debug: print"nomsSources=%s" %nomsSources
- for nom in nomsSources:
- if self.debug: print "nomSource courant=",nom
- if self.dictGroupes[nom].has_key('SOURCE'):
- if self.dictGroupes[nom]['SOURCE'] not in self.dictPort :
- if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, nom + tr(" : il manque un Domaine a cet inducteur.")
- self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
- else:
- if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, nom + tr(" : il manque un Domaine a cet inducteur.")
- self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
- if self.dictGroupes[nom].has_key('STRAND'): # inducteur en un seul morceau
- if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, nom + tr(" : il manque un Domaine a cet inducteur.")
- strand = self.dictGroupes[nom]['STRAND']
- if self.debug: print "un seul morceau : nomStrand courant=", strand
- self.texteCarmel3D_INGEND2+= self.dictStrand[strand]
- if self.dictGroupes[nom].has_key('LISTE'): # inducteur en plusieurs morceaux
- listeStrand = self.dictGroupes[nom]['LISTE'] # liste des groupes de maillage composant l'inducteur, ou groupe tout seul si inducteur en un seul morceau
- for strand in listeStrand:
- #strand = strand.replace("'", "") # suppression des guillemets simples
- if self.debug: print "plusieurs morceaux : nomStrand courant=",strand
- if self.debug: print "self.dictGroupes[strand]=", self.dictGroupes[strand]
- self.texteCarmel3D_INGEND2+= self.dictStrand[self.dictGroupes[strand]['STRAND'] ]
-
- def creaBLOC_PORTS_GEOMETRY(self, nomsGroupes):
- if self.debug:
- print "self.dictSourceEport=", self.dictSourceEport
- print "self.dictSourceHport=", self.dictSourceHport
- nomsSources=self.dictGroupes['ordreDomaineJdC']
- nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
-
- for nom in nomsSources:
- port=self.dictGroupes[nom]['SOURCE']
- if self.dictGroupes[nom]['SOURCE'] in self.dictPort :
- self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
- port=self.dictGroupes[nom]['SOURCE']
-
- if self.dictPort[port].has_key('EPORT'):# inducteur en un seul morceau
- if self.dictPort[port]['EPORT']=="VOLTAGE":
- self.texteCarmel3D_INGEND2+= "\n1"
- else:
- self.texteCarmel3D_INGEND2+= "\n2"
- if self.dictPort[port].has_key('HPORT'):# inducteur en un seul morceau
- if self.dictPort[port]['HPORT']=="VOLTAGE":
- self.texteCarmel3D_INGEND2+= "\n1"
- else:
- self.texteCarmel3D_INGEND2+= "\n2"
-
-#-------------------------------------
-# Methodes utilitaires
-# ------------------------------------
- def formateCOMPLEX(self,nbC):
- """prise en compte des differentes formes de description d un nombre complexe
- 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
- """
- if self.debug:
- print "formatage"
- print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
- nbformate =""
- if isinstance(nbC,(tuple,list)):
- if nbC[0] == "'RI'" :
- nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
- if nbC[0] == "'MP'" :
- nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
- else:
- nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
- if self.debug:
- print "nbformate : %s" % nbformate
- return nbformate
-
- def nomReelGroupe(self, nom, typeBloc=None):
- """Calcule et retourne le nom reel du groupe de maillage donne en entree,
- en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
- de bloc du fichier PHYS specifie.
- Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
- """
- from string import join
- if self.debug:
- print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
- {'nom': nom, 'use_prefix': str(usePrefix)}
- nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
- if usePrefix:
- # suppression du prefixe si present
- partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
- # les tests suivants ne generent une erreur que si le prefixe est obligatoire
- if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
- print "ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
- indiquant le type de materiau ou de source associee" % (nom, )
- elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
- print "ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable" % (nom, )
- else:
- # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
- if typeBloc is not None:
- if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
- print "ERREUR! ce type de bloc (%s) n'est pas valable" % (str(typeBloc), )
- elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
- print "ERREUR! ce groupe de maille (%(nom)s) n'a pas \
- le prefixe correct pour etre associe a un type %(type_bloc)s", \
- {'nom': nom, 'type_bloc': str(typeBloc)}
- else: # c'est bon
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
- if self.debug:
- print "ce groupe de maille (%(nom)s) a un prefixe qui \
- est supprime automatiquement pour devenir : %(nom_reel)s", \
- {'nom': nom, 'nom_reel': nomReel}
- else: # c'est bon
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
- if self.debug:
- print "ce groupe de maille (%(nom)s) a un prefixe qui \
- est supprime automatiquement pour devenir : %(nom_reel)s", \
- {'nom': nom, 'nom_reel': nomReel}
- if self.debug:
- print "... %s", nomReel
- return nomReel
+++ /dev/null
-# Exemple de script pour lire la sortie csv du banc d'intégration odysee
-#
-# Lecture des valeurs dans le csv et renvoi de la valeur après application de la fonction d'agragation max,min et moy
-
-# To get the history in python
-# print('\n'.join([str(readline.get_history_item(i + 1)) for i in range(readline.get_current_history_length())]))
-
-
-def vMax(arrayNx2):
- import numpy as np
-
- return np.apply_along_axis(max, 0, arrayNx2[:, 1]).item()
-
-
-def vMin(arrayNx2):
- import numpy as np
-
- return np.apply_along_axis(min, 0, arrayNx2[:, 1]).item()
-
-
-def vMean(arrayNx2):
- import numpy as np
- import statistics
-
- return np.apply_along_axis(statistics.mean, 0, arrayNx2[:, 1]).item()
-
-
-def vSum(arrayNx2):
- import numpy as np
-
- return np.apply_along_axis(sum, 0, arrayNx2[:, 1]).item()
-
-
-def vInitialTime(arrayNx2):
- import numpy as np
-
- # Dates on first column, Values on second one
- timeColumn = arrayNx2[:, 0]
- # Tmin=np.apply_along_axis(min, 0, timeColumn)
- # assert(arrayNx2[0,0]==Tmin)
- idxTmin = timeColumn.argmin()
- assert idxTmin == 0
-
- valTmin = arrayNx2[idxTmin][1].item()
-
- return valTmin
-
-
-def vFinalTime(arrayNx2):
- import numpy as np
-
- # Dates on first column, Values on second one
- timeColumn = arrayNx2[:, 0]
- # Tmax=np.apply_along_axis(max, 0, timeColumn)
- # assert(arrayNx2[timeColumn.size,0]==Tmax)
- idxTmax = timeColumn.argmax()
- idxMax = timeColumn.size - 1
- assert idxTmax == idxMax
-
- valTmax = arrayNx2[idxTmax][1].item()
-
- return valTmax
-
-
-def vHalfTime(arrayNx2):
- import numpy as np
-
- # Dates on first column, Values on second one
- timeColumn = arrayNx2[:, 0]
- Tmin = np.apply_along_axis(min, 0, timeColumn)
- Tmax = np.apply_along_axis(max, 0, timeColumn)
-
- Thalf = (Tmax - Tmin) / 2 + Tmin
- idxThalf = (np.abs(timeColumn - Thalf)).argmin()
- valThalf = arrayNx2[idxThalf][1].item()
-
- return valThalf
-
-
-def get_result_from_csv(
- variableName: str, functionList, filename: str = None, delimiter=","
-):
- from csv import reader
- import numpy as np
-
- transientName = "Transient duration"
-
- # ex: file_csv = "Fuel temperature@Thermalhydraulics@MAX.csv"
- if filename == None:
- filename = variableName + ".csv"
-
- with open(filename, "r") as csv_file:
- csv_reader = reader(csv_file, delimiter=delimiter)
- header = next(csv_reader)
- header_transient_name = header[1]
- header_variable_name = header[2]
- if header_variable_name != variableName:
- print(
- sys.stderr,
- "The variable name {} differs from the file's header one {}".format(
- variableName, header_variable_name
- ),
- )
- return -1 # TODO Exception ?
- if header_transient_name != transientName:
- print(
- sys.stderr,
- "The transient duration name {} differs from the file's header one {}".format(
- transientName, header_transient_name
- ),
- )
- return -1 # TODO Exception ?
-
- date_value_array = np.loadtxt(filename, delimiter=delimiter, skiprows=1)[:, 1:3]
- valList = []
- for func in functionList:
- valList.append(func(date_value_array))
- return valList
-
-
-# Fuel-temperature_Thermalhydraulics_MAX
-# value at t_initial value at t_mid value at t_final mean value cumsum value min value max value
-# MeanFirstOrder (°C): 1113.040047 1009.112047 968.544065 207597.218716 1113.040047 968.544064 1032.821984
-# StandardDeviationFirstOrder (°C): 203.302658 250.504351 255.172144 43724.195535 203.302658 256.008518 217.533311
-
-
-def write_result_from_persalys(resultNp, indexNp, resSk, outputs):
- import numpy as np
- import pandas as pnd
- from functools import reduce
-
- # resultNp = np.array([meanFirstOrder, meanSecondOrderOrder, standardDeviationFirstOrder ])
- # Lignes de résultats demandés pour toutes les fcts d'aggrégation en colonne
- # resultNp = np.array([ {optionalResultList} ])
- # Noms de lignes
- # index = ['meanFirstOrder', 'meanSecondOrderOrder', 'standardDeviationFirstOrder' ]
- # indexNp = [ {optionalResultStrList} ]
- nResult = len(indexNp)
- # Tableau skyline localisant les variables (hors fctAgg) dans le tableau de résultat global
- # resultSk = [0,7,10]
- # resSk = [ {resultSkList} ]
- nOutVar = len(resSk) - 1
-
- print("\n")
- for i in range(nOutVar):
- # Récupère les couples (fctAggrégation,Nom de variable ss fct Agg)
- # des champs de description des sorties.
- # Les sorties concernées proviennent de la section de résultatNp
- # qui doit correspondre à une même variable hors fct Agg
- fctAgg_outVarName = list(
- map(lambda o: eval(o.getDescription()), outputs[resSk[i] : resSk[i + 1]])
- )
- outVarName = fctAgg_outVarName[0][1]
- checkOutVarName = reduce(
- lambda n1, n2: n1 == n2,
- [True] + list(map(lambda o: o[1] == outVarName, fctAgg_outVarName)),
- )
- assert checkOutVarName == True
- print(outVarName)
- columns = list(map(lambda o1: o1[0], fctAgg_outVarName))
- resultDf = pnd.DataFrame(
- resultNp[:, resSk[i] : (resSk[i + 1])], index=indexNp, columns=columns
- )
- print(resultDf, "\n")
- # name_csv = str.replace(str.replace(outVarName,"@","_"),' ','-')
- name_csv = outVarName
- resultDf.to_csv(name_csv + "-uncertainty.csv")
+++ /dev/null
-# ----------------------------------
-# headerScriptPersalys
-# Parametres pour format :
-# nom de l etude, nom de l etude, nom de l etude, path pour wrapper, wrapper, nom de la fonction
-# sys.path[:0]=[{}]
-
-headerScriptPersalys = """#! /usr/bin/env python3
-# coding: utf-8
-# --------------------------------------------------------------------------
-# Script Eficas genere pour lancement Etude Probabiliste
-# ---------------------------------------------------------------------------
-# Exemple d'utilisation standalone avec salome :
-# ~/salome/appli_V9_7_0_package/salome start -k -t python3 mon_fichier_uq_genere.py
-# ou
-# ~/salome/appli_V9_7_0_package/salome start -k -t
-# ~/salome/appli_V9_7_0_package/salome shell python3 mon_fichier_uq_genere.py
-
-# Chargement du module systeme
-import sys
-import os
-
-# Chargement du module OpenTURNS #TODO : Parametrer OpenTurns/Uranie
-import openturns as ot
-import persalys
-
-"""
-
-# def run_case(self):
-# """
-# Launch the calculation once the case files are ready.
-# """
-# command = './run.sh '
-# command += './syrthes.py -n ' + str(self.nproc) + ' -d ' + self.comm_file
-# command += ' >' + os.path.join(self.workdir, "std.log")
-# command += ' 2>' + os.path.join(self.workdir, "err.log")
-# os.system(command)
-# pass
-
-
-# ----------------------------------
-# etudeScript
-etudeScript = """
-class Study:
- import os
- import subprocess
-
- def __init__(self, {chaineDesVariablesInput}):
- {chaineInitDesVariablesInput}
-
- def do_sh(self, command, execdir=os.getcwd()):
- print('Execution directory is : ', execdir)
- import subprocess
- sh = subprocess.Popen(command, shell=True, cwd=execdir,
- stdout=subprocess.PIPE,
- stderr=subprocess.STDOUT)
- out, err = sh.communicate()
- return out, err, sh.poll()
-
- #TODO : Définir un décorateur pour sélectionner la fonction voulue
- def define_workdirectory(self):
- from incertainty_tools import value_repr_name
- self.workdir = value_repr_name([{chaineSelfDesVariablesInput}])
-
- def case_exists(self):
- ok = True
- if os.path.isdir(self.workdir):
- try:
- ok = False #TODO
- except:
- ok = False
- else:
- ok = False
- return ok
-
- def prepare_case(self):
- from incertainty_tools import replace_data
- import shutil
-
- if not os.path.isdir(self.workdir):
- os.mkdir(self.workdir)
-
- #section spécifique au code de calcul
- comm_file_balise = '{commFileBalise}'
-
- self.nproc = {nproc} # La présence de cette variable dépend
- # du mode de lancement MPI
- # S'il est géré par le script appelé à partir du MDD, il est inutile de le stocker
- self.comm_file_balise = os.path.join(self.workdir, comm_file_balise)
- shutil.copy(comm_file_balise, self.comm_file_balise)
-
- self.comm_file = os.path.join(self.workdir, '{commFile}')
- replace_data(self.comm_file_balise, {{ {replaceDataList} }} , self.comm_file)
- #TODO: Lancer la validation du fichier généré avant tout lancement : Le banc le fait
-
- pass
-
- def get_result_from_csv(self,postProcessedVar, aggregationFctList):
- from post_csv_rn import get_result_from_csv
- #TODO: Fonctions a implementer dans un fichier post_csv provenant
- # de la mise en donnée pour définir la façon d'aggréger les valeurs
- from post_csv_rn import vInitialTime, vHalfTime, vFinalTime, vMean, vSum, vMin, vMax
-
- savdir=os.getcwd()
- os.chdir(self.workdir)
- results = get_result_from_csv(postProcessedVar, aggregationFctList)
- os.chdir(savdir)
- return results
-
- def run_case(self):
- #os.chdir(self.workdir)
- # Si lancement mpi externe à ib_test.sh il faut utiliser self.nproc : mpiexec -n self.nproc ib_test.sh
- #o,e,c = self.do_sh(command="ib_test.sh", execdir=self.workdir)
- command="{uncertaintyScript} {uncertaintyScriptParameters}"
- o,e,c = self.do_sh(command=command, execdir=self.workdir)
- if o != None : print(o.decode())
- if e != None : print(e.decode())
- if c != 0:
- raise Exception(' Study::run_case : Execution error : cd ' +
- os.path.join('{workDirectory}',self.workdir) +
- ' && '+ os.path.join('../','{uncertaintyScript}') +
- ' '+ '{uncertaintyScriptParameters}')
-
-"""
-
-# /home/C65845/VIMMP/Banc_integration.newer_odysee/environment/bin/python3 /home/C65845/VIMMP/Banc_integration.newer_odysee/environment/bin/ib-run --cocagne-neutro-solver SPN --cocagne-thermo-solver THERMOMI/TRMIC -- /home/C65845/VIMMP/Banc_integration.newer_odysee/integration_bench/tests/control_rod_ejection_small_core_cathare3_cocagne.comm /home/C65845/VIMMP/Banc_integration.newer_odysee/integration_bench/tests/control_rod_ejection_small_core_cathare3_cocagne_spn_thermomi-trmic_serial
-
-getResultCall = """ {variableOutputList}, = study.get_result_from_csv( '{nomVarPostraite}', [{fonctionAggregationList}] )
- print( '{nomVarPostraite}: ({variableOutputList})',{variableOutputList})
-"""
-
-getResultCallAvoidPersalysBug = """ {variableOutputList}, = study.get_result_from_csv( '{nomVarPostraite}', [{fonctionAggregationList}] )
-
- print( '{nomVarPostraite}: ({variableOutputList})',{variableOutputList})
-
- #Contournement Bug Persalys sur la longueur de la chaine retour
- {shortVariableOutputList} = {variableOutputList}
-
-"""
-
-# -------------------------
-# fonctionPersalys
-# ------------------------
-fonctionPersalys = """
-def _exec({chaineDesVariablesInput}):
- from post_csv_rn import vInitialTime, vHalfTime, vFinalTime, vMean, vSum, vMin, vMax
- from {currentFile} import Study
-
- study = Study({chaineDesVariablesInput})
- study.define_workdirectory()
- if not study.case_exists():
- study.prepare_case()
- study.run_case()
-
-{getAllResults}
- return {chaineDesVariablesOutput}
-"""
-
-# ------------------------
-# codePersalys
-# ------------------------
-codePersalys = """
-code = '''
-{fonctionPersalys}
-'''
-"""
-
-# ----------------------------
-# inputHeaderPersalys
-# ----------------------------
-inputHeaderPersalys = """
-{indent}# definition des Inputs
-{indent}# ---------------------
-"""
-
-# inputPersalysUniform='{}{} = persalys.Input({}, {})'
-# inputPersalys='{}{} = persalys.Input({}, {})'
-
-# ------------------------------
-# ouputHeaderPersalys
-# ------------------------------
-outputHeaderPersalys = """
-{indent}# definition des Outputs
-{indent}# ----------------------
-"""
-
-# ------------------
-# mainPersalys
-# ------------------
-mainPersalys = """
-# ------------------
-# definition du main
-# ------------------
-if __name__ == '__main__':
-
- from datetime import datetime
-
- {nomEtude} = persalys.Study('{nomEtude}')
- persalys.Study.Add({nomEtude})
-
-{inputVariableInitList}
-{outputVariableInitList}
-
-{inputHeaderPersalys}
- inputs = [{chaineDesVariablesInput}]
- nInputs = len(inputs)
-
-{outputHeaderPersalys}
- outputs = [{chaineDesVariablesOutput}]
- nOutputs = len(outputs)
-
- yacsPhysicalModel = persalys.YACSPhysicalModel('PhysicalModel', inputs, outputs, code)
-{yacsJobParameters}
- {nomEtude}.add(yacsPhysicalModel)
-
-{centralTendencyPersalys}
- {nomEtude}.add(centralTendency)
-
-################ CUT THE FILE HERE IF YOU WANT TO IMPORT IT IN THE SALOME PERSALYS MODULE ################
-
- head_study = str(datetime.now()) +" {scenarioType} "+""
-
- centralTendency.run()
-{resultPersalys}
-
-"""
-# a = persalys.Input('a', 0, '')
-# b = persalys.Input('b', 0, '')
-# d = persalys.Output('d', '')
-# inputs = [a, b]
-# outputs = [d]
-
-# empiricalMean = ot.Sample(result.getMean())[nInputs:]
-# empiricalStandardDeviation = ot.Sample(result.getStandardDeviation())[nInputs:]
-# resultNp.reshape(nbindex,nbsorties)
-
-printResultMC = """ import numpy as np
- sys.path.append(os.path.abspath('{post_csv_rnPath}'))
- from {post_csv_rnScript} import write_result_from_persalys
-
- #Noms de lignes
- #index = ['meanFirstOrder', 'meanSecondOrderOrder', 'standardDeviationFirstOrder' ]
- indexNp = [ {optionalResultStrList} ]
- nResult = len(indexNp)
-
- #resultNp = np.array([meanFirstOrder, meanSecondOrderOrder, standardDeviationFirstOrder ])
- #Lignes de résultats demandés pour toutes les fcts d'aggrégation en colonne
- resultNp = np.array([ {optionalResultList} ])
- resultNp = resultNp.reshape(nResult, nOutputs) #En MC à cause du ot.Sample( PointsCollection) il y a un niveau de liste en trop
-
- #Tableau skyline localisant les variables (hors fctAgg) dans le tableau de résultat global
- # ex pour deux variables et respectivement 7 et 3 fcts aggrégation : resultSk = [0,7,10]
- #nOutVar = len(resSk)-1
- resSk = [ {resultSkList} ]
-
- print('\\n\\n')
- print('*********************************************************************************\\n')
- print(' UNCERTAINTY QUANTIFICATION RESULTS\\n')
-
- print(head_study,'\\n')
-
- print('Uncertain inputs list :','\\n')
- print(
-{Uncertain_inputs}'\\n'
- )
- print('\\nElapsed Time : ', centralTendency.getElapsedTime(),'\\n') #Monte Carlo ou Taylor
-
- print('\\nDesign of Experiment :')
- print(result.getDesignOfExperiment().getInputSample(),'\\n') #TODO: générer un fichier csv
-
- print('\\nCoefficient of Variation :')
- print(ot.Sample(result.getCoefficientOfVariation())[nInputs:],'\\n') #TODO: générer un fichier csv
- write_result_from_persalys(resultNp, indexNp, resSk, outputs)
-
- print('\\n*********************************************************************************\\n')
-"""
-
-
-printResultTaylor = """ import numpy as np
- sys.path.append(os.path.abspath('{post_csv_rnPath}'))
- from {post_csv_rnScript} import write_result_from_persalys
-
- #resultNp = np.array([meanFirstOrder, meanSecondOrderOrder, standardDeviationFirstOrder ])
- #Lignes de résultats demandés pour toutes les fcts d'aggrégation en colonne
- resultNp = np.array([ {optionalResultList} ])
-
- #Noms de lignes
- #index = ['meanFirstOrder', 'meanSecondOrderOrder', 'standardDeviationFirstOrder' ]
- #nResult = len(indexNp)
- indexNp = [ {optionalResultStrList} ]
-
- #nResult = len(indexNp)
-
- #Tableau skyline localisant les variables (hors fctAgg) dans le tableau de résultat global
- # ex pour deux variables et respectivement 7 et 3 fcts aggrégation : resultSk = [0,7,10]
- #nOutVar = len(resSk)-1
- resSk = [ {resultSkList} ]
-
- print('\\n\\n')
- print('*********************************************************************************\\n')
- print(' UNCERTAINTY QUANTIFICATION RESULTS\\n')
-
- print(head_study,'\\n')
-
- print('Uncertain inputs list :','\\n')
- print(
-{Uncertain_inputs}'\\n'
- )
- print('\\nElapsed Time : ', centralTendency.getElapsedTime(),'\\n') #Monte Carlo ou Taylor
-
- # print('\\nDesign of Experiment :')
- # print(result.getDesignOfExperiment().getInputSample(),'\\n') #TODO: Activer uniquement en MC + fichier csv
-
- # print('\\nCoefficient of Variation :')
- # print(result.getCoefficientOfVariation(),'\\n') #TODO: Activer uniquement en MC + fichier csv
- write_result_from_persalys(resultNp, indexNp, resSk, outputs)
-
- print('\\n*********************************************************************************\\n')
-"""
-
-## Tendance Centrale Taylor
-centralTendencyTaylor = """
- centralTendency = persalys.TaylorExpansionMomentsAnalysis('centralTendencyTaylor', yacsPhysicalModel)
-"""
-
-# Le result est une liste de taille <nombre de variables de sortie>
-resultTaylor = """
- result = centralTendency.getResult()
-{optionalResult}
-
-"""
-
-optionalResultTaylor = {
- "MeanFirstOrder": "meanFirstOrder = result.getMeanFirstOrder()",
- "StandardDeviationFirstOrder": "standardDeviationFirstOrder = result.getStandardDeviation()",
- "MeanSecondOrder": "meanSecondOrder = result.getMeanSecondOrder()",
- "Variance": "variance = result.getVariance()",
-}
-optionalPrintResultTaylor = {
- "MeanFirstOrder": 'print("MeanFirstOrder : ",meanFirstOrder)',
- "StandardDeviationFirstOrder": 'print("StandardDeviationFirstOrder :",standardDeviationFirstOrder)',
- "MeanSecondOrder": 'print("MeanSecondOrder :",meanSecondOrder)',
- "Variance": 'print("Variance :",variance)',
-}
-
-## Tendance Centrale MC
-centralTendencyMC = """
- centralTendency = persalys.MonteCarloAnalysis('centralTendencyMC', yacsPhysicalModel)
-{critereArretMC}
-{advancedParameterMC}
- centralTendency.setBlockSize({BlockSize})
-"""
-
-critereArretMC = {
- "SimulationsNumber": "centralTendency.setMaximumCalls({SimulationsNumber})",
- "MaximumElapsedTime": "centralTendency.setMaximumElapsedTime({MaximumElapsedTime})",
- "Accuracy": "centralTendency.setMaximumCoefficientOfVariation({Accuracy})",
-}
-
-advancedParameterMC = {
- "Seed": "centralTendency.setSeed({Seed})", # TODO : A ajouter dans le catalogue
- "ComputeConfidenceIntervalAt": "centralTendency.setLevelConfidenceInterval({ComputeConfidenceIntervalAt})",
-}
-
-# TODO: Gérer les unités
-resultMC = """
- result = centralTendency.getResult()
-{optionalResult}
-"""
-
-optionalResultMC = {
- "EmpiricalMean": "empiricalMean = ot.Sample(result.getMean())[nInputs:]", # En MC les inputs apparaissent en début de résultat !
- "Variance": "variance = ot.Sample(result.getVariance())[nInputs:]", # et on utilise ot.Sample pour accéder aux valeurs des Points
- "EmpiricalStandardDeviation": "empiricalStandardDeviation = ot.Sample(result.getStandardDeviation())[nInputs:]", # Idem.
- "EmpiricalQuantile": """
- designOfExperiment=result.getDesignOfExperiment()
- outputSample=designOfExperiment.getOutputSample()
- empiricalQuantile_Order = {EmpiricalQuantile_Order}
- empiricalQuantile=outputSample.computeQuantile(empiricalQuantile_Order)
- """,
-}
-
-optionalPrintResultMC = {
- "EmpiricalMean": 'print("EmpiricalMean : ", empiricalMean)',
- "Variance": 'print("Variance : ", variance)',
- "EmpiricalStandardDeviation": 'print("EmpiricalStandardDeviation : ",empiricalStandardDeviation)',
- "EmpiricalQuantile": 'print("EmpiricalQuantile : ",empiricalQuantile)',
- "EmpiricalQuantile_Order": 'print("EmpiricalQuantile_Order : ",empiricalQuantile_Order)',
-}
-
-
-# designOfExperiment=result.getDesignOfExperiment()
-# outputSample=designOfExperiment.getOutputSample()
-# computeQuantile=outputSample.computeQuantile(empiricalQuantile_Order)
-# ##isample=designOfExperiment.getSample()
-# ##computeQuantile=sample.computeQuantile(0.95)
-# ##nputSample=designOfExperiment.getInputSample()
-# ##computeQuantile=inputSample.computeQuantile(0.95)
-
-
-# En local le nombre de procs est inutile
-# TODO: S'il on peut récupérer les fichiers .csv des tirages,
-# il faut ajouter une ligne out_files
-yacsJobParameters = """
- yacsPhysicalModel.jobParameters().salome_parameters.resource_required.name = '{resourceName}'
- yacsPhysicalModel.jobParameters().salome_parameters.job_name = '{nomEtude}'
- yacsPhysicalModel.jobParameters().salome_parameters.work_directory = '{workDirectory}'
- yacsPhysicalModel.jobParameters().salome_parameters.result_directory = '{resultDirectory}'
- yacsPhysicalModel.jobParameters().salome_parameters.in_files = {inFiles} # Chemins des fichiers locaux à copier dans work_directory
- yacsPhysicalModel.jobParameters().nb_branches = {nbBranches} # nombre de jobs parallèles
-"""
-
-# Le nombre de procs du job manager est uniquement utile pour les clusters
-yacsJobClusterParameters = """
- yacsPhysicalModel.jobParameters().salome_parameters.resource_required.nb_proc = {nprocs}
- yacsPhysicalModel.jobParameters().salome_parameters.wckey = '{wckey}'
-"""
-
-# Ces 3 lignes permettent de modifier le mode d'évaluation par défaut qui est
-# d'avoir toutes les évaluations dans un seul job.
-# Ici <nb_branches> jobs seront crées dynamiquement pour lancer chaque évaluation
-# chaque job demandera la réservation de nprocs processus.
-yacsJobClusterMultiJob = """
- import pydefx
- multiJobModel = pydefx.MultiJobStudy() # mode un job par évaluation
- yacsPhysicalModel.setJobModel(multiJobModel)
-"""
-
-# yacsJobParametersRef="""
-# yacsPhysicalModel.jobParameters().salome_parameters.job_name = '{nomEtude}_idefix_job'
-# yacsPhysicalModel.jobParameters().salome_parameters.work_directory = '/scratch/C65845/workingdir/persalys_light'
-# yacsPhysicalModel.jobParameters().salome_parameters.result_directory = '/tmp/local_result'
-# yacsPhysicalModel.jobParameters().salome_parameters.resource_required.name = 'gaia'
-# yacsPhysicalModel.jobParameters().salome_parameters.resource_required.nb_proc = 1
-# yacsPhysicalModel.jobParameters().salome_parameters.wckey = 'P11N0:SALOME'
-# yacsPhysicalModel.jobParameters().salome_parameters.in_files = [] # Chemins des fichiers locaux à copier dans work_directory
-# yacsPhysicalModel.jobParameters().nb_branches = 3 # nombre de jobs parallèles
-
-# # Ces 4 lignes permettent de modifier le mode d'évaluation par défaut qui est
-# # d'avoir toutes les évaluations dans un seul job.
-# import pydefx
-# import os
-# myModel = pydefx.MultiJobStudy() # mode un job par évaluation
-
-# PhysicalModel.setJobModel(myModel)
-# """
-
-
-if __name__ == "__main__":
- pass
