From 4dcb43451212aea0a48759f497b1c7daea9c6594 Mon Sep 17 00:00:00 2001 From: "pascale.noyret" Date: Wed, 6 Sep 2017 14:47:05 +0200 Subject: [PATCH] src/EFICASGUI/EFICASGUI.py --- src/EFICASGUI/colors.py | 24 +- src/EFICASGUI/eficasSalome.py | 1039 +++++++++++++++------------------ src/STUDY/EficasStudy.py | 677 +++++++++++---------- 3 files changed, 811 insertions(+), 929 deletions(-) diff --git a/src/EFICASGUI/colors.py b/src/EFICASGUI/colors.py index 7a2eccdd..deceb5e0 100644 --- a/src/EFICASGUI/colors.py +++ b/src/EFICASGUI/colors.py @@ -1,18 +1,18 @@ # Liste de couleurs pour visualisation -RED = 255,0,0 -GREEN = 0,255,0 -BLUE = 0,0,255 -SANDY = 255,0,128 -ORANGE = 255,128,0 -PURPLE = 128,0,255 -DARK_RED = 128,0,0 +RED = 255,0,0 +GREEN = 0,255,0 +BLUE = 0,0,255 +SANDY = 255,0,128 +ORANGE = 255,128,0 +PURPLE = 128,0,255 +DARK_RED = 128,0,0 DARK_GREEN = 0,128,0 -DARK_BLUE = 0,0,128 -YELLOW = 255,255,0 -PINK = 255,0,255 -CYAN = 0,255,255 +DARK_BLUE = 0,0,128 +YELLOW = 255,255,0 +PINK = 255,0,255 +CYAN = 0,255,255 -ListeColors= (RED, GREEN, BLUE, SANDY,ORANGE , PURPLE, DARK_RED,DARK_GREEN,DARK_BLUE,YELLOW,PINK,CYAN ) +ListeColors = (RED, GREEN, BLUE, SANDY, ORANGE, PURPLE, DARK_RED, DARK_GREEN, DARK_BLUE, YELLOW, PINK, CYAN) diff --git a/src/EFICASGUI/eficasSalome.py b/src/EFICASGUI/eficasSalome.py index 6e03fbd2..0f8aff20 100644 --- a/src/EFICASGUI/eficasSalome.py +++ b/src/EFICASGUI/eficasSalome.py @@ -1,425 +1,367 @@ # -*- coding: utf-8 -*- -#_____________________________________ -import sys, os, re,types +import os +import re +import sys import traceback -from PyQt5.QtWidgets import QMessageBox + from PyQt5.QtWidgets import QApplication +from PyQt5.QtWidgets import QMessageBox from salome.kernel.logger import Logger -logger = Logger( "EFICAS_SRC.EFICASGUI.eficasSalome.py" ) +logger = Logger("EFICAS_SRC.EFICASGUI.eficasSalome.py") -import eficasConfig +import eficasConfig # eficasConfig definit le EFICAS_ROOT # lignes de path ajoutees pour acceder aux packages python du # logiciel Eficas. Le package Aster est ajoute explicitement pour # acceder au module prefs.py. A # ajout de InterfaceQT4 pour permettre l acces a la fenetre Option -sys.path[:0]=[eficasConfig.eficasPath, - os.path.join( eficasConfig.eficasPath,'Editeur'), - os.path.join( eficasConfig.eficasPath,'UiQT5'), - os.path.join( eficasConfig.eficasPath,'InterfaceQT4'), - #os.path.join( eficasConfig.eficasPath,'Extensions'), - eficasConfig.eficasPath, - ] - - -import Editeur +sys.path[:0] = [eficasConfig.eficasPath, + os.path.join(eficasConfig.eficasPath, 'Editeur'), + os.path.join(eficasConfig.eficasPath, 'UiQT5'), + os.path.join(eficasConfig.eficasPath, 'InterfaceQT4'), + # os.path.join( eficasConfig.eficasPath,'Extensions'), + eficasConfig.eficasPath, + ] + +import Editeur from InterfaceQT4 import qtEficas import salome import SalomePyQt sgPyQt = SalomePyQt.SalomePyQt() -langue=str(sgPyQt.stringSetting("language","language")) - +langue = str(sgPyQt.stringSetting("language", "language")) from salome.kernel.studyedit import getStudyEditor - -# couleur pour visualisation des geometries +# couleur pour visualisation des geometries import colors COLORS = colors.ListeColors -LEN_COLORS = len( COLORS ) +LEN_COLORS = len(COLORS) from Extensions import localisation -localisation.localise(None,langue) +localisation.localise(None, langue) -class MyEficas( qtEficas.Appli ): +class MyEficas(qtEficas.Appli): """ Classe de lancement du logiciel EFICAS dans SALOME - Cette classe specialise le logiciel Eficas par l'ajout de: + Cette classe specialise le logiciel Eficas par l'ajout de: a)la creation de groupes de mailles dans le composant SMESH de SALOME b)la visualisation d'elements geometrique dans le coposant GEOM de SALOME par selection dans EFICAS """ - def __init__( self, parent, code = None, fichier = None, module = "EFICAS", - version = None, componentName = "Eficas",multi=False,lang=None): + def __init__(self, parent, code=None, fichier=None, module="EFICAS", + version=None, componentName="Eficas", multi=False, lang=None): """ Constructeur. - @type parent: + @type parent: @param parent: widget Qt parent @type code: string - @param code: catalogue a lancer + @param code: catalogue a lancer @type fichier: string @param fichier: chemin absolu du fichier eficas a ouvrir a das le lancement. optionnel """ - #dictPathCode={'ADAO':'Adao','MT':'MT','CARMEL3D':'Carmel3D', 'CF':'CF', - # 'SPECA':'SPECA','MAP':'MAP','SEP':'SEP', 'TELEMAC':'Telemac', - # 'pytel' : 'pytel', 'telemac2d' : 'telemac2dSalome','coupling1d2d':'coupling1d2d', - # 'mascaret':'mascaret','boundary_conditions':'boundary_conditions'} + dictPathCode = {'ADAO': 'Adao', 'MT': 'MT', 'CARMEL3D': 'Carmel3D', 'CF': 'CF', + 'SPECA': 'SPECA', 'MAP': 'MAP', 'SEP': 'SEP', 'TELEMAC': 'Telemac'} - dictPathCode={'ADAO':'Adao','MT':'MT','CARMEL3D':'Carmel3D', 'CF':'CF', - 'SPECA':'SPECA','MAP':'MAP','SEP':'SEP', 'TELEMAC':'Telemac'} + if code in dictPathCode: + pathCode = dictPathCode[code] + sys.path[:0] = [os.path.join(eficasConfig.eficasPath, pathCode)] - if code in dictPathCode.keys(): - pathCode=dictPathCode[code] - sys.path[:0]=[os.path.join(eficasConfig.eficasPath,pathCode)] - - if Editeur.__dict__.has_key( 'session' ): + if 'session' in Editeur.__dict__: from Editeur import session eficasArg = [] - eficasArg += sys.argv + eficasArg += sys.argv if fichier: - eficasArg += [ fichier ] + eficasArg += [fichier] if version: - eficasArg += [ "-c", version ] - #else : - # print "noversion" - session.parse( eficasArg ) - - self.editor = getStudyEditor() # Editeur de l'arbre d'etude - - if lang!=None : langue=lang - else : langue=str(sgPyQt.stringSetting("language","language")) - - qtEficas.Appli.__init__( self,code=code,salome=1,parent=parent,multi=multi,langue=langue) - - #--------------- specialisation EFICAS dans SALOME ------------------- - self.parent = parent - self.salome = True #active les parties de code specifique dans Salome( pour le logiciel Eficas ) - self.module = module #indique sous quel module dans l'arbre d'etude ajouter le JDC. + eficasArg += ["-c", version] + # else: + # print("noversion") + session.parse(eficasArg) + + self.editor = getStudyEditor() # Editeur de l'arbre d'etude + + langue = lang or str(sgPyQt.stringSetting("language", "language")) + + qtEficas.Appli.__init__(self, code=code, salome=1, parent=parent, multi=multi, langue=langue) + + # --------------- specialisation EFICAS dans SALOME ------------------- + self.parent = parent + self.salome = True # active les parties de code specifique dans Salome( pour le logiciel Eficas ) + self.module = module # indique sous quel module dans l'arbre d'etude ajouter le JDC. self.componentName = componentName - + # donnee pour la creation de groupe de maille - self.mainShapeNames = {} #dictionnaire pour gerer les multiples fichiers possibles ouverts par - #eficas ( cle = identifiant du JDC ), une mainshape par fichier ouvert. - #dictionnaire des sous-geometrie de la geometrie principale ( cle = entry, valeur = name ) - #---------------------------------------------------------------------- - + # dictionnaire pour gerer les multiples fichiers possibles ouverts par + # eficas ( cle = identifiant du JDC ), une mainshape par fichier ouvert. + # dictionnaire des sous-geometrie de la geometrie principale ( cle = entry, valeur = name ) + self.mainShapeNames = {} + # ---------------------------------------------------------------------- + self.icolor = 0 # compteur pour memoriser la couleur courante self.show() - - - def closeEvent(self,event): - res=self.fileExit() - if res==2 : - event.ignore() - return - if hasattr(self,'readercata') : - del self.readercata - import math - try: - import Numeric - except: - import numpy - Numeric = numpy + + def closeEvent(self, event): + res = self.fileExit() + if res == 2: + event.ignore() + return + if hasattr(self, 'readercata'): + del self.readercata from Extensions.param2 import originalMath - #Numeric.cos=originalMath.numeric_ncos - #Numeric.sin=originalMath.numeric_nsin - #Numeric.array=originalMath.numeric_narray - #math.sin=originalMath.sin - #math.cos=originalMath.cos - #math.sqrt=originalMath.sqrt - #math.ceil=originalMath.ceil - #math.pi=originalMath.pi originalMath.toOriginal() global appli appli = None event.accept() - - + # ___________________________ Methodes de l ex Pal __________________________________ - #---------------------------------------------------------------- - def getCORBAObjectInComponent( self, entry, composant ): - #---------------------------------------------------------------- - object = None - mySO = self.editor.study.FindObjectID(entry) - if mySO: - object = mySO.GetObject() - if not object: - myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", composant) - SCom = self.editor.study.FindComponent( composant ) - print myComponent , SCom - self.editor.builder.LoadWith( SCom , myComponent ) - object = mySO.GetObject() - if not object : - logger.debug("selectedEntry: An error occurs") - return object - - - #---------------------------------------------- - def giveMeshGroups( self,entry,label1,typeMesh): - #---------------------------------------------- - msg=None - names=[] - import SMESH - try: - monMaillage =self.getCORBAObjectInComponent(entry,"SMESH") - if monMaillage != None : # selection d'un groupe de SMESH - if monMaillage._narrow(SMESH.SMESH_Mesh): - mailSO = self.editor.study.FindObjectID(entry) - if mailSO == None : return names, msg - - - subIt = self.editor.study.NewChildIterator(mailSO) - while subIt.More(): - subSO = subIt.Value() - subIt.Next() - - if (subSO.GetName()[0:9]!=label1) : continue - subSSMeshit=self.editor.study.NewChildIterator(subSO) - while subSSMeshit.More(): - subSSMeshSO = subSSMeshit.Value() - subSSMeshit.Next() - if subSSMeshSO.GetObject()._narrow(typeMesh): - names.append(subSSMeshSO.GetName()) - else : - msg=entry + self.tr(" n est pas un maillage") - except : - logger.debug(' giveMeshGroups pb avec ( entry = %s ) ' %entry ) - msg=' giveMeshGroup pb avec ( entry = %s ) '+ entry - return names, msg - - #------------------------------------- - def isMeshGroup( self,entry): - #------------------------------------- - result=False - import SMESH - try: - monObjet =self.getCORBAObjectInComponent(entry,"SMESH") - if monObjet != None : # selection d'un groupe de SMESH - if monObjet._narrow(SMESH.SMESH_GroupBase): - result = True - except : - logger.debug(' isMeshGroup pb avec ( entry = %s ) ' %entry ) - return result - - #------------------------------------- - def isMesh( self,entry): - #------------------------------------- - result=False - import SMESH - try: - monObjet =self.getCORBAObjectInComponent(entry,"SMESH") - if monObjet != None : # selection d'un groupe de SMESH - if monObjet._narrow(SMESH.SMESH_Mesh): - result = True - except : - logger.debug(' isMesh pb avec ( entry = %s ) ' %entry ) - return result - - #------------------------------------- - def getMesh( self,entry): - #------------------------------------- - meshObject=None - import SMESH - try: - #if 1 : - monObjet =self.getCORBAObjectInComponent(entry,"SMESH") - if monObjet != None : # selection d'un groupe de SMESH - meshObject=monObjet._narrow(SMESH.SMESH_Mesh) - except : - logger.debug(' pb avec ( entry = %s ) ' %entry ) - return meshObject - - #------------------------------------- - - #------------------------------------- - def isShape( self,entry): - #------------------------------------- - result=False - import GEOM - try: - monObjet =self.getCORBAObjectInComponent(entry,"GEOM") - if monObjet != None : # selection d'un objet GEOM - if monObjet._narrow(GEOM.GEOM_Object ): - result = True - except : - logger.debug(' isShape pb avec ( entry = %s ) ' %entry ) - return result - - #----------------------------------------------------------------- - def getMainShapeEntry(self,entry): - #----------------------------------------------------------------- - result=None + def getCORBAObjectInComponent(self, entry, composant): + sobject = None + mySO = self.editor.study.FindObjectID(entry) + if mySO: + sobject = mySO.GetObject() + if not object: + myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", composant) + SCom = self.editor.study.FindComponent(composant) + print(myComponent, SCom) + self.editor.builder.LoadWith(SCom, myComponent) + sobject = mySO.GetObject() + if not sobject: + logger.debug("selectedEntry: An error occurs") + return sobject + + def giveMeshGroups(self, entry, label1, typeMesh): + msg = None + names = [] + import SMESH + try: + monMaillage = self.getCORBAObjectInComponent(entry, "SMESH") + if monMaillage is not None: # selection d'un groupe de SMESH + if monMaillage._narrow(SMESH.SMESH_Mesh): + mailSO = self.editor.study.FindObjectID(entry) + if mailSO is None: + return names, msg + + subIt = self.editor.study.NewChildIterator(mailSO) + while subIt.More(): + subSO = subIt.Value() + subIt.Next() + + if (subSO.GetName()[0:9] != label1): + continue + subSSMeshit = self.editor.study.NewChildIterator(subSO) + while subSSMeshit.More(): + subSSMeshSO = subSSMeshit.Value() + subSSMeshit.Next() + if subSSMeshSO.GetObject()._narrow(typeMesh): + names.append(subSSMeshSO.GetName()) + else: + msg = entry + self.tr(" n est pas un maillage") + except: + logger.debug(' giveMeshGroups pb avec ( entry = %s ) ' % entry) + msg = ' giveMeshGroup pb avec ( entry = %s ) ' + entry + return names, msg + + def isMeshGroup(self, entry): + result = False + import SMESH + try: + monObjet = self.getCORBAObjectInComponent(entry, "SMESH") + if monObjet is not None: # selection d'un groupe de SMESH + if monObjet._narrow(SMESH.SMESH_GroupBase): + result = True + except: + logger.debug(' isMeshGroup pb avec ( entry = %s ) ' % entry) + return result + + def isMesh(self, entry): + result = False + import SMESH + try: + monObjet = self.getCORBAObjectInComponent(entry, "SMESH") + if monObjet is not None: # selection d'un groupe de SMESH + if monObjet._narrow(SMESH.SMESH_Mesh): + result = True + except: + logger.debug(' isMesh pb avec ( entry = %s ) ' % entry) + return result + + def getMesh(self, entry): + meshObject = None + import SMESH try: - mainShapeEntry = entry.split(':')[:4] - if len(mainShapeEntry) == 4: - strMainShapeEntry = '%s:%s:%s:%s'%tuple(mainShapeEntry) + monObjet = self.getCORBAObjectInComponent(entry, "SMESH") + if monObjet is not None: # selection d'un groupe de SMESH + meshObject = monObjet._narrow(SMESH.SMESH_Mesh) + except: + logger.debug(' pb avec ( entry = %s ) ' % entry) + return meshObject + + def isShape(self, entry): + result = False + import GEOM + try: + monObjet = self.getCORBAObjectInComponent(entry, "GEOM") + if monObjet is not None: # selection d'un objet GEOM + if monObjet._narrow(GEOM.GEOM_Object): + result = True + except: + logger.debug(' isShape pb avec ( entry = %s ) ' % entry) + return result + + def getMainShapeEntry(self, entry): + result = None + try: + mainShapeEntry = entry.split(':')[:4] + if len(mainShapeEntry) == 4: + strMainShapeEntry = '%s:%s:%s:%s' % tuple(mainShapeEntry) if self.isMainShape(strMainShapeEntry): result = strMainShapeEntry except: - logger.debug( 'Erreur pour SalomeStudy.getMainShapeEntry( entry = %s ) ' %entry ) + logger.debug('Erreur pour SalomeStudy.getMainShapeEntry( entry = %s ) ' % entry) result = None return result - #----------------------------------------------------------------- - def isMainShape(self,entry): - #----------------------------------------------------------------- + def isMainShape(self, entry): result = False try: - monObjet =self.getCORBAObjectInComponent(entry,"GEOM") + monObjet = self.getCORBAObjectInComponent(entry, "GEOM") import GEOM - shape = monObjet._narrow( GEOM.GEOM_Object ) + shape = monObjet._narrow(GEOM.GEOM_Object) if shape.IsMainShape(): result = True except: - logger.debug( 'Errreur pour SalomeStudy.isMainShape( entry = %s ) ' %entry ) + logger.debug('Errreur pour SalomeStudy.isMainShape( entry = %s ) ' % entry) result = False return result - - #----------------------------------------------------------------- - def ChercheType( self, shape ): - #----------------------------------------------------------------- - tgeo = shape.GetShapeType() - geomEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" ) - #print dir(self.editor.study) + def ChercheType(self, shape): + tgeo = shape.GetShapeType() + geomEngine = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM") groupIMeasureOp = geomEngine.GetIMeasureOperations(self.editor.study._get_StudyId()) - if tgeo != "COMPOUND" : return tgeo + if tgeo != "COMPOUND": + return tgeo - strInfo = groupIMeasureOp.WhatIs( shape ) + strInfo = groupIMeasureOp.WhatIs(shape) dictInfo = {} l = strInfo.split('\n') for couple in l: - nom, valeur = couple.split(':') - dictInfo[ nom.strip() ] = valeur.strip() + nom, valeur = couple.split(':') + dictInfo[nom.strip()] = valeur.strip() - ordre = [ "COMPSOLID", "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX" ] + ordre = ["COMPSOLID", "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX"] for t in ordre: - if dictInfo[ t ] != '0': - tgeo = t - return tgeo + if dictInfo[t] != '0': + tgeo = t + return tgeo return None - - #----------------------------------------------------------------- - def selectShape( self, editor, entry, kwType = None ): - #----------------------------------------------------------------- + def selectShape(self, editor, entry, kwType=None): """ selection sous-geometrie dans Salome: -test1) si c'est un element sous-geometrique . -test2) si appartient a la geometrie principale. """ - name, msgError = '','' + name, msgError = '', '' mySO = self.editor.study.FindObjectID(entry) - if mySO == None : - return name, msgError - object = mySO.GetObject() - if object == None : - return name, msgError + if mySO is None: + return name, msgError + sobject = mySO.GetObject() + if sobject is None: + return name, msgError import GEOM - shape = object._narrow( GEOM.GEOM_Object ) - if not shape : - return name, msgError - - tGeo=self.ChercheType(shape) - if not tGeo : - return name, msgError - #if kwType == "GROUP_NO" and str(tGeo) != "VERTEX": - # name,msgError = '',"la selection n est pas un Vertex" - # return name, msgError + shape = sobject._narrow(GEOM.GEOM_Object) + if not shape: + return name, msgError + + tGeo = self.ChercheType(shape) + if not tGeo: + return name, msgError if kwType == "GROUP_MA" and str(tGeo) == "VERTEX": name, msgError = '', "la selection n est pas un groupe de maille" return name, msgError - mainShapeEntry = self.getMainShapeEntry( entry ) - if self.mainShapeNames.has_key( editor ): - #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor] - if self.mainShapeNames[editor] == mainShapeEntry: - name=mySO.GetName() - else : - msgError="Le groupe reference la geometrie " + mainShapeEntry + " et non " + self.mainShapeNames[editor] - else : - self.mainShapeNames[editor] = mainShapeEntry - name=mySO.GetName() - + mainShapeEntry = self.getMainShapeEntry(entry) + if editor in self.mainShapeNames: + if self.mainShapeNames[editor] == mainShapeEntry: + name = mySO.GetName() + else: + msgError = "Le groupe reference la geometrie " + mainShapeEntry + " et non " + self.mainShapeNames[editor] + else: + self.mainShapeNames[editor] = mainShapeEntry + name = mySO.GetName() + return name, msgError - - #----------------------------------------------------------------- - def selectMeshGroup( self, editor, selectedEntry, kwType = None ): - #----------------------------------------------------------------- + def selectMeshGroup(self, editor, selectedEntry, kwType=None): """ selection groupe de maille dans Salome: -test 1) si c'est un groupe de maille -test 2) si le maillage fait reference a la geometrie principale """ - name, msgError = '','' + name, msgError = '', '' - mySO=self.editor.study.FindObjectID(selectedEntry ) + mySO = self.editor.study.FindObjectID(selectedEntry) from salome.smesh.smeshstudytools import SMeshStudyTools - monSMeshStudyTools=SMeshStudyTools(self.editor) + monSMeshStudyTools = SMeshStudyTools(self.editor) meshSO = monSMeshStudyTools.getMeshFromGroup(mySO) - if meshSO == None : return name, msgError + if meshSO is None: + return name, msgError - # on verifie que l entree selectionnee a le bon type (NODE ou EDGE...) + # on verifie que l entree selectionnee a le bon type (NODE ou EDGE...) tGroup = "" - groupObject = self.getCORBAObjectInComponent(selectedEntry,"SMESH") - if not groupObject : - logger.debug("selectedMeshEntry: An error occurs") + groupObject = self.getCORBAObjectInComponent(selectedEntry, "SMESH") + if not groupObject: + logger.debug("selectedMeshEntry: An error occurs") import SMESH - aGroup = groupObject._narrow( SMESH.SMESH_GroupBase ) - if aGroup: tGroup = aGroup.GetType() + aGroup = groupObject._narrow(SMESH.SMESH_GroupBase) + if aGroup: + tGroup = aGroup.GetType() if kwType == "GROUP_NO" and tGroup != SMESH.NODE: - msgError = self.tr("GROUP_NO attend un groupe de noeud") - return name, msgError + msgError = self.tr("GROUP_NO attend un groupe de noeud") + return name, msgError elif kwType == "GROUP_MA" and tGroup == SMESH.NODE: - msgError = self.tr("GROUP_MA attend un point goupe de maille") - return name, msgError + msgError = self.tr("GROUP_MA attend un point goupe de maille") + return name, msgError # on cherche la shape associee - #PN PN mesh_Object est un SOject + # PN PN mesh_Object est un SOject meshObject = meshSO.GetObject() - mesh = meshObject._narrow( SMESH.SMESH_Mesh ) - if mesh: #c'est bien un objet maillage - shape = mesh.GetShapeToMesh() - if shape: - ior = salome.orb.object_to_string( shape ) + mesh = meshObject._narrow(SMESH.SMESH_Mesh) + if mesh: # c'est bien un objet maillage + shape = mesh.GetShapeToMesh() + if shape: + ior = salome.orb.object_to_string(shape) if ior: - sObject = self.editor.study.FindObjectIOR( ior ) - mainShapeID = sObject.GetID() - else : - mainShapeID=0 - else : - return name, self.tr("Type d objet non permis") + sObject = self.editor.study.FindObjectIOR(ior) + mainShapeID = sObject.GetID() + else: + mainShapeID = 0 + else: + return name, self.tr("Type d objet non permis") # on cherche si la shape associee est la bonne - #print "------------- mainShapeID" , mainShapeID - if self.mainShapeNames.has_key( editor ): - #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor] - if self.mainShapeNames[editor] == mainShapeID: - name=mySO.GetName() - else : - msgError=self.tr("Le groupe reference la geometrie ") + mainShapeID + self.tr(" et non ") + self.mainShapeNames[editor] - else : - self.mainShapeNames[editor] = mainShapeID - name=mySO.GetName() - - #print "------------------------------ name :", name - #print "------------------------------ name :", name - #print "------------------------------ name :", name - return name,msgError + if editor in self.mainShapeNames: + if self.mainShapeNames[editor] == mainShapeID: + name = mySO.GetName() + else: + msgError = self.tr("Le groupe reference la geometrie ") + mainShapeID + self.tr(" et non ") + self.mainShapeNames[editor] + else: + self.mainShapeNames[editor] = mainShapeID + name = mySO.GetName() + return name, msgError def displayMeshGroups(self, meshGroupName): """ @@ -427,322 +369,290 @@ class MyEficas( qtEficas.Appli ): """ ok, msgError = False, '' try: - #if 1 : sg = salome.ImportComponentGUI('SMESH') - meshGroupEntries = [] - selMeshEntry = None - selMeshGroupEntry = None - +# meshGroupEntries = [] +# selMeshEntry = None +# selMeshGroupEntry = None + # liste des groupes de maille de nom meshGroupName listSO = self.editor.study.FindObjectByName(meshGroupName, "SMESH") - #print listSO - #print "liste des groupes de maille de nom %s: "%(meshGroupName), listSO - - if len(listSO)>1: - return 0,self.tr('Plusieurs objets portent ce nom') - if len(listSO) ==0 : - return 0,self.tr('Aucun objet ne porte ce nom') - SObjet=listSO[0] - groupEntry = SObjet.GetID() + + if len(listSO) > 1: + return 0, self.tr('Plusieurs objets portent ce nom') + if len(listSO) == 0: + return 0, self.tr('Aucun objet ne porte ce nom') + SObjet = listSO[0] + groupEntry = SObjet.GetID() myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH") - SCom = self.editor.study.FindComponent("SMESH") - myBuilder = self.editor.study.NewBuilder() - myBuilder.LoadWith( SCom , myComponent ) + SCom = self.editor.study.FindComponent("SMESH") + myBuilder = self.editor.study.NewBuilder() + myBuilder.LoadWith(SCom, myComponent) sg.CreateAndDisplayActor(groupEntry) - #color = COLORS[ self.icolor % LEN_COLORS ] - #self.icolor = self.icolor + 1 - #sg.SetColor(groupEntry, color[0], color[1], color[2]) + # color = COLORS[ self.icolor % LEN_COLORS ] + # self.icolor = self.icolor + 1 + # sg.SetColor(groupEntry, color[0], color[1], color[2]) salome.sg.Display(groupEntry) - salome.sg.FitAll() - ok = True + salome.sg.FitAll() + ok = True except: - #else : - msgError = self.tr("Impossible d afficher ")+shapeName - logger.debug(50*'=') + msgError = self.tr("Impossible d afficher ") + meshGroupName + logger.debug(50 * '=') return ok, msgError # ___________________________ Methodes appelees par EFICAS __________________________________ - #---------------------------------------------------------------- - def selectGroupFromSalome( self, kwType = None, editor=None): - #---------------------------------------------------------------- + def selectGroupFromSalome(self, kwType=None, editor=None): """ Selection d'element(s) d'une geometrie ( sub-shape ) ou d'element(s) de maillage ( groupe de maille) partir de l'arbre salome retourne ( la liste des noms des groupes, message d'erreur ) - - Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel GROUPMA + + Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel GROUPMA """ names, msg = [], '' - try: + try: atLeastOneStudy = self.editor.study if not atLeastOneStudy: return names, msg - # recupere toutes les selections de l'utilsateur dans l'arbre Salome + # recupere toutes les selections de l'utilsateur dans l'arbre Salome entries = salome.sg.getAllSelected() - nbEntries = len( entries ) + nbEntries = len(entries) if nbEntries >= 1: for entry in entries: - if self.isMeshGroup(entry): # selection d 'un sous maillage - name, msg = self.selectMeshGroup( editor, entry, kwType ) - elif self.isShape(entry): # selection d'une sous-geometrie - name, msg = self.selectShape( editor, entry, kwType ) + if self.isMeshGroup(entry): # selection d 'un sous maillage + name, msg = self.selectMeshGroup(editor, entry, kwType) + elif self.isShape(entry): # selection d'une sous-geometrie + name, msg = self.selectShape(editor, entry, kwType) else: - name, msg = None,self.tr("Selection SALOME non autorisee.") + name, msg = None, self.tr("Selection SALOME non autorisee.") if name: - names.append( name ) - - except: + names.append(name) + + except: logger.debug("selectGroupFromSalome: An error occurs") - #print "=================== selectGroupFromSalome ", names, msg - #print "=================== selectGroupFromSalome ", names, msg - #print "=================== selectGroupFromSalome ", names, msg - return names, msg - - #---------------------------------------------------------------- - def selectMeshFile( self, editor=None): - #---------------------------------------------------------------- + return names, msg + + def selectMeshFile(self, editor=None): """ """ - try : + try: atLeastOneStudy = self.editor.study - if not atLeastOneStudy: return "", 'Pas d etude' + if not atLeastOneStudy: + return "", 'Pas d etude' - # recupere toutes les selections de l'utilsateur dans l'arbre Salome + # recupere toutes les selections de l'utilsateur dans l'arbre Salome entries = salome.sg.getAllSelected() - nbEntries = len( entries ) - if nbEntries != 1 : return "", 'select a Mesh' + nbEntries = len(entries) + if nbEntries != 1: + return "", 'select a Mesh' entry = entries[0] - if not self.isMesh(entry): return "", 'select a Mesh' - mySO=self.editor.study.FindObjectID(entry) - print mySO + if not self.isMesh(entry): + return "", 'select a Mesh' + mySO = self.editor.study.FindObjectID(entry) + print(mySO) ok, anAttr = mySO.FindAttribute("AttributeName") - if not ok : return "" ,'Pb de nommage' - meshFile="/tmp/"+str(anAttr.Value())+'.med' - myMesh=self.getMesh(entry) - if myMesh==None : return "" ,'Pb dans la selection ' - myMesh.ExportMED( meshFile, 0) - return meshFile ,"" - except : - return "", "Pb dans la selection " - - #---------------------------------------------------------------- - def importMedFile( self,fileName, editor=None): - #---------------------------------------------------------------- - try : + if not ok: + return "", 'Pb de nommage' + meshFile = "/tmp/" + str(anAttr.Value()) + '.med' + myMesh = self.getMesh(entry) + if myMesh is None: + return "", 'Pb dans la selection ' + myMesh.ExportMED(meshFile, 0) + return meshFile, "" + except: + return "", "Pb dans la selection " + + def importMedFile(self, fileName, editor=None): + try: theStudy = self.editor.study - if not theStudy: return (0, 'Pas d etude') + if not theStudy: + return (0, 'Pas d etude') from salome.smesh import smeshBuilder smesh = smeshBuilder.New(theStudy) - aMesh,aResult = smesh.CreateMeshesFromMED(fileName) + smesh.CreateMeshesFromMED(fileName) salome.sg.updateObjBrowser(1) - return 1,"" - except : - return (O,"Pb a l import") - - #---------------------------------------------------------------- - def selectEntryFromSalome( self, kwType = None, editor=None): - #---------------------------------------------------------------- + return 1, "" + except: + return (0, "Pb a l import") + + def selectEntryFromSalome(self, kwType=None, editor=None): """ Selection d'element a partir de l'arbre salome Ne verifie que l unicite de la selection retourne ( la liste avec le nom du groupe, message d'erreur ) - + retourne une liste pour etre coherent avec selectGroupFromSalome - Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel SalomeEntry + Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel SalomeEntry """ - try: + try: if self.editor.study._non_existent(): - raise Exception(self.tr(u"L'etude Salome n'existe plus")) + raise Exception(self.tr("L'etude Salome n'existe plus")) entries = salome.sg.getAllSelected() - nbEntries = len( entries ) + nbEntries = len(entries) if nbEntries < 1: - raise Exception(self.tr(u"Veuillez selectionner une entree de l'arbre d'etude de Salome")) - elif nbEntries > 1 : - raise Exception(self.tr(u"Une seule entree doit être selectionnee dans l'arbre d'etude de Salome")) + raise Exception(self.tr("Veuillez selectionner une entree de l'arbre d'etude de Salome")) + elif nbEntries > 1: + raise Exception(self.tr("Une seule entree doit être selectionnee dans l'arbre d'etude de Salome")) value = kwType.get_selected_value(entries[0], self.editor) - msg = self.tr(u"L'entree de l'arbre d'etude de Salome a ete selectionnee") + msg = self.tr("L'entree de l'arbre d'etude de Salome a ete selectionnee") return [value], msg - except Exception, e: - QMessageBox.information(self, self.tr(u"Selection depuis Salome"), unicode(e)) - return [], unicode(e) - - - #--------------------------------------------- - def addJdcInSalome( self, jdcPath ): - #--------------------------------------------- + except Exception as e: + QMessageBox.information(self, self.tr("Selection depuis Salome"), str(e)) + return [], str(e) + + def addJdcInSalome(self, jdcPath): """ Ajoute le Jeu De Commande dans l'arbre d'etude Salome dans la rubrique EFICAS Revu pour QT4 """ - msgError = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome" - if jdcPath == "" or jdcPath == None : return + msgError = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome" + if jdcPath == "" or jdcPath is None: + return ok = False - try: + try: atLeastOneStudy = self.editor.study if not atLeastOneStudy: return ok, msgError - - fileType = { 'TELEMAC' : "FICHIER_EFICAS_TELEMAC", - 'ADAO' : "FICHIER_EFICAS_ADAO", - 'SEP' : "FICHIER_EFICAS_SEP", - 'SPECA' : "FICHIER_EFICAS_SPECA", - 'MT' : "FICHIER_EFICAS_MT", - 'CF' : "FICHIER_EFICAS_CF", - 'MAP' : "FICHIER_EFICAS_MAP", - 'CARMEL3D' : "FICHIER_EFICAS_CARMEL3D", - } - - - folderName = { 'TELEMAC' : "TelemacFiles", - 'ADAO' : "AdaoFiles", - 'SEP' : "SepFiles", - 'SPECA' : "SpecaFiles", - 'MT' : "MTFiles", - 'CF' : "CFFiles", - 'CARMEL3D' : 'CARMEL3DFiles' , - 'MAP' : 'MapFiles' , - } - - folderType = { 'TELEMAC' : "TELEMAC_FILE_FOLDER", - 'ADAO' : "ADAO_FILE_FOLDER", - 'SEP' : "SEP_FILE_FOLDER", - 'SPECA' : "SPECA_FILE_FOLDER", - 'MT' : "MT_FILE_FOLDER", - 'CF' : "CF_FILE_FOLDER", - 'SEP' : "SEP_FILE_FOLDER", - 'MAP' : "MAP_FILE_FOLDER", - 'CARMEL3D' : "CARMEL3D_FILE_FOLDER", + fileType = {'TELEMAC' : "FICHIER_EFICAS_TELEMAC", + 'ADAO' : "FICHIER_EFICAS_ADAO", + 'SEP' : "FICHIER_EFICAS_SEP", + 'SPECA' : "FICHIER_EFICAS_SPECA", + 'MT' : "FICHIER_EFICAS_MT", + 'CF' : "FICHIER_EFICAS_CF", + 'MAP' : "FICHIER_EFICAS_MAP", + 'CARMEL3D' : "FICHIER_EFICAS_CARMEL3D", } - + + folderName = {'TELEMAC' : "TelemacFiles", + 'ADAO' : "AdaoFiles", + 'SEP' : "SepFiles", + 'SPECA' : "SpecaFiles", + 'MT' : "MTFiles", + 'CF' : "CFFiles", + 'CARMEL3D': 'CARMEL3DFiles' , + 'MAP' : 'MapFiles' , + } + + + folderType = {'TELEMAC' : "TELEMAC_FILE_FOLDER", + 'ADAO' : "ADAO_FILE_FOLDER", + 'SEP' : "SEP_FILE_FOLDER", + 'SPECA' : "SPECA_FILE_FOLDER", + 'MT' : "MT_FILE_FOLDER", + 'CF' : "CF_FILE_FOLDER", + 'SEP' : "SEP_FILE_FOLDER", + 'MAP' : "MAP_FILE_FOLDER", + 'CARMEL3D' : "CARMEL3D_FILE_FOLDER", + } + moduleEntry = self.editor.findOrCreateComponent(self.module, self.componentName) - itemName = re.split("/",jdcPath)[-1] - - if folderName.has_key(self.code) : - monFolderName=folderName[ self.code ] - else : - monFolderName=str(self.code)+"Files" - - if folderType.has_key(self.code) : - monFolderType=fileType[ self.code ] - else : - monFolderType=str(self.code)+"_FILE_FOLDER" - - if fileType.has_key(self.code) : - monFileType=fileType[ self.code ] - else : - monFileType="FICHIER_EFICAS_"+str(self.code) + itemName = re.split("/", jdcPath)[-1] + + if self.code in folderName: + monFolderName = folderName[self.code] + else: + monFolderName = str(self.code) + "Files" + + if self.code in folderType: + monFolderType = fileType[self.code] + else: + monFolderType = str(self.code) + "_FILE_FOLDER" + + if self.code in fileType: + monFileType = fileType[self.code] + else: + monFileType = "FICHIER_EFICAS_" + str(self.code) fatherEntry = self.editor.findOrCreateItem( moduleEntry, - name = monFolderName, - #icon = "ICON_COMM_FOLDER", - fileType = monFolderType) - - commEntry = self.editor.findOrCreateItem( fatherEntry , - name = itemName, - fileType = monFileType, - fileName = jdcPath, - #icon = "ICON_COMM_FILE", - comment = str( jdcPath )) + name=monFolderName, + # icon = "ICON_COMM_FOLDER", + fileType=monFolderType) + + commEntry = self.editor.findOrCreateItem(fatherEntry, + name=itemName, + fileType=monFileType, + fileName=jdcPath, + # icon = "ICON_COMM_FILE", + comment=str(jdcPath)) salome.sg.updateObjBrowser(1) - #print 'addJdcInSalome commEntry->', commEntry if commEntry: - ok, msgError = True, '' - except Exception, exc: + ok, msgError = True, '' + except Exception as exc: msgError = "Can't add Eficas file to Salome study tree" - logger.debug(msgError, exc_info = True) + logger.debug(msgError, exc_info=True) QMessageBox.warning(self, self.tr("Warning"), self.tr("%s. Raison:\n%s\n\n Voir la log pour plus de details " % (msgError, exc))) - return ok, msgError - - - #--------------------------------------- - def displayShape( self, shapeName ): - #--------------------------------------- + return ok, msgError + + def displayShape(self, shapeName): """ visualisation de nom shapeName dans salome """ ok, msgError = False, '' try: - #if 1 : import SalomePyQt sgPyQt = SalomePyQt.SalomePyQt() - myActiveView=sgPyQt.getActiveView() - if myActiveView < 0 : - return ok, 'pas de vue courante' - - currentViewType=sgPyQt.getViewType(myActiveView) - if str(currentViewType) != "OCCViewer" : # maillage + myActiveView = sgPyQt.getActiveView() + if myActiveView < 0: + return ok, 'pas de vue courante' + + currentViewType = sgPyQt.getViewType(myActiveView) + if str(currentViewType) != "OCCViewer": # maillage ok, msgError = self.displayMeshGroups(shapeName) - else: #geometrie - current_color = COLORS[ self.icolor % LEN_COLORS ] + else: # geometrie + current_color = COLORS[self.icolor % LEN_COLORS] from salome.geom.geomtools import GeomStudyTools - myGeomTools=GeomStudyTools(self.editor) - ok = myGeomTools.displayShapeByName( shapeName, current_color ) + myGeomTools = GeomStudyTools(self.editor) + ok = myGeomTools.displayShapeByName(shapeName, current_color) salome.sg.FitAll() - self.icolor = self.icolor + 1 + self.icolor = self.icolor + 1 if not ok: - msgError =self.tr("Impossible d afficher ")+shapeName - except: - #else : - logger.debug(50*'=') - return ok, msgError - - #--------------------------------------- + msgError = self.tr("Impossible d afficher ") + shapeName + except: + logger.debug(50 * '=') + return ok, msgError + def ChercheGrpMeshInSalome(self): - #--------------------------------------- - print "je passe par la" + print("je passe par la") import SMESH names, msg = [], '' - try : - #if 1 : - entries = salome.sg.getAllSelected() - nbEntries = len( entries ) - names, msg = None, self.tr("Selection SALOME non autorisee.") - if nbEntries == 1: + try: + entries = salome.sg.getAllSelected() + nbEntries = len(entries) + names, msg = None, self.tr("Selection SALOME non autorisee.") + if nbEntries == 1: for entry in entries: - names,msg=self.giveMeshGroups(entry,"SubMeshes",SMESH.SMESH_subMesh) - except : - #else : - print "bim bam boum" - return(msg,names) + names, msg = self.giveMeshGroups(entry, "SubMeshes", SMESH.SMESH_subMesh) + except: + print("bim bam boum") + return(msg, names) - #--------------------------------------- def ChercheGrpMailleInSalome(self): - #--------------------------------------- import SMESH names, msg = [], '' - try : - #if 1: - entries = salome.sg.getAllSelected() - nbEntries = len( entries ) - names, msg = None, self.tr("Selection SALOME non autorisee.") - if nbEntries == 1: + try: + entries = salome.sg.getAllSelected() + nbEntries = len(entries) + names, msg = None, self.tr("Selection SALOME non autorisee.") + if nbEntries == 1: for entry in entries: - print entry - names,msg=self.giveMeshGroups(entry,"Groups of",SMESH.SMESH_GroupBase) - print names - except : - #else: - print "bim bam boum" - return(msg,names) - - - - - -#------------------------------------------------------------------------------------------------------- + print(entry) + names, msg = self.giveMeshGroups(entry, "Groups of", SMESH.SMESH_GroupBase) + print(names) + except: + print("bim bam boum") + return(msg, names) + +# ------------------------------------------------------------------------------------------------------- # Pilotage de la Visu des elements de structures # - - - def envoievisu(self,liste_commandes): + def envoievisu(self, liste_commandes): try: from salome.geom.structelem import StructuralElementManager, InvalidParameterError except ImportError: @@ -754,12 +664,12 @@ class MyEficas( qtEficas.Appli ): atLeastOneStudy = self.editor.study if not atLeastOneStudy: return - logger.debug(10*'#'+":envoievisu: creating a StructuralElementManager instance") + logger.debug(10 * '#' + ":envoievisu: creating a StructuralElementManager instance") structElemManager = StructuralElementManager() elem = structElemManager.createElement(liste_commandes) elem.display() salome.sg.updateObjBrowser(True) - except InvalidParameterError, err: + except InvalidParameterError as err: trStr = self.tr("Invalid parameter for group %(group)s: %(expr)s must be " "greater than %(minval)g (actual value is %(value)g)") msg = str(trStr) % {"group": err.groupName, "expr": err.expression, @@ -767,50 +677,49 @@ class MyEficas( qtEficas.Appli ): QMessageBox.warning(self, self.tr("Error"), msg) except: traceback.print_exc() - logger.debug(10*'#'+":pb dans envoievisu") + logger.debug(10 * '#' + ":pb dans envoievisu") class SalomeEntry: - """ - This class replaces the class Accas.SalomeEntry (defined in EFICAS tool) - when Eficas is launched in Salome context. It handles the objects that can - be selected from Salome object browser. - By default, the selected value is the entry of the selected item in the - object browser. This class can be subclassed to provide more advanced - functions. - """ - - help_message = u"Une entree de l'arbre d'etude de Salome est attendue" - - def __init__(self, entryStr): - self._entry = entryStr - - @staticmethod - def __convert__(entryStr): - return SalomeEntry(entryStr) - - @staticmethod - def get_selected_value(selected_entry, study_editor): - return selected_entry - - -#------------------------------------------------------------------------------------------------------- + """ + This class replaces the class Accas.SalomeEntry (defined in EFICAS tool) + when Eficas is launched in Salome context. It handles the objects that can + be selected from Salome object browser. + By default, the selected value is the entry of the selected item in the + object browser. This class can be subclassed to provide more advanced + functions. + """ + + help_message = "Une entree de l'arbre d'etude de Salome est attendue" + + def __init__(self, entryStr): + self._entry = entryStr + + @staticmethod + def __convert__(entryStr): + return SalomeEntry(entryStr) + + @staticmethod + def get_selected_value(selected_entry, study_editor): + return selected_entry + + +# ------------------------------------------------------------------------------------------------------- # Point d'entree lancement EFICAS # -def runEficas( code=None, fichier=None, module = "EFICAS", version=None, componentName = "Eficas",multi=False): - logger.debug(10*'#'+":runEficas: START") - #global appli - logger.debug(10*'#'+":runEficas: code="+str(code)) - logger.debug(10*'#'+":runEficas: fichier="+str(fichier)) - logger.debug(10*'#'+":runEficas: module="+str(module)) - logger.debug(10*'#'+":runEficas: version="+str(version)) - - #if not appli: #une seul instance possible! - appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier, - module = module, version = version, componentName = componentName,multi=multi ) - #if not appli: #une seul instance possible! +def runEficas(code=None, fichier=None, module="EFICAS", version=None, componentName="Eficas", multi=False): + logger.debug(10 * '#' + ":runEficas: START") + # global appli + logger.debug(10 * '#' + ":runEficas: code=" + str(code)) + logger.debug(10 * '#' + ":runEficas: fichier=" + str(fichier)) + logger.debug(10 * '#' + ":runEficas: module=" + str(module)) + logger.debug(10 * '#' + ":runEficas: version=" + str(version)) + + # if not appli: #une seul instance possible! + appli = MyEficas(SalomePyQt.SalomePyQt().getDesktop(), code=code, fichier=fichier, + module=module, version=version, componentName=componentName, multi=multi) + # if not appli: #une seul instance possible! # appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier, # module = module, componentName = componentName, version=version ) - logger.debug(10*'#'+":runEficas: END") + logger.debug(10 * '#' + ":runEficas: END") - diff --git a/src/STUDY/EficasStudy.py b/src/STUDY/EficasStudy.py index 5570f798..c191b112 100644 --- a/src/STUDY/EficasStudy.py +++ b/src/STUDY/EficasStudy.py @@ -1,73 +1,67 @@ -# -*- coding: iso-8859-1 -*- +# -*- coding: utf8 -*- import salomedsgui import salome import SALOMEDS -try : +try: import SMESH -except : - pass -try : - import SMESH -except : +except ImportError: pass from salome.kernel.logger import Logger -logger=Logger( "EficasStudy" ) +logger = Logger("EficasStudy") -#Nom des composants SALOME dans l'arbre d'étude -SMesh = "Mesh" -SGeom = "Geometry" -SVisu = "Post-Pro" +# Nom des composants SALOME dans l'arbre d'étude +SMesh = "Mesh" +SGeom = "Geometry" +SVisu = "Post-Pro" SAster = "Aster" -class SalomeStudy( salomedsgui.guiDS ): +class SalomeStudy(salomedsgui.guiDS): """ - Classe de manipulation de l'arbre d'étude Salome. Cette classe permet à - l'utilisateur de manipuler les objets de 'arbre d'étude via leurs + Classe de manipulation de l'arbre d'étude Salome. Cette classe permet à + l'utilisateur de manipuler les objets de 'arbre d'étude via leurs identifiants( entry ). - - Attention : Par défaut les opérations réalisée par cette classe portent sur - une étude courante ( positionnée dans le constructeur ou par la méthode + + Attention : Par défaut les opérations réalisée par cette classe portent sur + une étude courante ( positionnée dans le constructeur ou par la méthode setCurrentStudyID() ) - """ - def __init__( self, studyID = salome.myStudyId ): - salomedsgui.guiDS.__init__( self ) - self.setCurrentStudy( studyID) - - # spécifique méthode __getMeshType() : - self.groupOp = None + """ + def __init__(self, studyID=salome.myStudyId): + salomedsgui.guiDS.__init__(self) + self.setCurrentStudy(studyID) + + # spécifique méthode __getMeshType() : + self.groupOp = None self.geomEngine = None - - # spécifique méthode createMesh() : - self.smeshEngine = None - - - + + # spécifique méthode createMesh() : + self.smeshEngine = None + # -------------------------------------------------------------------------- - # fonctions de manipulation générale ( porte sur toute l'arbre d'étude ) - def __getCORBAObject( self, entry ): + # fonctions de manipulation générale ( porte sur toute l'arbre d'étude ) + def __getCORBAObject(self, entry): """ - Retourne l'objet CORBA correspondant son identifiant ( entry ) dans - l'arbre d'étude. - + Retourne l'objet CORBA correspondant son identifiant ( entry ) dans + l'arbre d'étude. + @type entry : string - @param entry : objet Corba - + @param entry : objet Corba + @rtype : objet CORBA @return : l'objet CORBA, None si erreur. """ - object = None - try: - mySO = self._myStudy.FindObjectID( entry ) - if mySO: - object = mySO.GetObject() - - if not object: # l'objet n'a pas encore chargé - path = self._myStudy.GetObjectPath( mySO )# recherche du nom du composant - componentName = ( path.split('/')[1] ).strip() + sobject = None + try: + mySO = self._myStudy.FindObjectID(entry) + if mySO: + sobject = mySO.GetObject() + + if not sobject: # l'objet n'a pas encore chargé + path = self._myStudy.GetObjectPath(mySO) # recherche du nom du composant + componentName = (path.split('/')[1]).strip() if componentName == SMesh: strContainer, strComponentName = "FactoryServer", "SMESH" @@ -77,469 +71,448 @@ class SalomeStudy( salomedsgui.guiDS ): strContainer, strComponentName = "FactoryServer", "VISU" elif componentName == SAster: strContainer, strComponentName = "FactoryServerPy", "ASTER" - else : - logger.debug('>>>>CS_Pbruno StudyTree.__getCORBAObject chargement du composant %s non implémenté ' %componentName) - raise 'Erreur' - - myComponent = salome.lcc.FindOrLoadComponent( strContainer, strComponentName ) - SCom = self._myStudy.FindComponent( strComponentName ) - self._myBuilder.LoadWith( SCom , myComponent ) - object = mySO.GetObject() + else: + logger.debug('>>>>CS_Pbruno StudyTree.__getCORBAObject chargement du composant %s non implémenté ' % componentName) + raise Exception('Erreur') + + myComponent = salome.lcc.FindOrLoadComponent(strContainer, strComponentName) + SCom = self._myStudy.FindComponent(strComponentName) + self._myBuilder.LoadWith(SCom, myComponent) + sobject = mySO.GetObject() except: import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - logger.debug( '>>>>CS_Pbruno StudyTree.__getCORBAObject erreur recupération objet corba ( entry = %s ) ' %entry) - logger.debug( 'type = %s , value = %s '%( type, value ) ) - object = None - - return object - - - def __getEntry( self, corbaObject ): + ex_type = sys.exc_info()[0] + ex_value = sys.exc_info()[1] + logger.debug('>>>>CS_Pbruno StudyTree.__getCORBAObject erreur recupération objet corba ( entry = %s ) ' % entry) + logger.debug('type = %s , value = %s ' % (ex_type, ex_value)) + sobject = None + + return sobject + + def __getEntry(self, corbaObject): """ - Retourne l'identifiant ( entry ) ds l'arbre d'étude de l'objet CORBA - passé en paramètre. - + Retourne l'identifiant ( entry ) ds l'arbre d'étude de l'objet CORBA + passé en paramètre. + @type corbaObject : objet Corba - @param corbaObject : objet Corba - + @param corbaObject : objet Corba + @rtype : string @return : identifiant ( entry ), None si erreur. """ - entry = None + entry = None currentStudy = self._myStudy - + if corbaObject: - ior = salome.orb.object_to_string( corbaObject ) + ior = salome.orb.object_to_string(corbaObject) if ior: - sObject = currentStudy.FindObjectIOR( ior ) - entry = sObject.GetID() + sObject = currentStudy.FindObjectIOR(ior) + entry = sObject.GetID() return entry - - - def setCurrentStudyID( self, studyID): + def setCurrentStudyID(self, studyID): + """ + Fixe l'étude courante sur laquel vont opérer toutes les fonctions + de la classe. """ - Fixe l'étude courante sur laquel vont opérer toutes les fonctions - de la classe. - """ - self._father = None + self._father = None self._component = None - self._myStudy = self._myStudyManager.GetStudyByID( studyID) - self._myBuilder = self._myStudy.NewBuilder( ) - - salome.myStudy = self._myStudy - salome.myStudyId = studyID - salome.myStudyName = self._myStudy._get_Name() - - def refresh( self ): + self._myStudy = self._myStudyManager.GetStudyByID(studyID) + self._myBuilder = self._myStudy.NewBuilder() + + salome.myStudy = self._myStudy + salome.myStudyId = studyID + salome.myStudyName = self._myStudy._get_Name() + + def refresh(self): """ - Rafraichissement de l'arbre d'étude + Rafraichissement de l'arbre d'étude """ salome.sg.updateObjBrowser(0) - - def setName( self, entry, name ): + + def setName(self, entry, name): """ - Fixe le nom( la valeur de l'attribut 'AttributeName' ) d'un objet de l'arbre d'étude - désigné par son identifiant( entry ) - + Fixe le nom( la valeur de l'attribut 'AttributeName' ) d'un objet de l'arbre d'étude + désigné par son identifiant( entry ) + @type entry: string - @param entry: identifiant de l'objet dans l'arbre d'étude - + @param entry: identifiant de l'objet dans l'arbre d'étude + @type name: string - @param name: nom à attribuer - + @param name: nom à attribuer + @rtype : boolean @return : True si Ok, False sinon, None si erreur """ result = False try: - SObject = self._myStudy.FindObjectID( entry ) - A1 = self._myBuilder.FindOrCreateAttribute( SObject, "AttributeName" ) - AName = A1._narrow(SALOMEDS.AttributeName) - AName.SetValue( name ) - result = True + SObject = self._myStudy.FindObjectID(entry) + A1 = self._myBuilder.FindOrCreateAttribute(SObject, "AttributeName") + AName = A1._narrow(SALOMEDS.AttributeName) + AName.SetValue(name) + result = True except: import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - logger.debug( '>>>>CS_Pbruno StudyTree.setName ( entry = %s, name = %s )' %( entry, name ) ) - logger.debug( 'type = %s , value = %s '%( type, value ) ) + ex_type = sys.exc_info()[0] + ex_value = sys.exc_info()[1] + logger.debug('>>>>CS_Pbruno StudyTree.setName ( entry = %s, name = %s )' % (entry, name)) + logger.debug('type = %s , value = %s ' % (ex_type, ex_value)) result = None - + return result - def hasName( self, componentName, objectName ): + def hasName(self, componentName, objectName): """ - Vérifie si dans l'arbre d'étude le commposant de nom componentName - possède un objet de nom objectName. - + Vérifie si dans l'arbre d'étude le commposant de nom componentName + possède un objet de nom objectName. + @type componentName: string @param componentName: nom du composant Salome - + @type objectName: string - @param objectName: nom de l'objet - + @param objectName: nom de l'objet + @rtype : boolean @return : True si Ok, False sinon, None si erreur """ result = False try: - nom = { + nom = { SMesh: "SMESH", SGeom: "GEOM", SVisu: "VISU", - SAster: "ASTER" + SAster: "ASTER" } - componentName = nom[ componentName ] - SObjects = self._myStudy.FindObjectByName( objectName, componentName ) - if len( SObjects ) > 0: - result = True + componentName = nom[componentName] + SObjects = self._myStudy.FindObjectByName(objectName, componentName) + if len(SObjects) > 0: + result = True except: import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - logger.debug( '>>>>CS_Pbruno StudyTree.setName ( entry = %s, name = %s )' %( entry, name ) ) - logger.debug( 'type = %s , value = %s '%( type, value ) ) + ex_type = sys.exc_info()[0] + ex_value = sys.exc_info()[1] + logger.debug('>>>>CS_Pbruno StudyTree.hasName ( componentName = %s, objectName = %s )' % (componentName, objectName)) + logger.debug('type = %s , value = %s ' % (ex_type, ex_value)) result = None - - return result - - - + return result # -------------------------------------------------------------------------- - # fonctions de manipulation des objets géométriques dans l'arbre d'étude - # ( éléments contenu dans la sous-rubrique "Geometry' ) - def isMainShape( self, entry ): + # fonctions de manipulation des objets géométriques dans l'arbre d'étude + # ( éléments contenu dans la sous-rubrique "Geometry' ) + def isMainShape(self, entry): """ - Teste si l'objet désigné par l'identifiant ( entry ) passé en argument - est bien un objet géométrique principal. - + Teste si l'objet désigné par l'identifiant ( entry ) passé en argument + est bien un objet géométrique principal. + @type entry: string - @param entry: identifiant de l'objet - + @param entry: identifiant de l'objet + @rtype: boolean @return: True si Ok, False sinon """ result = False - try: - anObject = self.__getCORBAObject( entry ) - shape = anObject._narrow( GEOM.GEOM_Object ) + try: + anObject = self.__getCORBAObject(entry) + shape = anObject._narrow(GEOM.GEOM_Object) if shape.IsMainShape(): - result = True + result = True except: import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - logger.debug( '>>>>CS_Pbruno StudyTree.isMainShape( entry = %s ) ' %entry ) - logger.debug( 'type = %s , value = %s '%( type, value ) ) - result = False + ex_type = sys.exc_info()[0] + ex_value = sys.exc_info()[1] + logger.debug('>>>>CS_Pbruno StudyTree.isMainShape( entry = %s ) ' % entry) + logger.debug('type = %s , value = %s ' % (ex_type, ex_value)) + result = False return result - - - def getMainShapeEntry( self, entry ): + + def getMainShapeEntry(self, entry): """ - Retourne l'identifiant de l'objet géométrique principal du sous-objet géométrique désigné par - l'identifiant ( entry ) passé en paramètre. - + Retourne l'identifiant de l'objet géométrique principal du sous-objet géométrique désigné par + l'identifiant ( entry ) passé en paramètre. + @type entry: string - @param entry: identifiant du sous-objet géométrique - - @rtype : string - @return : identifiant de l'objet géométrique principal, None si erreur. + @param entry: identifiant du sous-objet géométrique + + @rtype : string + @return : identifiant de l'objet géométrique principal, None si erreur. """ result = None - try : - if self.isMainShape( entry ): + try: + if self.isMainShape(entry): result = entry else: - anObject = self.__getCORBAObject( entry ) - shape = anObject._narrow( GEOM.GEOM_Object ) - objMain = shape.GetMainShape() - result = self.__getEntry( objMain ) - except : - import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - #print '>>>>CS_Pbruno StudyTree.getMainShapeEntry( entry = %s ) ' %entry - #print 'type = %s , value = %s '%( type, value ) + anObject = self.__getCORBAObject(entry) + shape = anObject._narrow(GEOM.GEOM_Object) + objMain = shape.GetMainShape() + result = self.__getEntry(objMain) + except: + # import sys + # ex_type = sys.exc_info()[0] + # ex_value = sys.exc_info()[1] + # print('>>>>CS_Pbruno StudyTree.getMainShapeEntry( entry = %s ) ' %entry) + # print('type = %s , value = %s '%( ex_type, ex_value )) result = None - + return result - - def sameMainShape( self, shapeEntry1, shapeEntry2 ): + + def sameMainShape(self, shapeEntry1, shapeEntry2): """ - Détermine si les objets géometriques fournis en argument sont les - sous-objets d'une même géométrie principale - + Détermine si les objets géometriques fournis en argument sont les + sous-objets d'une même géométrie principale + @type shapeEntry1: string - @param shapeEntry1: identifiant dans l'arbre d'étude d'un objet géométrique - + @param shapeEntry1: identifiant dans l'arbre d'étude d'un objet géométrique + @type shapeEntry2: string - @param shapeEntry2: identifiant dans l'arbre d'étude d'un objet géométrique - + @param shapeEntry2: identifiant dans l'arbre d'étude d'un objet géométrique + @rtype : boolean - @return : True si même objet principal, False sinon, None si erreur. + @return : True si même objet principal, False sinon, None si erreur. """ result = None - try : - mainShape1 = self.getMainShapeEntry( shapeEntry1 ) + try: + mainShape1 = self.getMainShapeEntry(shapeEntry1) if mainShape1: - mainShape2 = self.getMainShapeEntry( shapeEntry2 ) + mainShape2 = self.getMainShapeEntry(shapeEntry2) if mainShape2: result = mainShape1 == mainShape2 - except : - import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - #print '>>>>CS_Pbruno StudyTree.sameMainShape( shapeEntry1 = %s , shapeEntry2 = %s )'%( shapeEntry1, shapeEntry2 ) - #print 'type = %s , value = %s '%( type, value ) + except: + # import sys + # ex_type = sys.exc_info()[0] + # ex_value = sys.exc_info()[1] + # print('>>>>CS_Pbruno StudyTree.sameMainShape( shapeEntry1 = %s , shapeEntry2 = %s )'%( shapeEntry1, shapeEntry2 )) + # print('type = %s , value = %s '%( ex_type, ex_value )) result = None - + return result - - + # -------------------------------------------------------------------------- - # fonctions de manipulation des objets maillages dans l'arbre d'étude - # ( éléments contenu dans la sous-rubrique 'Mesh' ) - def __getMeshType( self, shapeEntry ): + # fonctions de manipulation des objets maillages dans l'arbre d'étude + # ( éléments contenu dans la sous-rubrique 'Mesh' ) + def __getMeshType(self, shapeEntry): """ - Determination du type de maille en fonction de la géométrie pour les conditions aux limites. - + Determination du type de maille en fonction de la géométrie pour les conditions aux limites. + @type shapeEntry : string - @param shapeEntry : identifiant de l'objet géométrique - + @param shapeEntry : identifiant de l'objet géométrique + @rtype: SMESH::ElementType ( voir SMESH_Mesh.idl ) @return: type de maillage, None si erreur. - """ + """ result = None - - try: - anObject = self.__getCORBAObject( shapeEntry ) - shape = anObject._narrow( GEOM.GEOM_Object ) - - if shape: #Ok, c'est bien un objet géométrique - tgeo = str( shape.GetShapeType() ) - + + try: + anObject = self.__getCORBAObject(shapeEntry) + shape = anObject._narrow(GEOM.GEOM_Object) + + if shape: # Ok, c'est bien un objet géométrique + tgeo = str(shape.GetShapeType()) + meshTypeStr = { - "VERTEX" : SMESH.NODE, - "EDGE": SMESH.EDGE, - "FACE": SMESH.FACE, - "SOLID": SMESH.VOLUME, - "COMPOUND" : None + "VERTEX": SMESH.NODE, + "EDGE": SMESH.EDGE, + "FACE": SMESH.FACE, + "SOLID": SMESH.VOLUME, + "COMPOUND": None } - result = meshTypeStr[ tgeo] - if result == None: + result = meshTypeStr[tgeo] + if result is None: if not self.geomEngine: - self.geomEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" ) + self.geomEngine = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM") if not self.GroupOp: - self.GroupOp = self.geomEngine.GetIGroupOperations( salome.myStudyId ) - - tgeo = self.GroupOp.GetType( shape ) - meshTypeInt = { #Voir le dictionnnaire ShapeType dans geompy.py pour les correspondances type - numero. - 7: SMESH.NODE, + self.GroupOp = self.geomEngine.GetIGroupOperations(salome.myStudyId) + + tgeo = self.GroupOp.GetType(shape) + meshTypeInt = { # Voir le dictionnnaire ShapeType dans geompy.py pour les correspondances type - numero. + 7: SMESH.NODE, 6: SMESH.EDGE, 4: SMESH.FACE, 2: SMESH.VOLUME } - if meshTypeInt.has_key( int( tgeo ) ): - result = meshTypeInt[ tgeo] + if int(tgeo) in meshTypeInt: + result = meshTypeInt[tgeo] except: import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - logger.debug( '>>>>CS_Pbruno StudyTree.__getMeshType( shapeEntry = %s ) ' %shapeEntry ) - logger.debug( 'type = %s , value = %s '%( type, value )) + ex_type = sys.exc_info()[0] + ex_value = sys.exc_info()[1] + logger.debug('>>>>CS_Pbruno StudyTree.__getMeshType( shapeEntry = %s ) ' % shapeEntry) + logger.debug('type = %s , value = %s ' % (ex_type, ex_value)) result = None - + return result - - def getAllMeshReferencingMainShape( self, mainShapeEntry ): + + def getAllMeshReferencingMainShape(self, mainShapeEntry): """ - Retourne une liste de tous les maillages construits à partir de l'objet - principal géométrique passé en argument - + Retourne une liste de tous les maillages construits à partir de l'objet + principal géométrique passé en argument + @type mainShapeEntry : string - @param mainShapeEntry : identifiant( entry ) de l'objet principal géométrique - + @param mainShapeEntry : identifiant( entry ) de l'objet principal géométrique + @rtype: list @return: liste des identifiants( entry ) des maillages, liste vide si aucun , None si erreur. """ result = [] - + try: - if self.isMainShape( mainShapeEntry ): - mainShapeSO = salome.IDToSObject( mainShapeEntry ) - SObjectList = self._myStudy.FindDependances( mainShapeSO ) - #print '#### mainShapeSO=%s , SObjectList = %s'%( mainShapeSO, SObjectList ) - if SObjectList: #Ok, il y a des objet référençant la mainShape - for SObject in SObjectList: # Recherche du type de chacun des objets + if self.isMainShape(mainShapeEntry): + mainShapeSO = salome.IDToSObject(mainShapeEntry) + SObjectList = self._myStudy.FindDependances(mainShapeSO) + # print('#### mainShapeSO=%s , SObjectList = %s'%( mainShapeSO, SObjectList )) + if SObjectList: # Ok, il y a des objet référençant la mainShape + for SObject in SObjectList: # Recherche du type de chacun des objets SFatherComponent = SObject.GetFatherComponent() - #print '#### SFatherComponent = %s'%SFatherComponent - if SFatherComponent.GetName() == SMesh: #Ok, l'objet est un objet du composant 'Mesh' + # print('#### SFatherComponent = %s'%SFatherComponent) + if SFatherComponent.GetName() == SMesh: # Ok, l'objet est un objet du composant 'Mesh' SFather = SObject.GetFather() - #print '#### SFather= %s'%SFather - ##CorbaObject = SFather.GetObject() + # print('#### SFather= %s'%SFather) + # #CorbaObject = SFather.GetObject() FatherEntry = SFather.GetID() - CorbaObject = self.__getCORBAObject( FatherEntry ) - #print '#### CorbaObject = %s'%CorbaObject - MeshObject = CorbaObject ._narrow( SMESH.SMESH_Mesh ) - #print '#### MeshObject = %s'%MeshObject - if MeshObject : #Ok, l'objet est un objet 'maillage' - MeshObjectEntry = self.__getEntry( MeshObject ) - #print '#### MeshObjectEntry = %s'%MeshObjectEntry + CorbaObject = self.__getCORBAObject(FatherEntry) + # print('#### CorbaObject = %s'%CorbaObject) + MeshObject = CorbaObject ._narrow(SMESH.SMESH_Mesh) + # print('#### MeshObject = %s'%MeshObject) + if MeshObject: # Ok, l'objet est un objet 'maillage' + MeshObjectEntry = self.__getEntry(MeshObject) + # print('#### MeshObjectEntry = %s'%MeshObjectEntry) if MeshObjectEntry: - result.append( MeshObjectEntry ) # On l'ajoute ds la liste résultat! - else: # c'est pas une mainShape ! - result = None - except : + result.append(MeshObjectEntry) # On l'ajoute ds la liste résultat! + else: # c'est pas une mainShape ! + result = None + except: import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - logger.debug( '>>>>CS_Pbruno StudyTree.getAllMeshReferencingMainShape( mainShapeEntry = %s ) ' %mainShapeEntry ) - logger.debug( 'type = %s , value = %s '%( type, value )) + ex_type = sys.exc_info()[0] + ex_value = sys.exc_info()[1] + logger.debug('>>>>CS_Pbruno StudyTree.getAllMeshReferencingMainShape( mainShapeEntry = %s ) ' % mainShapeEntry) + logger.debug('type = %s , value = %s ' % (ex_type, ex_value)) result = None - - return result - - - def updateMesh( self, meshEntry, groupeMaEntries, groupeNoEntries ): + return result + + def updateMesh(self, meshEntry, groupeMaEntries, groupeNoEntries): """ - Met à jours d'un objet maillage à partir d'une liste de sous-objet géométrique. - L'opération consiste à créer des groupes dans le maillage correspondant - aux sous-objets géométrique de la liste. - - CS_pbruno Attention: ajoute des groupes sans vérifier si auparavant ils ont déjà été crées - + Met à jours d'un objet maillage à partir d'une liste de sous-objet géométrique. + L'opération consiste à créer des groupes dans le maillage correspondant + aux sous-objets géométrique de la liste. + + CS_pbruno Attention: ajoute des groupes sans vérifier si auparavant ils ont déjà été crées + @type meshEntry : string @param meshEntry : identifiant du maillage - + @type groupeMaEntries : liste de string - @param groupeMaEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques + @param groupeMaEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques sur lesquel on veut construire des groupes de face. @type groupeNoEntries : liste de string - @param groupeNoEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques + @param groupeNoEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques sur lesquel on veut construire des groupes de noeuds. - + @rtype: bool @return: True si update OK, False en cas d'erreur """ result = False try: - #print 'CS_pbruno updateMesh( self, meshEntry=%s, groupeMaEntries=%s )'%( meshEntry, groupeMaEntries ) - corbaObject = self.__getCORBAObject( meshEntry ) - mesh = corbaObject._narrow( SMESH.SMESH_Mesh ) - - if mesh: # Ok, c'est bien un maillage + # print('CS_pbruno updateMesh( self, meshEntry=%s, groupeMaEntries=%s )'%( meshEntry, groupeMaEntries )) + corbaObject = self.__getCORBAObject(meshEntry) + mesh = corbaObject._narrow(SMESH.SMESH_Mesh) + + if mesh: # Ok, c'est bien un maillage shapeName = "" - meshType = None - - #création groupes de noeud + meshType = None + + # création groupes de noeud for shapeEntry in groupeNoEntries: - anObject = self.__getCORBAObject( shapeEntry ) - shape = anObject._narrow( GEOM.GEOM_Object ) - if shape: #Ok, c'est bien un objet géométrique - shapeName = self.getNameAttribute( shapeEntry ) - mesh.CreateGroupFromGEOM( SMESH.NODE, shapeName, shape ) + anObject = self.__getCORBAObject(shapeEntry) + shape = anObject._narrow(GEOM.GEOM_Object) + if shape: # Ok, c'est bien un objet géométrique + shapeName = self.getNameAttribute(shapeEntry) + mesh.CreateGroupFromGEOM(SMESH.NODE, shapeName, shape) else: - pass # CS_pbruno au choix: 1)une seule erreur arrète l'intégralité de l'opération - #return False # 2)ou on continue et essaye les suivants ( choix actuel + pass # CS_pbruno au choix: 1)une seule erreur arrète l'intégralité de l'opération + # return False # 2)ou on continue et essaye les suivants ( choix actuel - #création groupes de face + # création groupes de face for shapeEntry in groupeMaEntries: - meshType = self.__getMeshType( shapeEntry ) - if meshType: - anObject = self.__getCORBAObject( shapeEntry ) - shape = anObject._narrow( GEOM.GEOM_Object ) - if shape: #Ok, c'est bien un objet géométrique - shapeName = self.getNameAttribute( shapeEntry ) - mesh.CreateGroupFromGEOM( meshType, shapeName, shape ) + meshType = self.__getMeshType(shapeEntry) + if meshType: + anObject = self.__getCORBAObject(shapeEntry) + shape = anObject._narrow(GEOM.GEOM_Object) + if shape: # Ok, c'est bien un objet géométrique + shapeName = self.getNameAttribute(shapeEntry) + mesh.CreateGroupFromGEOM(meshType, shapeName, shape) else: - pass #CS_pbruno au choix: 1)une seule erreur arrète l'intégralité de l'opération - #return False # 2)ou on continue et essaye les suivants ( choix actuel ) + pass # CS_pbruno au choix: 1)une seule erreur arrète l'intégralité de l'opération + # return False # 2)ou on continue et essaye les suivants ( choix actuel ) else: - pass #CS_pbruno au choix: 1)une seule erreur arrète l'intégralité de l'opération - #return False # 2)ou on continue et essaye les suivants ( choix actuel ) + pass # CS_pbruno au choix: 1)une seule erreur arrète l'intégralité de l'opération + # return False # 2)ou on continue et essaye les suivants ( choix actuel ) result = True - + except: import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - logger.debug( '>>>>CS_Pbruno StudyTree.updateMesh( meshEntry= %s, groupeMaEntries = %s )' %( meshEntry, groupeMaEntries)) - logger.debug( 'type = %s , value = %s '%( type, value )) + ex_type = sys.exc_info()[0] + ex_value = sys.exc_info()[1] + logger.debug('>>>>CS_Pbruno StudyTree.updateMesh( meshEntry= %s, groupeMaEntries = %s )' % (meshEntry, groupeMaEntries)) + logger.debug('type = %s , value = %s ' % (ex_type, ex_value)) result = None return result - - - - - - - def createMesh( self, newMeshName, mainShapeEntry, groupeMaEntries, groupeNoEntries ): + + def createMesh(self, newMeshName, mainShapeEntry, groupeMaEntries, groupeNoEntries): """ - Création d'un objet maillage à partir d'un objet géométrique principal - Les groupes dans le maillage sont crée à partir des sous-objets géométriques - contenu dans la liste fourni en paramètre d'entré. + Création d'un objet maillage à partir d'un objet géométrique principal + Les groupes dans le maillage sont crée à partir des sous-objets géométriques + contenu dans la liste fourni en paramètre d'entré. @type newMeshName : string @param newMeshName : nom du nouveau maillage - + @type mainShapeEntry : string - @param mainShapeEntry : identifiant de l'objet géométrique principal - + @param mainShapeEntry : identifiant de l'objet géométrique principal + @type groupeMaEntries : liste de string - @param groupeMaEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques + @param groupeMaEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques sur lesquel on veut construire des groupes de face. @type groupeNoEntries : liste de string - @param groupeNoEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques + @param groupeNoEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques sur lesquel on veut construire des groupes de noeuds. - + @rtype: string - @return: identifiant( entry ) dans l'arbre d'étude du nouveau maillage, None en cas d'erreur. - """ + @return: identifiant( entry ) dans l'arbre d'étude du nouveau maillage, None en cas d'erreur. + """ result = False try: - #print 'CS_pbruno createMesh( self, newMeshName=%s, mainShapeEntry=%s, groupeMaEntries=%s )'%( newMeshName, mainShapeEntry, groupeMaEntries ) + # print('CS_pbruno createMesh( self, newMeshName=%s, mainShapeEntry=%s, groupeMaEntries=%s )' + # % (newMeshName, mainShapeEntry, groupeMaEntries)) newMesh = None - anObject = self.__getCORBAObject( mainShapeEntry ) - shape = anObject._narrow( GEOM.GEOM_Object ) - if shape: - # Création du nouveau maillage + anObject = self.__getCORBAObject(mainShapeEntry) + shape = anObject._narrow(GEOM.GEOM_Object) + if shape: + # Création du nouveau maillage if not self.smeshEngine: - self.smeshEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "SMESH" ) - self.smeshEngine.SetCurrentStudy( salome.myStudy ) - newMesh = self.smeshEngine.CreateMesh( shape ) - newMeshEntry = self.__getEntry( newMesh ) - if newMeshEntry: - ok = self.setName( newMeshEntry, newMeshName ) + self.smeshEngine = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH") + self.smeshEngine.SetCurrentStudy(salome.myStudy) + newMesh = self.smeshEngine.CreateMesh(shape) + newMeshEntry = self.__getEntry(newMesh) + if newMeshEntry: + ok = self.setName(newMeshEntry, newMeshName) if ok: - result = self.updateMesh( newMeshEntry, groupeMaEntries, groupeNoEntries ) + result = self.updateMesh(newMeshEntry, groupeMaEntries, groupeNoEntries) except: import sys - type = sys.exc_info()[0] - value = sys.exc_info()[1] - logger.debug( '>>>>CS_Pbruno StudyTree.createMesh( self, newMeshName=%s, mainShapeEntry=%s, groupeMaEntries=%s )'%( newMeshName, mainShapeEntry, groupeMaEntries)) - logger.debug( 'type = %s , value = %s '%( type, value )) + ex_type = sys.exc_info()[0] + ex_value = sys.exc_info()[1] + logger.debug('>>>>CS_Pbruno StudyTree.createMesh( self, newMeshName=%s, mainShapeEntry=%s, groupeMaEntries=%s )' + % (newMeshName, mainShapeEntry, groupeMaEntries)) + logger.debug('type = %s , value = %s ' % (ex_type, ex_value)) result = None return result - - - - - - - # -------------------------------------------------------------------------- # INIT study = SalomeStudy() - + -- 2.39.2