# -*- 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):
"""
"""
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:
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,
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")
-
-# -*- 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"
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()
-
+
