src/STUDY/EficasStudy.py

   1 # -*- coding: iso-8859-1 -*-
   2 import salomedsgui
   3 import salome
   4
   5 import SALOMEDS
   6 import GEOM
   7 import SMESH
   8
   9 from Logger import Logger
  10 logger=Logger( "EficasStudy" )
  11
  12
  13 #Nom des composants SALOME dans l'arbre d'étude
  14 SMesh  = "Mesh"
  15 SGeom  = "Geometry"
  16 SVisu  = "Post-Pro"
  17 SAster = "Aster"
  18
  19
  20 class SalomeStudy(   salomedsgui.guiDS ):
  21     """
  22     Classe de manipulation de l'arbre d'étude Salome. Cette classe permet à
  23     l'utilisateur de manipuler les objets de 'arbre d'étude via leurs
  24     identifiants( entry ).
  25
  26     Attention : Par défaut les opérations réalisée par cette classe portent sur
  27     une étude courante ( positionnée dans le constructeur ou par la méthode
  28     setCurrentStudyID() )
  29     """
  30     def __init__( self, studyID = salome.myStudyId ):
  31         salomedsgui.guiDS.__init__( self  )
  32         self.setCurrentStudy( studyID)
  33
  34         # spécifique méthode __getMeshType() :
  35         self.groupOp    = None
  36         self.geomEngine = None
  37
  38         # spécifique méthode createMesh() :
  39         self.smeshEngine = None
  40
  41
  42
  43     # --------------------------------------------------------------------------
  44     #   fonctions de manipulation générale ( porte sur toute l'arbre d'étude )
  45     def __getCORBAObject( self,  entry ):
  46         """
  47         Retourne l'objet CORBA correspondant son identifiant ( entry ) dans
  48         l'arbre d'étude.
  49
  50         @type   entry : string
  51         @param  entry : objet Corba
  52
  53         @rtype  :  objet CORBA
  54         @return :  l'objet CORBA,   None si erreur.
  55         """
  56         object = None
  57         try:
  58             mySO = self._myStudy.FindObjectID( entry )
  59             if mySO:
  60                 object = mySO.GetObject()
  61
  62                 if not object: # l'objet n'a pas encore chargé
  63                     path          = self._myStudy.GetObjectPath( mySO )# recherche du nom du composant
  64                     componentName = ( path.split('/')[1] ).strip()
  65
  66                     if componentName == SMesh:
  67                         strContainer, strComponentName = "FactoryServer", "SMESH"
  68                     elif componentName == SGeom:
  69                         strContainer, strComponentName = "FactoryServer", "GEOM"
  70                     elif componentName == SVisu:
  71                         strContainer, strComponentName = "FactoryServer", "VISU"
  72                     elif componentName == SAster:
  73                         strContainer, strComponentName = "FactoryServerPy", "ASTER"
  74                     else :
  75                         logger.debug('>>>>CS_Pbruno StudyTree.__getCORBAObject chargement du composant  %s non implémenté ' %componentName)
  76                         raise 'Erreur'
  77
  78                     myComponent = salome.lcc.FindOrLoadComponent( strContainer, strComponentName )
  79                     SCom        = self._myStudy.FindComponent( strComponentName )
  80                     self._myBuilder.LoadWith( SCom , myComponent  )
  81                     object      = mySO.GetObject()
  82         except:
  83             import sys
  84             type        = sys.exc_info()[0]
  85             value       = sys.exc_info()[1]
  86             logger.debug( '>>>>CS_Pbruno StudyTree.__getCORBAObject erreur recupération  objet corba ( entry = %s ) ' %entry)
  87             logger.debug( 'type        = %s ,             value       = %s '%( type, value ) )
  88             object = None
  89
  90         return object
  91
  92
  93     def __getEntry( self, corbaObject ):
  94         """
  95         Retourne l'identifiant ( entry ) ds l'arbre d'étude de l'objet CORBA
  96         passé en paramètre.
  97
  98         @type     corbaObject : objet Corba
  99         @param  corbaObject   : objet Corba
 100
 101         @rtype  :  string
 102         @return :  identifiant ( entry ),    None si erreur.
 103         """
 104         entry        = None
 105         currentStudy = self._myStudy
 106
 107         if corbaObject:
 108             ior = salome.orb.object_to_string( corbaObject )
 109             if ior:
 110                 sObject = currentStudy.FindObjectIOR(  ior )
 111                 entry   = sObject.GetID()
 112         return entry
 113
 114
 115
 116     def setCurrentStudyID( self, studyID):
 117         """
 118         Fixe l'étude courante sur laquel vont opérer toutes les fonctions
 119         de la classe.
 120         """
 121         self._father    = None
 122         self._component = None
 123         self._myStudy   = self._myStudyManager.GetStudyByID( studyID)
 124         self._myBuilder = self._myStudy.NewBuilder( )
 125
 126         salome.myStudy       = self._myStudy
 127         salome.myStudyId     = studyID
 128         salome.myStudyName   = self._myStudy._get_Name()
 129
 130     def refresh( self ):
 131         """
 132         Rafraichissement de l'arbre d'étude
 133         """
 134         salome.sg.updateObjBrowser(0)
 135
 136     def setName( self, entry, name ):
 137         """
 138         Fixe le nom( la valeur de l'attribut 'AttributeName' ) d'un objet de l'arbre d'étude
 139         désigné par son identifiant( entry )
 140
 141         @type   entry: string
 142         @param  entry: identifiant de l'objet dans l'arbre d'étude
 143
 144         @type   name: string
 145         @param  name: nom à attribuer
 146
 147         @rtype  :  boolean
 148         @return :  True si Ok, False sinon, None si erreur
 149         """
 150         result = False
 151         try:
 152             SObject = self._myStudy.FindObjectID( entry )
 153             A1      = self._myBuilder.FindOrCreateAttribute( SObject, "AttributeName" )
 154             AName   = A1._narrow(SALOMEDS.AttributeName)
 155             AName.SetValue( name )
 156             result = True
 157         except:
 158             import sys
 159             type        = sys.exc_info()[0]
 160             value       = sys.exc_info()[1]
 161             logger.debug( '>>>>CS_Pbruno StudyTree.setName ( entry = %s, name = %s )' %( entry, name ) )
 162             logger.debug( 'type        = %s ,             value       = %s '%( type, value ) )
 163             result = None
 164
 165         return result
 166
 167     def hasName( self, componentName, objectName ):
 168         """
 169         Vérifie si dans l'arbre d'étude le commposant de nom componentName
 170         possède un objet de nom objectName.
 171
 172         @type   componentName: string
 173         @param  componentName: nom du composant Salome
 174
 175         @type   objectName: string
 176         @param  objectName: nom de l'objet
 177
 178         @rtype  :  boolean
 179         @return :  True si Ok, False sinon,  None si erreur
 180         """
 181         result = False
 182         try:
 183             nom = {
 184                 SMesh:  "SMESH",
 185                 SGeom:  "GEOM",
 186                 SVisu:  "VISU",
 187                 SAster: "ASTER"
 188             }
 189             componentName = nom[ componentName ]
 190             SObjects = self._myStudy.FindObjectByName( objectName, componentName )
 191             if len( SObjects ) > 0:
 192                 result = True
 193         except:
 194             import sys
 195             type        = sys.exc_info()[0]
 196             value       = sys.exc_info()[1]
 197             logger.debug( '>>>>CS_Pbruno StudyTree.setName ( entry = %s, name = %s )' %( entry, name ) )
 198             logger.debug( 'type        = %s ,             value       = %s '%( type, value ) )
 199             result = None
 200
 201         return result
 202
 203
 204
 205
 206
 207     # --------------------------------------------------------------------------
 208     #   fonctions de manipulation des objets géométriques dans l'arbre d'étude
 209     #   ( éléments contenu dans la sous-rubrique "Geometry' )
 210     def isMainShape(  self,  entry ):
 211         """
 212         Teste si l'objet désigné par l'identifiant ( entry ) passé en argument
 213         est bien un objet géométrique principal.
 214
 215         @type   entry: string
 216         @param  entry: identifiant de l'objet
 217
 218         @rtype:   boolean
 219         @return:  True si Ok, False sinon
 220         """
 221         result = False
 222         try:
 223             anObject = self.__getCORBAObject(  entry )
 224             shape    = anObject._narrow( GEOM.GEOM_Object )
 225             if shape.IsMainShape():
 226                 result = True
 227         except:
 228             import sys
 229             type        = sys.exc_info()[0]
 230             value       = sys.exc_info()[1]
 231             logger.debug( '>>>>CS_Pbruno StudyTree.isMainShape( entry = %s ) ' %entry )
 232             logger.debug( 'type        = %s ,             value       = %s '%( type, value ) )
 233             result = False
 234         return result
 235
 236
 237     def getMainShapeEntry(  self,  entry ):
 238         """
 239         Retourne l'identifiant de l'objet géométrique principal du sous-objet géométrique désigné par
 240         l'identifiant ( entry ) passé en paramètre.
 241
 242         @type   entry: string
 243         @param  entry: identifiant du sous-objet géométrique
 244
 245         @rtype  :  string
 246         @return :  identifiant de  l'objet géométrique principal, None si erreur.
 247         """
 248         result = None
 249         try :
 250             if self.isMainShape( entry ):
 251                 result = entry
 252             else:
 253                 anObject = self.__getCORBAObject(  entry )
 254                 shape    = anObject._narrow( GEOM.GEOM_Object )
 255                 objMain  = shape.GetMainShape()
 256                 result   = self.__getEntry( objMain )
 257         except :
 258             import sys
 259             type        = sys.exc_info()[0]
 260             value       = sys.exc_info()[1]
 261             print '>>>>CS_Pbruno StudyTree.getMainShapeEntry( entry = %s ) ' %entry
 262             print 'type        = %s ,             value       = %s '%( type, value )
 263             result = None
 264
 265         return result
 266
 267     def sameMainShape(  self,  shapeEntry1, shapeEntry2 ):
 268         """
 269         Détermine si les objets géometriques fournis en argument sont les
 270         sous-objets d'une même géométrie principale
 271
 272         @type   shapeEntry1: string
 273         @param  shapeEntry1: identifiant dans l'arbre d'étude d'un objet géométrique
 274
 275         @type   shapeEntry2: string
 276         @param  shapeEntry2: identifiant dans l'arbre d'étude d'un objet géométrique
 277
 278         @rtype  :  boolean
 279         @return :  True si même objet principal, False sinon, None si erreur.
 280         """
 281         result = None
 282         try :
 283             mainShape1 = self.getMainShapeEntry( shapeEntry1 )
 284             if mainShape1:
 285                 mainShape2 = self.getMainShapeEntry( shapeEntry2 )
 286                 if mainShape2:
 287                     result = mainShape1 == mainShape2
 288         except :
 289             import sys
 290             type        = sys.exc_info()[0]
 291             value       = sys.exc_info()[1]
 292             print '>>>>CS_Pbruno StudyTree.sameMainShape(  shapeEntry1 = %s , shapeEntry2 = %s )'%( shapeEntry1, shapeEntry2 )
 293             print 'type        = %s ,             value       = %s '%( type, value )
 294             result = None
 295
 296         return result
 297
 298
 299     # --------------------------------------------------------------------------
 300     #   fonctions de manipulation des objets maillages  dans l'arbre d'étude
 301     #   ( éléments contenu dans la sous-rubrique 'Mesh' )
 302     def __getMeshType( self, shapeEntry ):
 303         """
 304         Determination du type de maille en fonction de la géométrie pour les conditions aux limites.
 305
 306         @type     shapeEntry : string
 307         @param  shapeEntry : identifiant de l'objet géométrique
 308
 309         @rtype:   SMESH::ElementType ( voir SMESH_Mesh.idl )
 310         @return:  type de maillage, None si erreur.
 311         """
 312         result = None
 313
 314         try:
 315             anObject = self.__getCORBAObject(  shapeEntry )
 316             shape    = anObject._narrow( GEOM.GEOM_Object )
 317
 318             if shape: #Ok, c'est bien un objet géométrique
 319                 tgeo = str( shape.GetShapeType() )
 320
 321                 meshTypeStr = {
 322                     "VERTEX" :         SMESH.NODE,
 323                     "EDGE":             SMESH.EDGE,
 324                     "FACE":             SMESH.FACE,
 325                     "SOLID":            SMESH.VOLUME,
 326                     "COMPOUND" :  None
 327                 }
 328                 result = meshTypeStr[ tgeo]
 329                 if result == None:
 330                     if not self.geomEngine:
 331                         self.geomEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" )
 332                     if not self.GroupOp:
 333                         self.GroupOp  = self.geomEngine.GetIGroupOperations(  salome.myStudyId )
 334
 335                     tgeo = self.GroupOp.GetType( shape )
 336                     meshTypeInt = { #Voir le dictionnnaire ShapeType dans geompy.py pour les correspondances type - numero.
 337                         7:      SMESH.NODE,
 338                         6:      SMESH.EDGE,
 339                         4:      SMESH.FACE,
 340                         2:      SMESH.VOLUME
 341                     }
 342                     if meshTypeInt.has_key(  int( tgeo ) ):
 343                         result = meshTypeInt[ tgeo]
 344         except:
 345             import sys
 346             type        = sys.exc_info()[0]
 347             value       = sys.exc_info()[1]
 348             logger.debug( '>>>>CS_Pbruno StudyTree.__getMeshType( shapeEntry  = %s ) ' %shapeEntry )
 349             logger.debug( 'type        = %s ,             value       = %s '%( type, value ))
 350             result = None
 351
 352         return result
 353
 354     def getAllMeshReferencingMainShape( self, mainShapeEntry ):
 355         """
 356         Retourne une liste de tous les maillages construits à partir de l'objet
 357         principal géométrique passé en argument
 358
 359         @type     mainShapeEntry : string
 360         @param    mainShapeEntry : identifiant( entry ) de l'objet  principal géométrique
 361
 362         @rtype:   list
 363         @return:  liste des identifiants( entry ) des maillages, liste vide si aucun , None si erreur.
 364         """
 365         result = []
 366
 367         try:
 368             if self.isMainShape(  mainShapeEntry ):
 369                 mainShapeSO = salome.IDToSObject( mainShapeEntry )
 370                 SObjectList = self._myStudy.FindDependances( mainShapeSO )
 371                 print '####  mainShapeSO=%s , SObjectList  = %s'%( mainShapeSO, SObjectList )
 372                 if SObjectList: #Ok, il y a des objet référençant la mainShape
 373                     for SObject in SObjectList: # Recherche du type de chacun des objets
 374                         SFatherComponent = SObject.GetFatherComponent()
 375                         print '####  SFatherComponent = %s'%SFatherComponent
 376                         if SFatherComponent.GetName() == SMesh: #Ok, l'objet est un objet du composant 'Mesh'
 377                             SFather = SObject.GetFather()
 378                             print '####  SFather= %s'%SFather
 379                             ##CorbaObject = SFather.GetObject()
 380                             FatherEntry = SFather.GetID()
 381                             CorbaObject  = self.__getCORBAObject(  FatherEntry )
 382                             print '####  CorbaObject = %s'%CorbaObject
 383                             MeshObject = CorbaObject ._narrow( SMESH.SMESH_Mesh )
 384                             print '####  MeshObject = %s'%MeshObject
 385                             if MeshObject : #Ok, l'objet est un objet 'maillage'
 386                                 MeshObjectEntry = self.__getEntry( MeshObject )
 387                                 print '####  MeshObjectEntry = %s'%MeshObjectEntry
 388                                 if MeshObjectEntry:
 389                                     result.append( MeshObjectEntry )  # On l'ajoute ds la liste résultat!
 390             else: # c'est pas une mainShape !
 391                 result = None
 392         except :
 393             import sys
 394             type        = sys.exc_info()[0]
 395             value       = sys.exc_info()[1]
 396             logger.debug( '>>>>CS_Pbruno StudyTree.getAllMeshReferencingMainShape( mainShapeEntry  = %s ) ' %mainShapeEntry )
 397             logger.debug( 'type        = %s ,             value       = %s '%( type, value ))
 398             result = None
 399
 400         return result
 401
 402
 403
 404     def updateMesh( self,  meshEntry, groupeMaEntries, groupeNoEntries ):
 405         """
 406         Met à jours d'un objet maillage à partir d'une liste de sous-objet géométrique.
 407         L'opération consiste à créer des groupes dans le maillage correspondant
 408         aux sous-objets géométrique de la liste.
 409
 410         CS_pbruno Attention: ajoute des groupes sans vérifier si auparavant ils ont déjà été crées
 411
 412         @type   meshEntry : string
 413         @param  meshEntry : identifiant du maillage
 414
 415         @type   groupeMaEntries : liste de string
 416         @param  groupeMaEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques
 417                                   sur lesquel on veut construire des groupes de face.
 418
 419         @type   groupeNoEntries : liste de string
 420         @param  groupeNoEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques
 421                                   sur lesquel on veut construire des groupes de noeuds.
 422
 423         @rtype:   bool
 424         @return:  True si update OK, False en cas d'erreur
 425         """
 426         result = False
 427         try:
 428             #print 'CS_pbruno updateMesh( self,  meshEntry=%s,   groupeMaEntries=%s )'%( meshEntry,   groupeMaEntries )
 429             corbaObject = self.__getCORBAObject(  meshEntry  )
 430             mesh        = corbaObject._narrow( SMESH.SMESH_Mesh )
 431
 432             if mesh: # Ok, c'est bien un maillage
 433                 shapeName = ""
 434                 meshType  = None
 435
 436                 #création groupes de noeud
 437                 for shapeEntry in groupeNoEntries:
 438                     anObject = self.__getCORBAObject(  shapeEntry )
 439                     shape    = anObject._narrow( GEOM.GEOM_Object )
 440                     if shape: #Ok, c'est bien un objet géométrique
 441                         shapeName = self.getNameAttribute( shapeEntry )
 442                         mesh.CreateGroupFromGEOM( SMESH.NODE, shapeName, shape )
 443                     else:
 444                         pass            # CS_pbruno au choix: 1)une seule erreur arrète l'intégralité de l'opération
 445                         #return False   #                    2)ou on continue et essaye les suivants ( choix actuel
 446
 447                 #création groupes de face
 448                 for shapeEntry in groupeMaEntries:
 449                     meshType = self.__getMeshType( shapeEntry )
 450                     if meshType:
 451                         anObject = self.__getCORBAObject(  shapeEntry )
 452                         shape    = anObject._narrow( GEOM.GEOM_Object )
 453                         if shape: #Ok, c'est bien un objet géométrique
 454                             shapeName = self.getNameAttribute( shapeEntry )
 455                             mesh.CreateGroupFromGEOM( meshType, shapeName, shape )
 456                         else:
 457                             pass            #CS_pbruno au choix: 1)une seule erreur arrète l'intégralité de l'opération
 458                             #return False   #                    2)ou on continue et essaye les suivants ( choix actuel )
 459                     else:
 460                         pass            #CS_pbruno au choix: 1)une seule erreur arrète l'intégralité de l'opération
 461                         #return False   #                    2)ou on continue et essaye les suivants ( choix actuel )
 462
 463                 result = True
 464
 465         except:
 466             import sys
 467             type        = sys.exc_info()[0]
 468             value       = sys.exc_info()[1]
 469             logger.debug( '>>>>CS_Pbruno StudyTree.updateMesh( meshEntry= %s,   groupeMaEntries = %s )' %( meshEntry, groupeMaEntries))
 470             logger.debug( 'type        = %s ,             value       = %s '%( type, value ))
 471             result = None
 472         return result
 473
 474
 475
 476
 477
 478
 479     def createMesh( self, newMeshName, mainShapeEntry, groupeMaEntries, groupeNoEntries ):
 480         """
 481         Création d'un objet maillage à partir d'un objet géométrique principal
 482         Les groupes dans le maillage sont crée à partir des sous-objets géométriques
 483         contenu dans la liste fourni en paramètre d'entré.
 484
 485         @type   newMeshName : string
 486         @param  newMeshName : nom du nouveau maillage
 487
 488         @type   mainShapeEntry : string
 489         @param  mainShapeEntry : identifiant de l'objet géométrique principal
 490
 491         @type   groupeMaEntries : liste de string
 492         @param  groupeMaEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques
 493                                   sur lesquel on veut construire des groupes de face.
 494
 495         @type   groupeNoEntries : liste de string
 496         @param  groupeNoEntries : liste contenant les identifiants ( entry ) des sous-objets géométriques
 497                                   sur lesquel on veut construire des groupes de noeuds.
 498
 499         @rtype:   string
 500         @return:  identifiant( entry ) dans l'arbre d'étude du nouveau maillage, None en cas d'erreur.
 501         """
 502         result = False
 503         try:
 504             #print 'CS_pbruno createMesh( self, newMeshName=%s, mainShapeEntry=%s, groupeMaEntries=%s )'%( newMeshName, mainShapeEntry, groupeMaEntries )
 505             newMesh = None
 506             anObject = self.__getCORBAObject(  mainShapeEntry )
 507             shape    = anObject._narrow( GEOM.GEOM_Object )
 508             if shape:
 509                 # Création du nouveau maillage
 510                 if not self.smeshEngine:
 511                     self.smeshEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "SMESH" )
 512                     self.smeshEngine.SetCurrentStudy( salome.myStudy )
 513                 newMesh      = self.smeshEngine.CreateMesh( shape )
 514                 newMeshEntry = self.__getEntry( newMesh )
 515                 if newMeshEntry:
 516                     ok = self.setName( newMeshEntry, newMeshName )
 517                     if ok:
 518                         result = self.updateMesh( newMeshEntry, groupeMaEntries, groupeNoEntries )
 519         except:
 520             import sys
 521             type        = sys.exc_info()[0]
 522             value       = sys.exc_info()[1]
 523             logger.debug( '>>>>CS_Pbruno StudyTree.createMesh( self, newMeshName=%s, mainShapeEntry=%s, groupeMaEntries=%s )'%( newMeshName, mainShapeEntry, groupeMaEntries))
 524             logger.debug( 'type        = %s ,             value       = %s '%( type, value ))
 525             result = None
 526         return result
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536 # --------------------------------------------------------------------------
 537 #   INIT
 538 study = SalomeStudy()
 539