src/EELIH/c_geometrie.py

   1 # -*- coding: iso-8859-1 -*-
   2
   3 # module salome
   4 import salome
   5 # module eficas
   6 import SMESH_utils
   7 # module GEOM
   8 import GEOM
   9 # module de bases
  10 import string
  11 # module pour le maillage
  12 import maillage
  13
  14 class C_geometrie:
  15     """
  16     controleur de la classe Geometrie, permet la sélection de la géométrie dans l'arbre d'étude
  17     de Salome. Met à jour les champs correspondants (sous-géométries, ...)
  18     - geometrie = référence sur le panneau géométrie
  19     - dicoSousGeom = clé = IORString
  20                      valeur = name
  21     """
  22     def __init__(self, appli, geometrie):
  23         self.appli = appli
  24         self.geometrie = geometrie
  25         self.dicoSousGeom = []
  26
  27     def getGeometrie(self):
  28         """
  29         affecte le nom de la géométrie sélectionnée dans l'arbre d'étude de Salome
  30         à l'instance étude de l'application et au lineedit correspondant
  31         """
  32         # récupération de tous les objets sélectionnés dans l'arbre d'étude
  33         listeSelection = salome.sg.getAllSelected()
  34         if len(listeSelection) > 1:
  35             print "----------------------------------------"
  36             print "1 seule géométrie doit être sélectionnée"
  37         elif len(listeSelection)  == 0:
  38             print "----------------------------------------"
  39             print "Sélectionnez une géométrie"
  40         else:
  41             # on teste si l'objet sélectionné est une géométrie et s'il possède des fils
  42             import EFICASGUI
  43             import salomedsgui
  44             anObject=SMESH_utils.entryToIor(salome.myStudy,listeSelection[0])
  45             if not anObject: # l'objet n'a pas encore chargé
  46                strContainer, strComponentName = "FactoryServer", "GEOM"
  47                myComponent = salome.lcc.FindOrLoadComponent( strContainer, strComponentName )
  48                SCom=salome.myStudy.FindComponent( strComponentName )
  49                myBuilder = salome.myStudy.NewBuilder()
  50                myBuilder.LoadWith( SCom , myComponent  )
  51                anObject=SMESH_utils.entryToIor(salome.myStudy,listeSelection[0])
  52             type = None
  53             try:
  54                type = anObject._narrow(GEOM.GEOM_Object)
  55             except:
  56                pass
  57
  58             # le type doit être une géométrie
  59             if type == None:
  60                print "----------------------------------------"
  61                print "Sélectionnez une géométrie"
  62             # type = géométrie
  63             else:
  64               # on vérifie que cette géométrie possède au moins un fils qui soit une géoméotrie
  65               geom = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" )
  66               group = geom.GetIMeasureOperations(EFICASGUI.currentStudyId)
  67               nom = SMESH_utils.entryToName(salome.myStudy, listeSelection)
  68
  69               # modelisation 3D --> il faut un SOLID
  70               if self.appli.etude.modelisation == '3D':
  71                  n = string.find(group.WhatIs(type), 'SOLID')
  72                  if group.WhatIs(type)[n+8] != 0:
  73                     liste = []
  74                     liste = [nom[0], listeSelection[0]]
  75                     self.geometrie.ln.setText(nom[0])
  76                     self.appli.etude.setGeometrie(liste)
  77                     # groupes de mailles = face ou shell
  78                     self.dicoSousGeom = SMESH_utils.getSubGeometryIorAndName(salome.myStudy, self.appli.etude.geometrie)
  79                     listeSousGeom = []
  80                     for maille in self.dicoSousGeom.keys():
  81                        anObject = SMESH_utils.iorStringToIor(maille)
  82                        type = anObject._narrow(GEOM.GEOM_Object)
  83                        n = string.find(group.WhatIs(type), 'FACE')
  84                        if group.WhatIs(type)[n+7] != 0:
  85                           listeSousGeom.append(self.dicoSousGeom[maille])
  86                        else:
  87                           n = string.find(group.WhatIs(type), 'SHELL')
  88                           if group.WhatIs(type)[n+8] != 0:
  89                              listeSousGeom.append(self.dicoSousGeom[maille])
  90
  91                     listeSousGeom.sort()
  92                     self.appli.etude.setSousGeometrie(listeSousGeom)
  93
  94                  else:
  95                     print "----------------------------------------"
  96                     print "Pour une modélisation 3D, la géométrie sélectionnée doit être un solide."
  97
  98               # modelisation 2D --> SHELL ou FACE
  99               if string.find(self.appli.etude.modelisation, '2D') != -1:
 100                  liste = []
 101                  liste = [nom[0], listeSelection[0]]
 102                  self.geometrie.ln.setText(nom[0])
 103                  self.appli.etude.setGeometrie(liste)
 104                  self.dicoSousGeom = SMESH_utils.getSubGeometryIorAndName(salome.myStudy, self.appli.etude.geometrie)
 105                  listeSousGeom = []
 106                  n = string.find(group.WhatIs(type), 'SHELL')
 107                  if group.WhatIs(type)[n+8] != 0:
 108                     # groupes de mailles = edge
 109                     for maille in self.dicoSousGeom.keys():
 110                        anObject = SMESH_utils.iorStringToIor(maille)
 111                        type = anObject._narrow(GEOM.GEOM_Object)
 112                        n = string.find(group.WhatIs(type), 'EDGE')
 113                        if group.WhatIs(type)[n+7] != 0:
 114                           listeSousGeom.append(self.dicoSousGeom[maille])
 115                  else:
 116                     n = string.find(group.WhatIs(type), 'FACE')
 117                     if group.WhatIs(type)[n+7] != 0:
 118                        # groupes de mailles = edge
 119                        for maille in self.dicoSousGeom.keys():
 120                           anObject = SMESH_utils.iorStringToIor(maille)
 121                           type = anObject._narrow(GEOM.GEOM_Object)
 122                           n = string.find(group.WhatIs(type), 'EDGE')
 123                           if group.WhatIs(type)[n+7] != 0:
 124                              listeSousGeom.append(self.dicoSousGeom[maille])
 125
 126                  listeSousGeom.sort()
 127                  self.appli.etude.setSousGeometrie(listeSousGeom)
 128
 129               # on cree le bon nombre de panneaux maillages : autant qu'il y a de sous geometries
 130               #self.createMeshPanel()
 131               #print "-----------------------------"
 132               #print "-----------------------------"
 133               #print "-----------------------------"
 134               #print "-----------------------------"
 135               #print "-----------------------------"
 136               #print "-----------------------------"
 137               #print "-----------------------------"
 138               #print "liste des panneaux ="
 139               #print self.appli.mw.listePanels
 140
 141 #    def createMeshPanel(self):
 142 #       """
 143 #       cree autant de panneaux maillages que de sous geometries
 144 #       """
 145 #       self.listeMaillages = []
 146 #       for i in self.appli.etude.sousGeometrie:
 147 #          mesh = maillage.Maillage(self.appli.mw.ws, self.appli)
 148 #         self.listeMaillages.append(mesh)
 149 #          self.appli.mw.listePanels.append(mesh)
 150 #         #self.appli.mw.listePanels.insert(0, self.appli.mw.listePanels[0] + 1)
 151 #          #del self.appli.mw.listePanels[1]
 152
 153 #         self.updateGeomMaillage(mesh, i)
 154
 155     def getSousGeometrie(self):
 156         """
 157         retourne les sous-géométries de la géométrie sélectionnée dans l'arbre d'étude de Salome
 158         """
 159         liste = SMESH_utils.getSubGeometry(salome.myStudy, self.geometrie.appli.etude.geometrie)
 160         liste.sort()
 161         return liste
 162
 163     def updateComboSousGeom(self):
 164         """
 165         affecte les combobox des tables des panneaux ddl et pression avec les valeurs
 166         des sous-géométries
 167         """
 168         # insertion pour le panneau ddl
 169         for cmb in self.geometrie.appli.mw.ddl.controleurNouvelleLigneTable.controleurTable.listeComboGeom:
 170             cmb.insertStrList(self.geometrie.appli.etude.sousGeometrie)
 171
 172         # insertion pour le panneau pression
 173         for cmb in self.geometrie.appli.mw.pression.controleurNouvelleLigneTable.controleurTable.listeComboGeom:
 174             cmb.insertStrList(self.geometrie.appli.etude.sousGeometrie)
 175
 176     def updateGeomMaillage(self, maillage, sousGeom):
 177         """
 178         affecte le label indiquant la géométrie sélectionnée du panneau maillage
 179         affecte la listbox du panneau maillage avec les valeurs des maillages trouvés dans l'arbre d'étude
 180         Salome correspondant à la géométrie sélectionnée
 181         """
 182         # affectation de la géométrie sélectionnée au label du panneau maillage
 183         maillage.lblGeom2.setText(str(self.appli.etude.geometrie[0]))
 184
 185         # affectation de la sous géométrie au label du panneau maillage
 186         maillage.lblSousGeom2.setText(str(sousGeom))
 187
 188         # récupération des mailles correspondants
 189         import eelihCL
 190         maillage.cl=eelihCL.CLinit()
 191         # récupération de l'IOR des sous géométries
 192         GEOMIor = []
 193         for iorSousGeom in self.dicoSousGeom.keys():
 194            GEOMIor.append(iorSousGeom)
 195            maillage.cl.GetOrCreateCL(iorSousGeom)
 196            #self.appli.mw.maillage.cl.traiteCL()
 197         maillage.cl.get_geoms()
 198         maillage.cl.get_maillages()
 199 #
 200         maillage.cl.MainShapes(0)
 201 #
 202         listeMaillage = maillage.cl.Possibles(0, str(self.appli.etude.geometrie[0]))
 203         # insertion des maillages trouvés dans la listbox du panneau maillage
 204         # si aucun maillage on disable la listbox
 205         # sinon on disable le lineedit pour donner le nom d'un nouveau maillage
 206         if listeMaillage != []:
 207             maillage.lbMaillage.insertStrList(listeMaillage)
 208             #maillage.lbMaillage.setEnabled(1)
 209             #maillage.lblMaillage.setEnabled(1)
 210             #maillage.lblNouveauMaillage.setEnabled(0)
 211             #maillage.lnNouveauMaillage.setEnabled(0)
 212         #else:
 213             #maillage.lnNouveauMaillage.setEnabled(1)
 214             #maillage.lblNouveauMaillage.setEnabled(1)
 215             #maillage.lbMaillage.setEnabled(0)
 216             #maillage.lblMaillage.setEnabled(0)
 217
 218
 219     def convertit_group_maille_from_salome(self,liste_in):
 220         """
 221         convertit les groupes de maille
 222         """
 223         newr=[]
 224         if [ 1 == 1 ]:
 225             for entree in liste_in :
 226                 travail=[]
 227                 travail.append(entree)
 228                 if dict_geom_numgroupe.has_key(entree):
 229                     r=dict_geom_numgroupe[entree]
 230                 else:
 231                     r=SMESH_utils.getAsterGroupMa(salome.myStudy,travail)
 232                     dict_geom_numgroupe[entree]=r
 233                 for i in r :
 234                     newr.append(i)
 235         else :
 236             print "pas de groupe de maille associé"
 237             showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de maille")
 238         return newr
 239
 240     def convertit_entrees_en_valeurs(self,liste_faces):
 241         """
 242         convertit les entry de l'arbre d'étude en valeur
 243         """
 244         valeur=self.convertit_group_maille_from_salome(liste_faces)
 245         if valeur == []:
 246             print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
 247             print "Pb pas de fonction de conversion de la valeur Salome en valeur Aster"
 248             print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
 249         print "VALEUR", valeur
 250         if len(valeur) == 1:
 251             valeur = "'" + str(valeur[0]) + "'"
 252         return valeur
 253
 254     def add_selection(self):
 255         """
 256         retourne le nom des objets sélectionnés dans l'arbre d'étude
 257         """
 258         entrychaine=salome.sg.getAllSelected()
 259         if len(entrychaine) >= 1:
 260            print "1 seule géométrie doit être sélectionnée"
 261
 262
 263         # liste des faces sélectionnées dans ddl et pression
 264 #       liste_faces = []
 265 #       for face in self.appli.etude.ddls:
 266 #          if face[0] not in liste_faces:
 267 #             liste_faces.append(face[0])
 268
 269 #       for face in self.appli.etude.chargements:
 270 #          if face[0] not in liste_faces:
 271 #             liste_faces.append(face[0])
 272 #        if liste_faces != '':
 273         liste_faces = []
 274         #liste_faces.append('0:1:2:1:1')
 275         #liste_faces.append('0:1:2:1:2')
 276
 277         # récupération de toutes les sous géométries
 278         for sousGeom in self.appli.etude.sousGeometrie:
 279            SO = salome.myStudy.FindObject(str(sousGeom))
 280            liste_faces.append(SO.GetID())
 281
 282         touteslesvaleurs = self.convertit_entrees_en_valeurs(liste_faces)
 283         #liste_faces = []
 284         #liste_faces.append('0:1:2:1:2')
 285         #touteslesvaleurs = self.convertit_entrees_en_valeurs(liste_faces)
 286         return touteslesvaleurs
 287
 288 dict_geom_numgroupe = { }
 289 dict_geom_numface = { }