src/STUDY/EficasStudy.py

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