From: salome <> Date: Fri, 30 Sep 2005 16:55:57 +0000 (+0000) Subject: Intégration eficas_novice X-Git-Tag: EFICAS_before_burge~9 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=6e55bad2ff24ba98ec28956514cfb87dcfaa7a35;p=modules%2Feficas.git Intégration eficas_novice --- diff --git a/src/EELIH/Makefile.in b/src/EELIH/Makefile.in new file mode 100644 index 00000000..69d7fc38 --- /dev/null +++ b/src/EELIH/Makefile.in @@ -0,0 +1,64 @@ +#============================================================================== +# File : Makefile.in +# Created : dim déc 9 18:35:11 CET 2001 +# Author : Paul RASCLE, EDF +# Project : SALOME +# Copyright : EDF 2001 +#============================================================================== + +# source path +top_srcdir=@top_srcdir@ +top_builddir=../.. +srcdir=@srcdir@ +VPATH=.:@srcdir@:@top_srcdir@/idl:$(top_builddir)/idl:${KERNEL_ROOT_DIR}/idl/salome + + +@COMMENCE@ + +# header files +EXPORT_HEADERS= + + +# Libraries targets + +LIB = +LIB_SRC = + +LIB_CLIENT_IDL = + +LIB_SERVER_IDL = + +EXPORT_PYSCRIPTS = \ +appli.py \ +c_nouvelleLigneTableDdl.py \ +ddl.py \ +fichier.py \ +materiau.py \ +pression.py \ +c_nouvelleLigneTablePression.py \ +eelih.py \ +geometrie.py \ +modelisation.py \ +publication.py \ +c_geometrie.py \ +c_selectionGeometrie.py \ +maillage.py \ +c_maillage.py \ +c_suppressionLigneTable.py \ +eficas_novice.py \ +mainwindow.py \ +panelbase.py \ +validationlineedit.py \ +c_modelisation.py \ +c_table.py \ +eelihCL.py + +# additionnal information to compil and link file + +CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES) $(SIP_INCLUDES) +CPPFLAGS += -I$(top_builddir)/SALOME/src/SALOME_PYQT +CXXFLAGS += + +LDFLAGS += $(PYTHON_LIBS) $(PYQT_LIBS) -lSalomeGUI + +@CONCLUDE@ diff --git a/src/EELIH/appli.py b/src/EELIH/appli.py new file mode 100644 index 00000000..d555d528 --- /dev/null +++ b/src/EELIH/appli.py @@ -0,0 +1,30 @@ +# -*- coding: iso-8859-1 -*- + +# modules de l'application +from mainwindow import * +from modelisation import * +from materiau import * +import eelih + +class Appli: + """ + Définit l'application : + - salome = référence de l'étude Salome + - etude = définie les valeurs à saisir + - mw = interface graphique + - flagEficasOrAster = E si Eficas a été chargé (fichier .comm enregistré manuellement par l'utilisateur) + A si Aster a été chargé (fichier .comm enregistré automatiquement dans /tmp) + """ + def __init__(self, salomeRef, flag): + # référence à Salome + self.salome = salomeRef + + # flag pour l'enregistrement du fichier de commande + self.flagEficasOrAster = flag + + # création de l'étude + self.etude = eelih.Eelih() + + # création de la fenêtre principale + self.mw = MainWindow(self) + self.mw.show() diff --git a/src/EELIH/c_geometrie.py b/src/EELIH/c_geometrie.py new file mode 100644 index 00000000..8a906093 --- /dev/null +++ b/src/EELIH/c_geometrie.py @@ -0,0 +1,289 @@ +# -*- coding: iso-8859-1 -*- + +# module salome +import salome +# module eficas +import SMESH_utils +# module GEOM +import GEOM +# module de bases +import string +# module pour le maillage +import maillage + +class C_geometrie: + """ + controleur de la classe Geometrie, permet la sélection de la géométrie dans l'arbre d'étude + de Salome. Met à jour les champs correspondants (sous-géométries, ...) + - geometrie = référence sur le panneau géométrie + - dicoSousGeom = clé = IORString + valeur = name + """ + def __init__(self, appli, geometrie): + self.appli = appli + self.geometrie = geometrie + self.dicoSousGeom = [] + + def getGeometrie(self): + """ + affecte le nom de la géométrie sélectionnée dans l'arbre d'étude de Salome + à l'instance étude de l'application et au lineedit correspondant + """ + # récupération de tous les objets sélectionnés dans l'arbre d'étude + listeSelection = salome.sg.getAllSelected() + if len(listeSelection) > 1: + print "----------------------------------------" + print "1 seule géométrie doit être sélectionnée" + elif len(listeSelection) == 0: + print "----------------------------------------" + print "Sélectionnez une géométrie" + else: + # on teste si l'objet sélectionné est une géométrie et s'il possède des fils + import EFICASGUI + import salomedsgui + anObject=SMESH_utils.entryToIor(salome.myStudy,listeSelection[0]) + if not anObject: # l'objet n'a pas encore chargé + strContainer, strComponentName = "FactoryServer", "GEOM" + myComponent = salome.lcc.FindOrLoadComponent( strContainer, strComponentName ) + SCom=salome.myStudy.FindComponent( strComponentName ) + myBuilder = salome.myStudy.NewBuilder() + myBuilder.LoadWith( SCom , myComponent ) + anObject=SMESH_utils.entryToIor(salome.myStudy,listeSelection[0]) + type = None + try: + type = anObject._narrow(GEOM.GEOM_Object) + except: + pass + + # le type doit être une géométrie + if type == None: + print "----------------------------------------" + print "Sélectionnez une géométrie" + # type = géométrie + else: + # on vérifie que cette géométrie possède au moins un fils qui soit une géoméotrie + geom = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" ) + group = geom.GetIMeasureOperations(EFICASGUI.currentStudyId) + nom = SMESH_utils.entryToName(salome.myStudy, listeSelection) + + # modelisation 3D --> il faut un SOLID + if self.appli.etude.modelisation == '3D': + n = string.find(group.WhatIs(type), 'SOLID') + if group.WhatIs(type)[n+8] != 0: + liste = [] + liste = [nom[0], listeSelection[0]] + self.geometrie.ln.setText(nom[0]) + self.appli.etude.setGeometrie(liste) + # groupes de mailles = face ou shell + self.dicoSousGeom = SMESH_utils.getSubGeometryIorAndName(salome.myStudy, self.appli.etude.geometrie) + listeSousGeom = [] + for maille in self.dicoSousGeom.keys(): + anObject = SMESH_utils.iorStringToIor(maille) + type = anObject._narrow(GEOM.GEOM_Object) + n = string.find(group.WhatIs(type), 'FACE') + if group.WhatIs(type)[n+7] != 0: + listeSousGeom.append(self.dicoSousGeom[maille]) + else: + n = string.find(group.WhatIs(type), 'SHELL') + if group.WhatIs(type)[n+8] != 0: + listeSousGeom.append(self.dicoSousGeom[maille]) + + listeSousGeom.sort() + self.appli.etude.setSousGeometrie(listeSousGeom) + + else: + print "----------------------------------------" + print "Pour une modélisation 3D, la géométrie sélectionnée doit être un solide." + + # modelisation 2D --> SHELL ou FACE + if string.find(self.appli.etude.modelisation, '2D') != -1: + liste = [] + liste = [nom[0], listeSelection[0]] + self.geometrie.ln.setText(nom[0]) + self.appli.etude.setGeometrie(liste) + self.dicoSousGeom = SMESH_utils.getSubGeometryIorAndName(salome.myStudy, self.appli.etude.geometrie) + listeSousGeom = [] + n = string.find(group.WhatIs(type), 'SHELL') + if group.WhatIs(type)[n+8] != 0: + # groupes de mailles = edge + for maille in self.dicoSousGeom.keys(): + anObject = SMESH_utils.iorStringToIor(maille) + type = anObject._narrow(GEOM.GEOM_Object) + n = string.find(group.WhatIs(type), 'EDGE') + if group.WhatIs(type)[n+7] != 0: + listeSousGeom.append(self.dicoSousGeom[maille]) + else: + n = string.find(group.WhatIs(type), 'FACE') + if group.WhatIs(type)[n+7] != 0: + # groupes de mailles = edge + for maille in self.dicoSousGeom.keys(): + anObject = SMESH_utils.iorStringToIor(maille) + type = anObject._narrow(GEOM.GEOM_Object) + n = string.find(group.WhatIs(type), 'EDGE') + if group.WhatIs(type)[n+7] != 0: + listeSousGeom.append(self.dicoSousGeom[maille]) + + listeSousGeom.sort() + self.appli.etude.setSousGeometrie(listeSousGeom) + + # on cree le bon nombre de panneaux maillages : autant qu'il y a de sous geometries + #self.createMeshPanel() + #print "-----------------------------" + #print "-----------------------------" + #print "-----------------------------" + #print "-----------------------------" + #print "-----------------------------" + #print "-----------------------------" + #print "-----------------------------" + #print "liste des panneaux =" + #print self.appli.mw.listePanels + +# def createMeshPanel(self): +# """ +# cree autant de panneaux maillages que de sous geometries +# """ +# self.listeMaillages = [] +# for i in self.appli.etude.sousGeometrie: +# mesh = maillage.Maillage(self.appli.mw.ws, self.appli) +# self.listeMaillages.append(mesh) +# self.appli.mw.listePanels.append(mesh) +# #self.appli.mw.listePanels.insert(0, self.appli.mw.listePanels[0] + 1) +# #del self.appli.mw.listePanels[1] + +# self.updateGeomMaillage(mesh, i) + + def getSousGeometrie(self): + """ + retourne les sous-géométries de la géométrie sélectionnée dans l'arbre d'étude de Salome + """ + liste = SMESH_utils.getSubGeometry(salome.myStudy, self.geometrie.appli.etude.geometrie) + liste.sort() + return liste + + def updateComboSousGeom(self): + """ + affecte les combobox des tables des panneaux ddl et pression avec les valeurs + des sous-géométries + """ + # insertion pour le panneau ddl + for cmb in self.geometrie.appli.mw.ddl.controleurNouvelleLigneTable.controleurTable.listeComboGeom: + cmb.insertStrList(self.geometrie.appli.etude.sousGeometrie) + + # insertion pour le panneau pression + for cmb in self.geometrie.appli.mw.pression.controleurNouvelleLigneTable.controleurTable.listeComboGeom: + cmb.insertStrList(self.geometrie.appli.etude.sousGeometrie) + + def updateGeomMaillage(self, maillage, sousGeom): + """ + affecte le label indiquant la géométrie sélectionnée du panneau maillage + affecte la listbox du panneau maillage avec les valeurs des maillages trouvés dans l'arbre d'étude + Salome correspondant à la géométrie sélectionnée + """ + # affectation de la géométrie sélectionnée au label du panneau maillage + maillage.lblGeom2.setText(str(self.appli.etude.geometrie[0])) + + # affectation de la sous géométrie au label du panneau maillage + maillage.lblSousGeom2.setText(str(sousGeom)) + + # récupération des mailles correspondants + import eelihCL + maillage.cl=eelihCL.CLinit() + # récupération de l'IOR des sous géométries + GEOMIor = [] + for iorSousGeom in self.dicoSousGeom.keys(): + GEOMIor.append(iorSousGeom) + maillage.cl.GetOrCreateCL(iorSousGeom) + #self.appli.mw.maillage.cl.traiteCL() + maillage.cl.get_geoms() + maillage.cl.get_maillages() +# + maillage.cl.MainShapes(0) +# + listeMaillage = maillage.cl.Possibles(0, str(self.appli.etude.geometrie[0])) + # insertion des maillages trouvés dans la listbox du panneau maillage + # si aucun maillage on disable la listbox + # sinon on disable le lineedit pour donner le nom d'un nouveau maillage + if listeMaillage != []: + maillage.lbMaillage.insertStrList(listeMaillage) + #maillage.lbMaillage.setEnabled(1) + #maillage.lblMaillage.setEnabled(1) + #maillage.lblNouveauMaillage.setEnabled(0) + #maillage.lnNouveauMaillage.setEnabled(0) + #else: + #maillage.lnNouveauMaillage.setEnabled(1) + #maillage.lblNouveauMaillage.setEnabled(1) + #maillage.lbMaillage.setEnabled(0) + #maillage.lblMaillage.setEnabled(0) + + + def convertit_group_maille_from_salome(self,liste_in): + """ + convertit les groupes de maille + """ + newr=[] + if [ 1 == 1 ]: + for entree in liste_in : + travail=[] + travail.append(entree) + if dict_geom_numgroupe.has_key(entree): + r=dict_geom_numgroupe[entree] + else: + r=SMESH_utils.getAsterGroupMa(salome.myStudy,travail) + dict_geom_numgroupe[entree]=r + for i in r : + newr.append(i) + else : + print "pas de groupe de maille associé" + showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de maille") + return newr + + def convertit_entrees_en_valeurs(self,liste_faces): + """ + convertit les entry de l'arbre d'étude en valeur + """ + valeur=self.convertit_group_maille_from_salome(liste_faces) + if valeur == []: + print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" + print "Pb pas de fonction de conversion de la valeur Salome en valeur Aster" + print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" + print "VALEUR", valeur + if len(valeur) == 1: + valeur = "'" + str(valeur[0]) + "'" + return valeur + + def add_selection(self): + """ + retourne le nom des objets sélectionnés dans l'arbre d'étude + """ + entrychaine=salome.sg.getAllSelected() + if len(entrychaine) >= 1: + print "1 seule géométrie doit être sélectionnée" + + + # liste des faces sélectionnées dans ddl et pression +# liste_faces = [] +# for face in self.appli.etude.ddls: +# if face[0] not in liste_faces: +# liste_faces.append(face[0]) + +# for face in self.appli.etude.chargements: +# if face[0] not in liste_faces: +# liste_faces.append(face[0]) +# if liste_faces != '': + liste_faces = [] + #liste_faces.append('0:1:2:1:1') + #liste_faces.append('0:1:2:1:2') + + # récupération de toutes les sous géométries + for sousGeom in self.appli.etude.sousGeometrie: + SO = salome.myStudy.FindObject(str(sousGeom)) + liste_faces.append(SO.GetID()) + + touteslesvaleurs = self.convertit_entrees_en_valeurs(liste_faces) + #liste_faces = [] + #liste_faces.append('0:1:2:1:2') + #touteslesvaleurs = self.convertit_entrees_en_valeurs(liste_faces) + return touteslesvaleurs + +dict_geom_numgroupe = { } +dict_geom_numface = { } diff --git a/src/EELIH/c_maillage.py b/src/EELIH/c_maillage.py new file mode 100644 index 00000000..b351a92e --- /dev/null +++ b/src/EELIH/c_maillage.py @@ -0,0 +1,76 @@ +# -*- coding: utf-8 -*- + +from panelbase import * + + +class C_maillage: + """ + controleur de la classe Maillage, traite les maillages correspondants à la géométrie + sélectionnée ou crée un maillage avec le nom saisi + - maillage = référence sur le panneau maillage + """ + def __init__(self, maillage): + self.maillage = maillage + + def traiteMaillage(self): + """ + si un maillage est sélectionné dans la listbox traite ce maillage + sinon crée un nouveau maillage avec comme nom le nom saisi + """ + # nouveau maillage + if self.maillage.lbMaillage.currentItem() == -1: + self.maillage.cl.traiteNewMaillage(0, str(self.maillage.lblGeom2.text()), str(self.maillage.lnNouveauMaillage.text())) + self.maillage.cl.traiteCL() + # met à jour les autres listbox des autres maillages -> ajoute le maillage cree + self.updateMeshList() + + # sélection d'un maillage existant + else: + self.maillage.cl.traiteMaillage(0, str(self.maillage.lbMaillage.currentText().latin1())) + self.maillage.cl.traiteCL() + + print "traitemaillage -------------------------" + + def enableBtnSuivant(self): + """ + rend actif le bouton suivant (terminer) si un maillage a été sélectionné ou + si un nom de nouveau maillage a été saisi + """ + # nouveau maillage + if self.maillage.lblNouveauMaillage.isEnabled(): + if self.maillage.lblNouveauMaillage.text().latin1() != str(''): + self.maillage.btnSuivant.setEnabled(1) + else: + self.maillage.btnSuivant.setEnabled(0) + # sélection d'un maillage existant + elif self.maillage.lbMaillage.currentItem() != -1: + self.maillage.btnSuivant.setEnabled(1) + else: + self.maillage.btnSuivant.setEnabled(0) + + def close(self): + """ + ferme l'application quand on clique sur le bouton suivant (terminer) + """ + self.maillage.appli.mw.close() + + def updateMeshList(self): + """ + met à jour la liste des maillages dans tous les panneaux maillages + quand un nouveau maillage est cree + """ + for maillage in self.maillage.appli.mw.publication.listeMaillages: + try: + maillage.cl.get_geoms() + maillage.cl.get_maillages() + + maillage.cl.MainShapes(0) + + listeMaillage = maillage.cl.Possibles(0, str(self.maillage.appli.etude.geometrie[0])) + + maillage.lbMaillage.insertStrList(listeMaillage) + except: + pass + + + diff --git a/src/EELIH/c_modelisation.py b/src/EELIH/c_modelisation.py new file mode 100644 index 00000000..2ebbf01a --- /dev/null +++ b/src/EELIH/c_modelisation.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- + +class C_modelisation: + """ + controleur de la classe Modelisation, si la modélisation est 2D on cache la colonne DZ + de la table du panneau ddl + - modelisation = référence sur le panneau modélisation + """ + def __init__(self, modelisation): + self.modelisation = modelisation + + def enableDZ(self): + """ + si la modélisation est 2D on cache la colonne DZ de la table du panneau ddl + """ + # modélisation 2D --> on cache + if self.modelisation.cmb.currentText().latin1() != '3D': + self.modelisation.appli.mw.ddl.tbl.hideColumn(3) + # modélisation 3D --> on montre + else: + self.modelisation.appli.mw.ddl.tbl.showColumn(3) diff --git a/src/EELIH/c_nouvelleLigneTableDdl.py b/src/EELIH/c_nouvelleLigneTableDdl.py new file mode 100644 index 00000000..bb3e2df8 --- /dev/null +++ b/src/EELIH/c_nouvelleLigneTableDdl.py @@ -0,0 +1,93 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +# modules de gestion des tables +from c_suppressionLigneTable import * +# modules controleur de la géométrie +from c_geometrie import * +# modules de base +import commands +import os +# modules validateur de lineedit +from validationlineedit import * + +class C_nouvelleLigneTableDdl(QWidget): + """ + controleur de la table du panneau ddl, permet la création d'une ligne de cette table + - appli = référence sur l'application + - c_table = référence sur le controleur table (permet le contrôle de la table) + - ddl = référence sur le panneau ddl + """ + def __init__(self, appli, c_table, ddl): + self.appli = appli + self.controleurTable = c_table + self.ddl = ddl + + def nouvelleLigne(self): + """ + insère une nouvelle ligne dans la table + """ + # insertion de la ligne + self.controleurTable.tbl.insertRows(len(self.controleurTable.listeBoutonsMoins)) + self.controleurTable.tbl.setRowHeight(len(self.controleurTable.listeBoutonsMoins), 30) + # création des boutons associés à cette nouvelle ligne + self.creeBoutons() + + def creeBoutons(self): + """ + crée les boutons associés à une ligne + """ + # ajout du combobox pour le choix des sous-géométries + cmb = QComboBox(self.controleurTable.tbl) + cmb.setMinimumWidth(100) + cmb.setMaximumWidth(200) + # méthode pour récupérer les sous géométries + self.controleurTable.listeComboGeom.append(cmb) + controleurSousGeom = C_geometrie(self.appli, self.ddl) + self.controleurTable.listeControleursGeoms.append(controleurSousGeom) + liste = self.appli.etude.sousGeometrie + cmb.insertStrList(liste) + # ajout du combobox géométrie dans la nouvelle ligne + self.controleurTable.tbl.setCellWidget(len(self.controleurTable.listeBoutonsMoins), 0, cmb) + self.controleurTable.tbl.adjustColumn(0) + + # ajout du lineedit dx dans la nouvelle ligne + lnx = QLineEdit('', self.controleurTable.tbl) + lnx.setPaletteBackgroundColor(QColor(255, 170, 255)) + self.controleurTable.listeEditDx.append(lnx) + validateur = ValidationLineEdit(None, None, None, lnx) + self.controleurTable.listeControleursDx.append(validateur) + self.connect(lnx, SIGNAL('textChanged(const QString&)'), self.controleurTable.listeControleursDx[self.controleurTable.listeEditDx.index(lnx)].isValid) + self.controleurTable.tbl.setCellWidget(len(self.controleurTable.listeBoutonsMoins), 1, lnx) + + # ajout du lineedit dy dans la nouvelle ligne + lny = QLineEdit('', self.controleurTable.tbl) + lny.setPaletteBackgroundColor(QColor(255, 170, 255)) + self.controleurTable.listeEditDy.append(lny) + validateur = ValidationLineEdit(None, None, None, lny) + self.controleurTable.listeControleursDy.append(validateur) + self.connect(lny, SIGNAL('textChanged(const QString&)'), self.controleurTable.listeControleursDy[self.controleurTable.listeEditDy.index(lny)].isValid) + self.controleurTable.tbl.setCellWidget(len(self.controleurTable.listeBoutonsMoins), 2, lny) + + # ajout du lineedit dz dans la nouvelle ligne + lnz = QLineEdit('', self.controleurTable.tbl) + lnz.setPaletteBackgroundColor(QColor(255, 170, 255)) + self.controleurTable.listeEditDz.append(lnz) + validateur = ValidationLineEdit(None, None, None, lnz) + self.controleurTable.listeControleursDz.append(validateur) + self.connect(lnz, SIGNAL('textChanged(const QString&)'), self.controleurTable.listeControleursDz[self.controleurTable.listeEditDz.index(lnz)].isValid) + self.controleurTable.tbl.setCellWidget(len(self.controleurTable.listeBoutonsMoins), 3, lnz) + + # ajout du bouton moins dans la liste + px = QPixmap(os.path.join(os.getenv("EFICAS_ROOT_DIR"), 'share/salome/resources/moins.png')) + icon = QIconSet(px) + pbMoins = QPushButton(icon, '', self.controleurTable.tbl) + pbMoins.setFixedWidth(30) + pbMoins.setFixedHeight(30) + self.controleurTable.listeBoutonsMoins.append(pbMoins) + controleurLigne = C_suppressionLigneTable(self.controleurTable, pbMoins, cmb, controleurSousGeom) + self.controleurTable.listeControleursMoins.append(controleurLigne) + self.connect(pbMoins, SIGNAL('clicked()'), self.controleurTable.listeControleursMoins[self.controleurTable.listeBoutonsMoins.index(pbMoins)].supprimeLigne) + # ajout du bouton moins dans la nouvelle ligne + self.controleurTable.tbl.setCellWidget(len(self.controleurTable.listeBoutonsMoins) - 1, 4, pbMoins) diff --git a/src/EELIH/c_nouvelleLigneTablePression.py b/src/EELIH/c_nouvelleLigneTablePression.py new file mode 100644 index 00000000..5fb56178 --- /dev/null +++ b/src/EELIH/c_nouvelleLigneTablePression.py @@ -0,0 +1,75 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +# modules de gestions des tables +from c_suppressionLigneTable import * +# modules controleur géométrie +from c_geometrie import * +# modules de base +import commands +import os +# modules validateur de lineedit +from validationlineedit import * + +class C_nouvelleLigneTablePression(QWidget): + """ + controleur de la table du panneau pression, permet la création d'une ligne de cette table + - appli = référence sur l'application + - controleurTable = référence sur le controleur de la table + - pression = référence sur le panneau pression + """ + def __init__(self, appli, c_table, pression): + self.appli = appli + self.controleurTable = c_table + self.pression = pression + + def nouvelleLigne(self): + """ + insère une nouvelle ligne dans la table + """ + # création de la ligne + self.controleurTable.tbl.insertRows(len(self.controleurTable.listeBoutonsMoins)) + self.controleurTable.tbl.setRowHeight(len(self.controleurTable.listeBoutonsMoins), 30) + # création des boutons associés à cette nouvelle ligne + self.creeBoutons() + + def creeBoutons(self): + """ + crée les boutons associés à une ligne + """ + # ajout du combobox pour le choix des sous-géométries + cmb = QComboBox(self.controleurTable.tbl) + cmb.setMinimumWidth(50) + cmb.setMaximumWidth(200) + # méthode pour récupérer les sous géométries + self.controleurTable.listeComboGeom.append(cmb) + controleurSousGeom = C_geometrie(self.appli, self.pression) + self.controleurTable.listeControleursGeoms.append(controleurSousGeom) + liste = self.appli.etude.sousGeometrie + cmb.insertStrList(liste) + # ajout du combobox géométrie dans la nouvelle ligne + self.controleurTable.tbl.setCellWidget(len(self.controleurTable.listeBoutonsMoins), 0, cmb) + self.controleurTable.tbl.adjustColumn(0) + + # ajout du lineedit Pression dans la nouvelle ligne + lnf = QLineEdit('', self.controleurTable.tbl) + lnf.setPaletteBackgroundColor(QColor(255, 170, 255)) + self.controleurTable.listeEditPression.append(lnf) + validateur = ValidationLineEdit(None, None, None, lnf) + self.controleurTable.listeControleursPression.append(validateur) + self.connect(lnf, SIGNAL('textChanged(const QString&)'), self.controleurTable.listeControleursPression[self.controleurTable.listeEditPression.index(lnf)].isValid) + self.controleurTable.tbl.setCellWidget(len(self.controleurTable.listeBoutonsMoins), 1, lnf) + + # ajout du bouton moins dans la liste + px = QPixmap(os.path.join(os.getenv("EFICAS_ROOT_DIR"), 'share/salome/resources/moins.png')) + icon = QIconSet(px) + pbMoins = QPushButton(icon, '', self.controleurTable.tbl) + pbMoins.setFixedWidth(30) + pbMoins.setFixedHeight(30) + self.controleurTable.listeBoutonsMoins.append(pbMoins) + controleurLigne = C_suppressionLigneTable(self.controleurTable, pbMoins, cmb, controleurSousGeom) + self.controleurTable.listeControleursMoins.append(controleurLigne) + self.connect(pbMoins, SIGNAL('clicked()'), self.controleurTable.listeControleursMoins[self.controleurTable.listeBoutonsMoins.index(pbMoins)].supprimeLigne) + # ajout du bouton moins dans la nouvelle ligne + self.controleurTable.tbl.setCellWidget(len(self.controleurTable.listeBoutonsMoins) - 1, 2, pbMoins) diff --git a/src/EELIH/c_selectionGeometrie.py b/src/EELIH/c_selectionGeometrie.py new file mode 100644 index 00000000..ba6697e5 --- /dev/null +++ b/src/EELIH/c_selectionGeometrie.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- + +import salome +import SMESH_utils + +class C_selectionGeometrie: + def __init__(self, c_table, widget): + self.controleurTable = c_table + self.widget = widget + + def convertit_group_maille_from_salome(self,liste_in): + newr=[] + if [ 1 == 1 ]: + print liste_in + for entree in liste_in : + travail=[] + travail.append(entree) + entryname_list=SMESH_utils.entryToName(salome.myStudy,travail) + entreeName=entryname_list[0] + if dict_geom_numgroupe.has_key(entreeName): + r=dict_geom_numgroupe[entreeName] + else: + r=SMESH_utils.getAsterGroupMa(salome.myStudy,travail) + dict_geom_numgroupe[entreeName]=r + for i in r : + newr.append(i) + else : + print "pas de groupe de maille associé" + showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de maille") + return newr + + def convertit_entrees_en_valeurs(self,entrychaine): + valeur=self.convertit_group_maille_from_salome(entrychaine) + if valeur == []: + print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" + print "Pb pas de fonction de conversion de la valeur Salome en valeur Aster" + print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" + print "VALEUR", valeur + if len(valeur) == 1: + valeur = "'" + str(valeur[0]) + "'" + return valeur + + def add_selection(self): + entrychaine=salome.sg.getAllSelected() + if entrychaine != '': + # apparemment inutile + #entryname_list=SMESH_utils.entryToName(salome.myStudy,entrychaine) + touteslesvaleurs = self.convertit_entrees_en_valeurs(entrychaine) + if touteslesvaleurs != []: + # on recherche dans quelle ligne on insère la valeur sélectionnée dans Salome + indice = self.controleurTable.listeBoutonsSelections.index(self.widget) + # on modifie le texte du lineedit de cette ligne et de la colonne objet + self.controleurTable.tbl.setText(indice, 1, str(touteslesvaleurs)) + self.controleurTable.tbl.adjustColumn(1) + +dict_geom_numgroupe = { } +dict_geom_numface = { } diff --git a/src/EELIH/c_suppressionLigneTable.py b/src/EELIH/c_suppressionLigneTable.py new file mode 100644 index 00000000..eb3c7ffe --- /dev/null +++ b/src/EELIH/c_suppressionLigneTable.py @@ -0,0 +1,33 @@ +# -*- coding: iso-8859-1 -*- + +class C_suppressionLigneTable: + """ + controleur des tables des panneaux ddl et pression, permet la suppression d'une ligne + - c_table : controleur d'une table + - widgetMoins = référence sur le bouton moins + - widgetSousGeom = référence sur le combobox + - controleurSousGeom = référence sur le controleur géométrie + """ + def __init__(self, c_table, widgetMoins, widgetSousGeom, controleurSousGeom): + self.controleurTable = c_table + self.widgetMoins = widgetMoins + self.widgetSousGeom = widgetSousGeom + self.controleurSousGeom = controleurSousGeom + + def supprimeLigne(self): + """ + supprime les références sur les boutons et les controleurs associés des listes + qui contiennent tous les boutons et controleurs associés à une table, + supprime également la ligne de la table + """ + indice = self.controleurTable.listeBoutonsMoins.index(self.widgetMoins) + + # suppression des listes + self.controleurTable.listeBoutonsMoins.remove(self.widgetMoins) + if self.widgetSousGeom != None: + self.controleurTable.listeComboGeom.remove(self.widgetSousGeom) + self.controleurTable.listeControleursMoins.remove(self) + if self.controleurSousGeom != None: + self.controleurTable.listeControleursGeoms.remove(self.controleurSousGeom) + # suppression de la ligne de la table + self.controleurTable.tbl.removeRow(indice) diff --git a/src/EELIH/c_table.py b/src/EELIH/c_table.py new file mode 100644 index 00000000..df9b52c5 --- /dev/null +++ b/src/EELIH/c_table.py @@ -0,0 +1,35 @@ +# -*- coding: iso-8859-1 -*- + +class C_table: + """ + controleur des tables, permet de gérer l'ajout et la suppression d'une ligne dans une table + - listeBoutonsMoins = liste des boutons moins créés pour la table + - listeComboGeom = liste des combobox créés pour la table + - listeEditDx = liste des lineedit DX créés pour la table + - listeEditDy = liste des lineedit DY créés pour la table + - listeEditDz = liste des lineedit DZ créés pour la table + - listeEditPression = liste des lineedit Pression créés pour la table + - listeControleursMoins = liste des controleurs C_suppressionLigneTable + - listeControleursDx = liste des controleurs Validationlineedit pour Dx + - listeControleursDy = liste des controleurs Validationlineedit pour Dy + - listeControleursDz = liste des controleurs Validationlineedit pour Dz + - listeControleursPression = liste des controleurs Validationlineedit pour Pression + - listeControleursGeoms = liste des controleurs pour récupérer les sous-géométries dans les combobox + - tbl = référence sur la table + """ + def __init__(self, table): + self.listeBoutonsMoins = [] + self.listeComboGeom = [] + self.listeEditDx = [] + self.listeEditDy = [] + self.listeEditDz = [] + self.listeEditPression = [] + self.listeControleursMoins = [] + self.listeControleursDx = [] + self.listeControleursDy = [] + self.listeControleursDz = [] + self.listeControleursPression = [] + self.listeControleursGeoms = [] + self.tbl = table + + diff --git a/src/EELIH/cartouche.comm b/src/EELIH/cartouche.comm new file mode 100644 index 00000000..5b234a0b --- /dev/null +++ b/src/EELIH/cartouche.comm @@ -0,0 +1,43 @@ + + +DEBUT(); + +# MATERIAU + +MAIL=LIRE_MAILLAGE(UNITE=21, + FORMAT='MED', + INFO_MED=2,); + +# MODELISATION + +MATE=AFFE_MATERIAU(MAILLAGE=MAIL, + AFFE=_F(TOUT='OUI', + MATER=MA,),); + +# CHARGEMENT + +RESU=MECA_STATIQUE(MODELE=MODE, + CHAM_MATER=MATE, + EXCIT=_F(CHARGE=CHAR,),); + +RESU=CALC_ELEM(reuse =RESU, + MODELE=MODE, + CHAM_MATER=MATE, + RESULTAT=RESU, + OPTION=('SIEF_ELGA_DEPL','SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',), + EXCIT=_F( + CHARGE=CHAR,),); + +RESU=CALC_NO(reuse =RESU, + RESULTAT=RESU, + OPTION=('EQUI_NOEU_SIGM','SIGM_NOEU_DEPL',),); + +IMPR_RESU(FORMAT='MED', + UNITE=80, + RESU=_F(MAILLAGE=MAIL, + RESULTAT=RESU, + NOM_CHAM=('SIGM_NOEU_DEPL','EQUI_NOEU_SIGM','DEPL',),),); + +FIN(); + +# FIN diff --git a/src/EELIH/ddl.py b/src/EELIH/ddl.py new file mode 100644 index 00000000..25c0ef97 --- /dev/null +++ b/src/EELIH/ddl.py @@ -0,0 +1,90 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +from qttable import QTable +# modules de gestion des panneaux +from panelbase import * +# modules validateur lineedit +from validationlineedit import * +# modules controles des tables +from c_suppressionLigneTable import * +from c_nouvelleLigneTableDdl import * +from c_table import * +# modules de base +import commands + +class Ddl(PanelBase): + """ + Hérite de la classe mère PanelBase + Définit le panneau pour le choix des degrés de liberté d'un groupe de faces : + - tbl = table d'affichage des degrés de liberté + - controleurTable = controleur de gestion de la table + - controleurNouvelleLigneTable = controleur pour l'ajout d'une nouvelle ligne dans la table + - boutonPlus = permet de créer une nouvelle ligne quand on clique dessus + """ + def __init__(self, parent, appli): + # hérite de la classe mère des panneaux + PanelBase.__init__(self, parent, appli) + + # on modifie le label titre + self.lblTitre.setText('Degrés de liberté imposés') + + # on modifie l'explication + self.lblExplication.setText("Définissez le(s) groupe(s) de mailles et les ddls à appliquer :") + + # bouton suivant toujours actif + self.btnSuivant.setEnabled(1) + + # espacement + self.sp2 = QSpacerItem(20, 50, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp2, 3, 0) + + # création d'une QGridLayout + self.glProprietes = QGridLayout(self.parent, 1, 2, 5) + self.gl.addLayout(self.glProprietes, 4, 0) + + # ---------------- création et ajout du QTable ---------------- + self.tbl = QTable(1, 5, self.parent) + self.tbl.setMinimumHeight(150) + self.tbl.setMaximumHeight(200) + self.tbl.setColumnWidth(4, 30) + self.tbl.setRowHeight(0, 30) + + self.th = self.tbl.horizontalHeader() + self.th.setLabel(0, 'Objet') + self.th.setLabel(1, 'DX') + self.th.setLabel(2, 'DY') + self.th.setLabel(3, 'DZ') + self.th.setLabel(4, '') + + self.tbl.verticalHeader().hide() + self.tbl.setLeftMargin(0) + + self.glProprietes.addWidget(self.tbl, 0, 0) + + # création du controleur de la table + self.controleurTable = C_table(self.tbl) + + # création du controleur pour l'ajout d'une nouvelle ligne + self.controleurNouvelleLigneTable = C_nouvelleLigneTableDdl(self.appli, self.controleurTable, self) + # ajout de la première ligne + self.controleurNouvelleLigneTable.creeBoutons() + + # bouton plus = nouvelle ligne + px = QPixmap(os.path.join(os.getenv("EFICAS_ROOT_DIR"), 'share/salome/resources/plus.png')) + icon = QIconSet(px) + self.boutonPlus = QPushButton(icon, '', self.parent) + self.glProprietes.addWidget(self.boutonPlus, 0, 1, Qt.AlignCenter) + + self.connect(self.boutonPlus, SIGNAL('clicked()'), self.controleurNouvelleLigneTable.nouvelleLigne) + + def suivant(self): + """ + met à jour l'étude avec les valeurs des ddls saisies + passe au panneau suivant + affiche les valeurs mises à jour (simple fonction d'aide) + """ + self.appli.etude.setDdls(self.tbl) + PanelBase.suivant(self) + self.appli.etude.affiche() diff --git a/src/EELIH/eelih.py b/src/EELIH/eelih.py new file mode 100644 index 00000000..8f51b493 --- /dev/null +++ b/src/EELIH/eelih.py @@ -0,0 +1,103 @@ +# -*- coding: utf-8 -*- + +class Eelih: + """ + représente les données de l'étude : + - modelisation = type de modélisation choisie + - materiau_e = module d'Young choisi + - materiau_nu = coefficient de Poisson choisi + - chargements = liste réprésentant les pressions choisies pour les sous-géométries + - ddls = liste représentant les valeurs pour les ddls pour les sous-géométries + - geometrie = nom de la géométrie sélectionnée dans l'arbre d'étude Salome + - sousGeometrie = liste des sous-géométries de la géométrie choisie + """ + def __init__(self): + self.modelisation = None + self.materiau_e = None + self.materiau_nu = None + self.chargements = None + self.ddls = None + self.geometrie = None + self.sousGeometrie = None + + def setModelisation(self, val): + """ + fixe la valeur de la modélisation choisie + """ + self.modelisation = val.latin1() + + def setMateriau_e(self, val): + """ + fixe la valeur du module d'Young choisi + """ + self.materiau_e = val + + def setMateriau_nu(self, val): + """ + fixe la valeur du coefficient de Poisson choisi + """ + self.materiau_nu = val + + def setChargements(self, table): + """ + crée la liste des pressions choisies + un item de la liste est composé du nom de la sous-géométrie choisie et de la pression à appliquer + """ + self.chargements = [] + for ligne in range(table.numRows()): + # création d'un item + liste = [] + cmb = table.cellWidget(ligne, 0) + liste.append(cmb.currentText().latin1()) + liste.append(table.cellWidget(ligne, 1).text().latin1()) + # ajout de l'item dans la liste + self.chargements.append(liste) + + def setDdls(self, table): + """ + crée la liste des ddls choisies + un item de la liste est composé du nom de la sous-géométrie choisie, de l'axe de liberté et de sa valeur + """ + self.ddls = [] + for ligne in range(table.numRows()): + for i in range(1, 4): + # création d'un item + liste = [] + cmb = table.cellWidget(ligne, 0) + liste.append(cmb.currentText().latin1()) + th = table.horizontalHeader() + liste.append(th.label(i).latin1()) + liste.append(table.cellWidget(ligne, i).text().latin1()) + # ajout de l'item dans la liste + self.ddls.append(liste) + + def setGeometrie(self, val): + """ + fixe le nom de la géométrie sélectionnée dans l'arbre d'étude + """ + self.geometrie = val + + def setSousGeometrie(self, liste): + """ + crée la liste des sous-géométries de la géométrie sélectionnée + """ + self.sousGeometrie = [] + for val in liste: + if val != '': + self.sousGeometrie.append(val) + + def affiche(self): + """ + affiche les différentes valeurs de l'étude + (simple fonction d'aide) + """ + print "***********************" + print "***** ETUDE ***********" + print "***********************" + print "modélisation = " + str(self.modelisation) + print "module d'Young = " + str(self.materiau_e) + print "coeff. de Poisson = " + str(self.materiau_nu) + print "géométrie = " + str(self.geometrie) + print "sous géométries = " + str(self.sousGeometrie) + print "chargements = " + str(self.chargements) + print "degrés de libertés = " + str(self.ddls) diff --git a/src/EELIH/eelihCL.py b/src/EELIH/eelihCL.py new file mode 100644 index 00000000..8d6aed29 --- /dev/null +++ b/src/EELIH/eelihCL.py @@ -0,0 +1,11 @@ +import salome +import eficasCL + +Tag_RefOnShape = 1 +dict_CL={} + +class CLinit(eficasCL.CLinit): + def traiteCL(self): + self.get_geoms() + self.get_maillages() + salome.sg.updateObjBrowser(0) diff --git a/src/EELIH/eficas_novice.py b/src/EELIH/eficas_novice.py new file mode 100644 index 00000000..48c50af5 --- /dev/null +++ b/src/EELIH/eficas_novice.py @@ -0,0 +1,15 @@ +# -*- coding: iso-8859-1 -*- + +# modules de base +import sys +# modules PyQt +from qt import * +# modules IHM +from mainwindow import * +from appli import * + +if __name__ == '__main__': + a = QApplication(sys.argv) + appli = Appli() + a.connect(a, SIGNAL('lastWindowClosed()'), a, SLOT('quit()')) + a.exec_loop() diff --git a/src/EELIH/exemple.comm b/src/EELIH/exemple.comm new file mode 100644 index 00000000..266babb9 --- /dev/null +++ b/src/EELIH/exemple.comm @@ -0,0 +1,51 @@ + + +DEBUT(); + +MA=DEFI_MATERIAU(ELAS=_F(E=, + NU=,),); + +MAIL=LIRE_MAILLAGE(UNITE=21, + FORMAT='MED', + INFO_MED=2,); + +MODE=AFFE_MODELE(MAILLAGE=MAIL, + AFFE=_F(TOUT='OUI', + PHENOMENE='MECANIQUE', + MODELISATION=,),); + +MATE=AFFE_MATERIAU(MAILLAGE=MAIL, + AFFE=_F(TOUT='OUI', + MATER=MA,),); + +CHAR=AFFE_CHAR_MECA(MODELE=MODE, + FACE_IMPO=_F(GROUP_MA=, + DX=, + DY=, + DZ=,), + PRES_REP=_F(GROUP_MA='Bas', + PRES=100.0,),); + +RESU=MECA_STATIQUE(MODELE=MODE, + CHAM_MATER=MATE, + EXCIT=_F(CHARGE=CHAR,),); + +RESU=CALC_ELEM(reuse =RESU, + MODELE=MODE, + CHAM_MATER=MATE, + RESULTAT=RESU, + OPTION=('SIEF_ELGA_DEPL','SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',), + EXCIT=_F( + CHARGE=CHAR,),); + +RESU=CALC_NO(reuse =RESU, + RESULTAT=RESU, + OPTION=('EQUI_NOEU_SIGM','SIGM_NOEU_DEPL',),); + +IMPR_RESU(FORMAT='MED', + UNITE=80, + RESU=_F(MAILLAGE=MAIL, + RESULTAT=RESU, + NOM_CHAM=('SIGM_NOEU_DEPL','EQUI_NOEU_SIGM','DEPL',),),); + +FIN(); diff --git a/src/EELIH/fichier.py b/src/EELIH/fichier.py new file mode 100644 index 00000000..2f71d502 --- /dev/null +++ b/src/EELIH/fichier.py @@ -0,0 +1,136 @@ +# -*- coding: iso-8859-1 -*- + +# modules de base +import commands +import sys +from tkFileDialog import * + +cartouche = "DEBUT();\n\n" +cartouche = cartouche + "%(MATERIAU)s\n\n" +cartouche = cartouche + "MAIL=LIRE_MAILLAGE(UNITE=21,\n" +cartouche = cartouche + " FORMAT='MED',\n" +cartouche = cartouche + " INFO_MED=2,);\n\n" +cartouche = cartouche + "%(MODELISATION)s\n\n" +cartouche = cartouche + "MATE=AFFE_MATERIAU(MAILLAGE=MAIL,\n" +cartouche = cartouche + " AFFE=_F(TOUT='OUI',\n" +cartouche = cartouche + " MATER=MA,),);\n\n" +cartouche = cartouche + "%(CHARGEMENT)s\n\n" +cartouche = cartouche + "RESU=MECA_STATIQUE(MODELE=MODE,\n" +cartouche = cartouche + " CHAM_MATER=MATE,\n" +cartouche = cartouche + " EXCIT=_F(CHARGE=CHAR,),);\n\n" +cartouche = cartouche + "RESU=CALC_ELEM(reuse =RESU,\n" +cartouche = cartouche + " MODELE=MODE,\n" +cartouche = cartouche + " CHAM_MATER=MATE,\n" +cartouche = cartouche + " RESULTAT=RESU,\n" +cartouche = cartouche + " OPTION=('SIEF_ELGA_DEPL','SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',),\n" +cartouche = cartouche + " EXCIT=_F(\n" +cartouche = cartouche + " CHARGE=CHAR,),);\n\n" +cartouche = cartouche + "RESU=CALC_NO(reuse =RESU,\n" +cartouche = cartouche + " RESULTAT=RESU,\n" +cartouche = cartouche + " OPTION=('EQUI_NOEU_SIGM','SIGM_NOEU_DEPL',),);\n\n" +cartouche = cartouche + "IMPR_RESU(FORMAT='MED',\n" +cartouche = cartouche + " UNITE=80,\n" +cartouche = cartouche + " RESU=_F(MAILLAGE=MAIL,\n" +cartouche = cartouche + " RESULTAT=RESU,\n" +cartouche = cartouche + " NOM_CHAM=('SIGM_NOEU_DEPL','EQUI_NOEU_SIGM','DEPL',),),);\n\n" +cartouche = cartouche + "FIN();" + +dict_fichier = {} + +class Fichier: + """ + réalise la création du fichier de commandes avec les valeurs saisies à partir de la chaine cartouche + - utilisation du % export dico + """ + def __init__(self, appli, salomeRef): + self.appli = appli + + # initialisation pour la publication dans l'arbre d'étude + self.salome = salomeRef + + def creer(self): + """ + crée le fichier de commandes + """ + # définition de MATERIAU + s = 'MA=DEFI_MATERIAU(ELAS=_F(E=' + tmp = str(self.appli.etude.materiau_e.latin1()) + s = s + tmp + s = s + ', \n' + s = s + '\t\t\t NU=' + tmp = str(self.appli.etude.materiau_nu.latin1()) + s = s + tmp + s = s + ',),);\n\n' + + dict_fichier['MATERIAU'] = s + + # définition de MODELISATION + s = 'MODE=AFFE_MODELE(MAILLAGE=MAIL,\n' + s = s + "\t\tAFFE=_F(TOUT='OUI',\n" + s = s + "\t\t\t\tPHENOMENE='MECANIQUE',\n" + s = s + "\t\t\t\tMODELISATION=" + s = s + "'" + self.appli.etude.modelisation + "'" + s = s + ',),);\n\n' + + dict_fichier['MODELISATION'] = s + + # définition des ddls et pressions + s = 'CHAR=AFFE_CHAR_MECA(MODELE=MODE,\n' + s = s + '\t\t\tFACE_IMPO=(' + for i in range(0, len(self.appli.etude.ddls), 3): + liste = self.appli.etude.ddls[i:i+3] + if liste[0][2] == '' and liste[1][2] == '' and liste[2][2] == '': + pass + else: + s = s + "\n\t\t\t\t_F(GROUP_MA='" + str(liste[0][0]) + "'," + for i in range(3): + if liste[i][2] != '': + s = s + "\n\t\t\t\t\t\t" + str(liste[i][1]) + "=" + str(liste[i][2]) + "," + s = s + '),' + s = s + '),\n' + + s = s + '\t\t\tPRES_REP=(' + for pres in self.appli.etude.chargements: + if pres[1] != '': + s = s + "\n\t\t\t\t_F(GROUP_MA='" + pres[0] + "'," + s = s + "\n\t\t\t\t\t\tPRES=" + pres[1] + ",)," + s = s + "),);" + + dict_fichier['CHARGEMENT'] = s + + ch = cartouche % dict_fichier + + # si flag = E enregistrement manuel du fichier + # si flag = A enregistrement automatique + if self.appli.flagEficasOrAster == 'A': + # ouverture du nouveau fichier en écriture + f_temp = open('/tmp/temporaire.comm', 'w') + + # écriture du fichier + f_temp.write(ch) + + # fermeture du fichier créé + f_temp.close() + + # publication du fichier dans l'arbre d'étude Salome + import eficasEtude + self.salome.rangeInStudy('/tmp/temporaire.comm') + elif self.appli.flagEficasOrAster == 'E': + # on demande Ã| l'utilisateur dans quel fichier il veut sauvegarder + filesave = asksaveasfilename(defaultextension = '.comm', + initialdir = commands.getoutput("echo $HOME"), + title="Sauvegarde du fichier de commandes") + # ouverture du nouveau fichier en écriture + f_temp = open(filesave, 'w') + # écriture du fichier + f_temp.write(ch) + # fermeture du fichier créé + f_temp.close() + + # publication du fichier dans l'arbre d'étude Salome + import eficasEtude + self.salome.rangeInStudy(filesave) + else: + print "Erreur flag enreigstrement fichier .comm (A pour Aster, E pour Eficas)" + sys.exit() + diff --git a/src/EELIH/geometrie.py b/src/EELIH/geometrie.py new file mode 100644 index 00000000..49553aa1 --- /dev/null +++ b/src/EELIH/geometrie.py @@ -0,0 +1,80 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +# module de gestion des panneaux +from panelbase import * +# modules controleur de la géométrie +from c_geometrie import * +# modules de base +import commands +import os + +class Geometrie(PanelBase): + """ + Hérite de la classe mère PanelBase + Définit le panneau pour le choix de la géométrie sur laquelle on veut travailler + - pbSelection = bouton pour la sélection dans l'arbre d'étude Salome + - ln = lineedit pour l'affichage de la sélection + """ + def __init__(self, parent, appli): + # hérite de la classe mère des panneaux + PanelBase.__init__(self, parent, appli) + + # on modifie le label titre + self.lblTitre.setText('Sélection de la géométrie') + + # on modifie l'explication + self.lblExplication.setText("Sélectionnez la géométrie sur laquelle vous souhaitez travailler :") + + # espacement + self.sp2 = QSpacerItem(20, 50, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp2, 3, 0) + + # création d'une QGridLayout + self.glProprietes = QGridLayout(self.parent, 1, 4, 5) + self.gl.addLayout(self.glProprietes, 4, 0) + + # création d'un horizontalboxlayout + self.hbl = QHBoxLayout(self.glProprietes) + + # création du bouton sélection + px = QPixmap(os.path.join(os.getenv("EFICAS_ROOT_DIR"), 'share/salome/resources/select1.png')) + icon = QIconSet(px) + self.pbSelection = QPushButton(icon, '', self.parent) + self.pbSelection.setFixedWidth(30) + self.pbSelection.setFixedHeight(30) + self.hbl.addWidget(self.pbSelection) + + # création du lineedit d'affichage de la géométrie sélectionnée + self.ln = QLineEdit('', self.parent) + self.ln.setReadOnly(1) + self.ln.setMaximumWidth(300) + self.hbl.addWidget(self.ln) + self.connect(self.ln, SIGNAL('textChanged(const QString&)'), self.valid) + + # création du controleur géométrie + self.controleurGeom = C_geometrie(self.appli, self) + self.connect(self.pbSelection, SIGNAL('clicked()'), self.controleurGeom.getGeometrie) + + def valid(self): + """ + rend actif le bouton suivant si une géométrie est sélectionnée et si des sous-géométries existent + """ + if self.ln.text() != '': + self.btnSuivant.setEnabled(1) + else: + self.btnSuivant.setEnabled(0) + + def suivant(self): + """ + met à jour les combobox des sous-géométries des tables des panneaux ddl et pression + met à jour les maillages associés à cette géométrie dans le panneau maillage + affiche le panneau suivant + affiche les valeurs saisies (simple fonction d'aide) + """ + self.controleurGeom.updateComboSousGeom() + #self.controleurGeom.updateGeomMaillage() + #self.controleurGeom.add_selection() + PanelBase.suivant(self) + self.appli.etude.affiche() diff --git a/src/EELIH/maillage.py b/src/EELIH/maillage.py new file mode 100644 index 00000000..709b58c1 --- /dev/null +++ b/src/EELIH/maillage.py @@ -0,0 +1,105 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +# module de gestion des panneaux +from panelbase import * +# modules controleur géométrie +from c_geometrie import * +# modules controleur maillage +from c_maillage import * +# modules eficas conditions aux limites +import eelihCL + +class Maillage(PanelBase): + """ + Hérite de la classe mère PanelBase + Définit le panneau pour le choix du maillage : + - lblGeom2 = label qui donne le nom de la géométrie sélectionnée + - lbMaillage = listbox qui donne le(s) maillage(s) équivalent(s) à la géométrie s'il(s) existe(nt) + - lnNouveauMaillage = lineedit pour saisir le nom du nouveau maillage si le maillage n'existe pas + - cl = conditions aux limites + - controleurMaillage = controleur du panneau maillage + """ + def __init__(self, parent, appli): + # hérite de la classe mère des panneaux + PanelBase.__init__(self, parent, appli) + + # on modifie le label titre + self.lblTitre.setText('Définition du maillage') + + # on modifie l'explication + self.lblExplication.setText("Définissez un maillage sur lequel s'appliquent les conditions aux limites \nsi celui-ci n'existe pas encore :") + + # espacement + self.sp2 = QSpacerItem(20, 50, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp2, 3, 0) + + # création d'une QGridLayout + self.glProprietes = QGridLayout(self.parent, 4, 3, 5) + self.gl.addLayout(self.glProprietes, 4, 0) + + # ajout du label géométrie choisie + self.lblGeom1 = QLabel('Géométrie choisie :', self.parent) + self.glProprietes.addWidget(self.lblGeom1, 0, 0, Qt.AlignRight) + + self.lblGeom2 = QLabel('', self.parent) + self.lblGeom2.setPaletteBackgroundColor(QColor(255, 255, 255)) + self.lblGeom2.setMinimumWidth(200) + self.lblGeom2.setMaximumWidth(200) + self.lblGeom2.setFrameShape(QFrame.LineEditPanel) + self.glProprietes.addWidget(self.lblGeom2, 0, 1, Qt.AlignLeft) + + # ajout du label sous géométrie + self.lblSousGeom1 = QLabel('Sous-géométrie :', self.parent) + self.glProprietes.addWidget(self.lblSousGeom1, 1, 0, Qt.AlignRight) + + self.lblSousGeom2 = QLabel('', self.parent) + self.lblSousGeom2.setPaletteBackgroundColor(QColor(255, 255, 255)) + self.lblSousGeom2.setMinimumWidth(200) + self.lblSousGeom2.setMaximumWidth(200) + self.lblSousGeom2.setFrameShape(QFrame.LineEditPanel) + self.glProprietes.addWidget(self.lblSousGeom2, 1, 1, Qt.AlignLeft) + + # ajout de la listbox des maillages correspondant à la géométrie + self.lblMaillage =QLabel('Sélectionnez le(s) maillage(s) correspondant(s) :', self.parent) + self.glProprietes.addWidget(self.lblMaillage, 2, 0, Qt.AlignRight) + + self.lbMaillage = QListBox(self.parent) + self.lbMaillage.setMinimumWidth(200) + self.lbMaillage.setMaximumWidth(200) + self.glProprietes.addWidget(self.lbMaillage, 2, 1, Qt.AlignLeft) + + # ajout du lineedit pour le nom du nouveau maillage si nécessaire + self.lblNouveauMaillage = QLabel('Nom du nouveau maillage :', self.parent) + self.glProprietes.addWidget(self.lblNouveauMaillage, 3, 0, Qt.AlignRight) + + self.lnNouveauMaillage = QLineEdit(self.parent) + self.lnNouveauMaillage.setMinimumWidth(200) + self.lnNouveauMaillage.setMaximumWidth(200) + self.glProprietes.addWidget(self.lnNouveauMaillage, 3, 1, Qt.AlignLeft) + + self.pb = QPushButton('essai', self.parent) + self.glProprietes.addWidget(self.pb, 3, 2, Qt.AlignCenter) + + # c'est le dernier panneau de l'application --> le bouton suivant devient terminer + self.btnSuivant.setText('Terminer') + + # conditions aux limites + self.cl = None + + # création d'un controleur maillage + self.controleurMaillage = C_maillage(self) + + #self.connect(self.btnSuivant, SIGNAL('pressed()'), self.controleurMaillage.traiteMaillage) + self.connect(self.pb, SIGNAL('clicked()'), self.controleurMaillage.traiteMaillage) + self.connect(self.lbMaillage, SIGNAL('highlighted(int)'), self.controleurMaillage.enableBtnSuivant) + self.connect(self.lnNouveauMaillage, SIGNAL('textChanged(const QString&)'), self.controleurMaillage.enableBtnSuivant) + + def suivant(self): + """ + affiche le panneau suivant + """ + print "suivant ------------------------------" + PanelBase.suivant(self) + diff --git a/src/EELIH/mainwindow.py b/src/EELIH/mainwindow.py new file mode 100644 index 00000000..d57b7ab5 --- /dev/null +++ b/src/EELIH/mainwindow.py @@ -0,0 +1,54 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +# modules panneau modelisation +from modelisation import * +# modules panneau materiau +from materiau import * +# modules panneau ddl +from ddl import * +# modules panneau pression +from pression import * +# modules panneau publication +from publication import * +# modules panneau geometrie +from geometrie import * +# modules panneau maillage +from maillage import * + +class MainWindow(QMainWindow): + """ + Définit la fenêtre principale de l'application + - ws = widgetStack (pile des panneaux à afficher) + - listePanels = liste de l'ordre d'affichage des panneaux + """ + def __init__(self, appli): + self.appli = appli + QMainWindow.__init__(self, None, "Etude élastique linéaire isotrope homogène", Qt.WDestructiveClose) + self.setCaption("Etude élastique linéaire isotrope homogène") + self.resize(800, 400) + + # création de la pile des panneaux + self.ws = QWidgetStack(self) + self.ws.show() + self.setCentralWidget(self.ws) + + # création des différents panneaux + self.modelisation = Modelisation(self.ws, self.appli) + self.materiau = Materiau(self.ws, self.appli) + self.geometrie = Geometrie(self.ws, self.appli) + self.ddl = Ddl(self.ws, self.appli) + self.pression = Pression(self.ws, self.appli) + #self.maillage = Maillage(self.ws, self.appli) + self.publication = Publication(self.ws, self.appli, self.appli.salome) + + # liste d'ordre d'affichage des panneaux + self.listePanels = [1, self.modelisation, self.materiau, self.geometrie, self.ddl, self.pression, self.publication] + + # ajout des panneaux dans la pile + for wid in self.listePanels[1:]: + self.ws.addWidget(wid) + + # affichage du premier panneau + self.ws.raiseWidget(self.listePanels[1]) diff --git a/src/EELIH/materiau.py b/src/EELIH/materiau.py new file mode 100644 index 00000000..c3521428 --- /dev/null +++ b/src/EELIH/materiau.py @@ -0,0 +1,94 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +# module de gestion des panneaux +from panelbase import * +# modules validateur lineedit +from validationlineedit import * + +class Materiau(PanelBase): + """ + Hérite de la classe mère PanelBase + Définit le panneau pour le choix des propriétés du matériau : + - lnE : lineedit du module d'Young + - lnNU : lineedit du coefficient de Poisson + """ + def __init__(self, parent, appli): + # hérite de la classe mère des panneaux + PanelBase.__init__(self, parent, appli) + + # on modifie le label titre + self.lblTitre.setText('Propriétés du matériau') + + # on modifie l'explication + self.lblExplication.setText("Définissez le module d'Young et le coefficient de Poisson :") + + # espacement + self.sp2 = QSpacerItem(20, 50, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp2, 3, 0) + + # création d'une QGridLayout + self.glProprietes = QGridLayout(self.parent, 2, 3, 5) + self.gl.addLayout(self.glProprietes, 4, 0) + + # ---------------- création et ajout de E ---------------- + # ajout du label E + self.lblE = QLabel("E (module d'Young) :", self.parent) + self.glProprietes.addWidget(self.lblE, 0, 0, Qt.AlignRight) + # ajout du lineedit E + self.lnE = QLineEdit(self.parent) + self.lnE.setMaximumHeight(30) + self.lnE.setMaximumWidth(150) + self.lnE.setMaxLength(10) + self.lnE.setPaletteBackgroundColor(QColor(255, 170, 255)) + self.glProprietes.addWidget(self.lnE, 0, 1) + # ajout du label aide E + self.lblAideE = QLabel("( E >= 0 )", self.parent) + self.glProprietes.addWidget(self.lblAideE, 0, 2) + + # ---------------- création et ajout de NU ---------------- + # ajout du label NU + self.lblNU = QLabel("NU (coefficient de Poisson) :", self.parent) + self.glProprietes.addWidget(self.lblNU, 1, 0, Qt.AlignRight) + # ajout du lineedit NU + self.lnNU = QLineEdit(self.parent) + self.lnNU.setMaximumHeight(30) + self.lnNU.setMaximumWidth(150) + self.lnNU.setMaxLength(10) + self.lnNU.setPaletteBackgroundColor(QColor(255, 170, 255)) + self.glProprietes.addWidget(self.lnNU, 1, 1) + # ajout du label aide NU + self.lblAideNU = QLabel("( -1 <= NU <= 0.5 )", self.parent) + self.glProprietes.addWidget(self.lblAideNU, 1, 2) + + # connexion des signaux et des slots + # dès qu'une valeur est saisie, on teste sa validité + # pour E --> ajout du validateur + self.validE = ValidationLineEdit(0, 10000000000000, 10000000, self.lnE) + self.connect(self.lnE, SIGNAL('textChanged(const QString&)'), self.validE.isValid) + self.connect(self.lnE, SIGNAL('textChanged(const QString&)'), self.valid) + # pour NU --> ajout du validateur + self.validNU = ValidationLineEdit(-1, 0.5, 10, self.lnNU) + self.connect(self.lnNU, SIGNAL('textChanged(const QString&)'), self.validNU.isValid) + self.connect(self.lnNU, SIGNAL('textChanged(const QString&)'), self.valid) + + def suivant(self): + """ + met à jour l'étude avec les nouvelles valeurs saisies + affiche le panneau suivant + affiche les nouvelles valeurs de l'étude (simple fonction d'aide) + """ + self.appli.etude.setMateriau_e(self.lnE.text()) + self.appli.etude.setMateriau_nu(self.lnNU.text()) + PanelBase.suivant(self) + self.appli.etude.affiche() + + def valid(self): + """ + rend valide le bouton suivant si les valeurs saisies sont valides + """ + if self.validE.isValid() and self.validNU.isValid(): + self.btnSuivant.setEnabled(1) + else: + self.btnSuivant.setEnabled(0) diff --git a/src/EELIH/modelisation.py b/src/EELIH/modelisation.py new file mode 100644 index 00000000..06d8a56f --- /dev/null +++ b/src/EELIH/modelisation.py @@ -0,0 +1,58 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +# module de gestion des panneaux +from panelbase import * +# modules panneau materiau +from materiau import * +# modules controleur panneau modelisation +from c_modelisation import * + +class Modelisation(PanelBase): + """ + Hérite de la classe mère PanelBase + Définit le panneau pour le choix de la modélisation : + - cmb = combobox pour choisir le type de modélisation + """ + def __init__(self, parent, appli): + # hérite de la classe mère des panneaux + PanelBase.__init__(self, parent, appli) + + # liste des choix possibles + self.listeChoix = ['3D', '2D_CONTRAINTES_PLANES', '2D_DEFORMATIONS_PLANES', '2D_AXISYMETRIQUE'] + + # on modifie le label titre + self.lblTitre.setText("Modélisation") + + # on modifie l'explication + self.lblExplication.setText("Quelle type de modélisation souhaitez-vous réaliser ?") + + # bouton suivant toujours valide + self.btnSuivant.setEnabled(1) + + # espacement + self.sp2 = QSpacerItem(20, 50, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp2, 3, 0) + #self.gl.setRowSpacing(3, 100) + + # création et ajout du combobox + self.cmb = QComboBox(0, self.parent) + self.cmb.insertStrList(self.listeChoix) + self.cmb.setMaximumWidth(250) + self.gl.addWidget(self.cmb, 4, 0, Qt.AlignCenter) + + # création du controleur modelisation + self.controleurModelisation = C_modelisation(self) + + self.connect(self.cmb, SIGNAL('activated(const QString&)'), self.controleurModelisation.enableDZ) + + def suivant(self): + """ + met à jour l'étude avec la valeur de la modélisation choisie + affiche le panneau suivant + affiche les valeurs de l'étude (simple fonction d'aide) + """ + self.appli.etude.setModelisation(self.cmb.currentText()) + PanelBase.suivant(self) + self.appli.etude.affiche() diff --git a/src/EELIH/panelbase.py b/src/EELIH/panelbase.py new file mode 100644 index 00000000..fb92dd89 --- /dev/null +++ b/src/EELIH/panelbase.py @@ -0,0 +1,94 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * + +class PanelBase(QWidget): + """ + Panneau mère pour tous les panneaux de l'application, se compose de tous les widgets + en commun dans tous les panneaux de l'application + - lblTitre : titre du panneau + - lblExplication : label explication des fonctions du panneau + - btnPrecedent : charge le panneau précédent + - btnSuivant : charge le panneau suivant + """ + def __init__(self, parent, appli): + self.appli = appli + QWidget.__init__(self, parent) + self.parent =self + # création d'une gridlayout pour tous les widgets + self.gl = QGridLayout(self.parent, 8, 1) + + # définition et création du label titre + self.lblTitre = QLabel("Titre", self.parent) + self.lblTitre.setPaletteBackgroundColor(QColor(85, 85, 127)) + self.lblTitre.setPaletteForegroundColor(QColor(255, 255, 255)) + self.lblTitre.setAlignment(Qt.AlignCenter) + self.lblTitre.setMinimumHeight(60) + self.gl.addWidget(self.lblTitre, 0, 0) + + # espacement + self.sp1 = QSpacerItem(20, 30, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp1, 1, 0) + + # définition et création du label explication + self.lblExplication = QLabel("Explications", self.parent) + self.lblExplication.setAlignment(Qt.AlignCenter) + self.lblExplication.setMinimumHeight(60) + self.gl.addWidget(self.lblExplication, 2, 0) + + # espacement + self.sp3 = QSpacerItem(20, 100, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp3, 5, 0) + + # création d'un gridlayout pour les boutons précédent et suivant + self.glBoutons = QGridLayout(self.parent, 1, 5) + self.gl.addLayout(self.glBoutons, 6, 0) + self.glBoutons.setColSpacing(0, 20) + + # définition et création du bouton précédent + self.btnPrecedent = QPushButton("Précédent", self.parent) + self.btnPrecedent.setMaximumWidth(100) + self.glBoutons.addWidget(self.btnPrecedent, 0, 1) + self.glBoutons.setColSpacing(2, 200) + + # définition et création du bouton suivant + self.btnSuivant = QPushButton("Suivant", self.parent) + self.btnSuivant.setMaximumWidth(100) + self.btnSuivant.setEnabled(0) + self.glBoutons.addWidget(self.btnSuivant, 0, 3) + self.glBoutons.setColSpacing(4, 20) + + # espacement + self.sp4 = QSpacerItem(20, 50, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp4, 7, 0) + + # slots et connexions + self.connect(self.btnPrecedent, SIGNAL('clicked()'), self.precedent) + self.connect(self.btnSuivant, SIGNAL('clicked()'), self.suivant) + + def precedent(self): + """ + affiche le panneau précédent + """ + # on est au premier panneau ->on ne fait rien + if self.parentWidget().parentWidget().listePanels[0] <= 1 : + pass + # sinon on affiche le panneau précédent + else: + self.parentWidget().parentWidget().listePanels.insert(0, self.parentWidget().parentWidget().listePanels[0] - 1) + del self.parentWidget().parentWidget().listePanels[1] + self.parentWidget().raiseWidget(self.parentWidget().parentWidget().listePanels[self.parentWidget().parentWidget().listePanels[0]]) + + def suivant(self): + """ + affiche le panneau suivant + """ + # on est au dernier niveau -> on close + if self.parentWidget().parentWidget().listePanels[0] >= len(self.parentWidget().parentWidget().listePanels) - 1 : + self.parentWidget().parentWidget().close() + # sinon on affiche le panneau suivant + else: + self.parentWidget().parentWidget().listePanels.insert(0, self.parentWidget().parentWidget().listePanels[0] + 1) + del self.parentWidget().parentWidget().listePanels[1] + self.parentWidget().raiseWidget(self.parentWidget().parentWidget().listePanels[self.parentWidget().parentWidget().listePanels[0]]) diff --git a/src/EELIH/pression.py b/src/EELIH/pression.py new file mode 100644 index 00000000..4113af71 --- /dev/null +++ b/src/EELIH/pression.py @@ -0,0 +1,86 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +from qttable import QTable +# module de gestion des panneaux +from panelbase import * +# modules validateur lineedit +from validationlineedit import * +# modules de gestion des tables +from c_suppressionLigneTable import * +from c_nouvelleLigneTablePression import * +from c_table import * +# modules de base +import commands + +class Pression(PanelBase): + """ + Hérite de la classe mère PanelBase + Définit le panneau pour le choix des pressions à appliquer pour les sous-géométries : + - tbl = table pour l'affichage des pressions + - controleurTable = controleur de la table + - controleurNouvelleLigneTable = controleur pour l'ajout d'une ligne dans la table + """ + def __init__(self, parent, appli): + # hérite de la classe mère des panneaux + PanelBase.__init__(self, parent, appli) + + # on modifie le label titre + self.lblTitre.setText('Pressions imposés') + + # on modifie l'explication + self.lblExplication.setText("Définissez le(s) groupe(s) de mailles et les pressions à appliquer :") + + # bouton suivant toujurs actif + self.btnSuivant.setEnabled(1) + + # espacement + self.sp2 = QSpacerItem(20, 50, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp2, 3, 0) + + # création d'une QGridLayout + self.glProprietes = QGridLayout(self.parent, 1, 2, 5) + self.gl.addLayout(self.glProprietes, 4, 0) + + # ---------------- création et ajout du QTable ---------------- + self.tbl = QTable(1, 3, self.parent) + self.tbl.setMinimumHeight(150) + self.tbl.setMaximumHeight(200) + self.tbl.setColumnWidth(2, 30) + self.tbl.setRowHeight(0, 30) + + self.th = self.tbl.horizontalHeader() + self.th.setLabel(0, 'Objet') + self.th.setLabel(1, 'Pression') + self.th.setLabel(2, '') + + self.tbl.verticalHeader().hide() + self.tbl.setLeftMargin(0) + + self.glProprietes.addWidget(self.tbl, 0, 0) + + # création du controleur table + self.controleurTable = C_table(self.tbl) + + # création du controleur pour ajout d'une nouvelle ligne dans la table + self.controleurNouvelleLigneTable = C_nouvelleLigneTablePression(self.appli, self.controleurTable, self) + self.controleurNouvelleLigneTable.creeBoutons() + + # bouton plus = nouvelle ligne + px = QPixmap(os.path.join(os.getenv("EFICAS_ROOT_DIR"), 'share/salome/resources/plus.png')) + icon = QIconSet(px) + self.boutonPlus = QPushButton(icon, '', self.parent) + self.glProprietes.addWidget(self.boutonPlus, 0, 1, Qt.AlignCenter) + + self.connect(self.boutonPlus, SIGNAL('clicked()'), self.controleurNouvelleLigneTable.nouvelleLigne) + + def suivant(self): + """ + met à jour l'étude avec les valeurs de pressions saisies + affiche le panneau suivant + affiche les valeurs de l'étude (simple fonction d'aide) + """ + self.appli.etude.setChargements(self.tbl) + PanelBase.suivant(self) + self.appli.etude.affiche() diff --git a/src/EELIH/publication.py b/src/EELIH/publication.py new file mode 100644 index 00000000..0398e959 --- /dev/null +++ b/src/EELIH/publication.py @@ -0,0 +1,185 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * +# module de gestion des panneaux +from panelbase import * +# modules de création du fichier de commande +from fichier import * +# modules de base +import commands + +import salome +import SMESH_utils +import maillage + +class Publication(PanelBase): + """ + Hérite de la classe mère PanelBase + Définit le panneau pour publier le fichier de commandes dans l'arbre d'études de Salome : + """ + def __init__(self, parent, appli, salomeRef): + # hérite de la classe mère des panneaux + PanelBase.__init__(self, parent, appli) + + # initialisation pour la publication dans l'arbre d'étude + self.salome = salomeRef + + # on modifie le label titre + self.lblTitre.setText('Lancement du calcul') + + # on modifie l'explication + self.lblExplication.setText("Etes-vous sûr de souhaiter lancer le calcul ?") + + # espacement + self.sp2 = QSpacerItem(20, 50, QSizePolicy.Minimum, QSizePolicy.Minimum) + self.gl.addItem(self.sp2, 3, 0) + + # changement du bouton suivant + self.btnSuivant.setText("Lancer le calcul") + self.btnSuivant.setMaximumWidth(150) + + # bouton suivant toujours actif + self.btnSuivant.setEnabled(1) + + def suivant(self): + """ + affiche le panneau suivant + crée le fichier de commandes associé aux valeurs saisies + """ + # création des groupes de mailles + self.add_selection() + + # panneau suivant + PanelBase.suivant(self) + + # remplissage du fichier + fichier = Fichier(self.appli, self.salome) + fichier.creer() + + def convertit_group_maille_from_salome(self,liste_in): + """ + convertit les groupes de maille + """ + newr=[] + if [ 1 == 1 ]: + for entree in liste_in : + travail=[] + travail.append(entree) + if dict_geom_numgroupe.has_key(entree): + r=dict_geom_numgroupe[entree] + else: + r=SMESH_utils.getAsterGroupMa(salome.myStudy,travail) + dict_geom_numgroupe[entree]=r + for i in r : + newr.append(i) + else : + print "pas de groupe de maille associé" + showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de maille") + return newr + + def convertit_entrees_en_valeurs(self,liste_faces): + """ + convertit les entry de l'arbre d'étude en valeur + """ + valeur=self.convertit_group_maille_from_salome(liste_faces) + if valeur == []: + print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" + print "Pb pas de fonction de conversion de la valeur Salome en valeur Aster" + print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" + print "VALEUR", valeur + if len(valeur) == 1: + valeur = "'" + str(valeur[0]) + "'" + return valeur + + def add_selection(self): + """ + retourne le nom des objets sélectionnés dans l'arbre d'étude + """ + entrychaine=salome.sg.getAllSelected() + if len(entrychaine) >= 1: + print "1 seule géométrie doit être sélectionnée" + + liste_faces = [] + + # récupération des sous géométries sélectionnées + liste_select = [] + for sousGeomDdl in self.appli.etude.ddls: + if sousGeomDdl[0] not in liste_select: + liste_select.append(sousGeomDdl[0]) + for sousGeomPression in self.appli.etude.chargements: + if sousGeomPression[0] not in liste_select: + liste_select.append(sousGeomPression[0]) + + # transformation des sous geometries en entry + for sousGeom in liste_select: + SO = salome.myStudy.FindObject(str(sousGeom)) + liste_faces.append(SO.GetID()) + + print "----------------------------------> ", liste_faces + self.createMeshPanel(liste_select) + + touteslesvaleurs = self.convertit_entrees_en_valeurs(liste_faces) + + return touteslesvaleurs + + def createMeshPanel(self, listeSousGeomName): + """ + cree autant de panneaux maillages que de sous geometries + """ + self.listeMaillages = [] + for i in listeSousGeomName: + mesh = maillage.Maillage(self.appli.mw.ws, self.appli) + self.listeMaillages.append(mesh) + self.appli.mw.listePanels.append(mesh) + #self.appli.mw.listePanels.insert(0, self.appli.mw.listePanels[0] + 1) + #del self.appli.mw.listePanels[1] + + self.updateGeomMaillage(mesh, i) + + def updateGeomMaillage(self, maillage, sousGeom): + """ + affecte le label indiquant la géométrie sélectionnée du panneau maillage + affecte la listbox du panneau maillage avec les valeurs des maillages trouvés dans l'arbre d'étude + Salome correspondant à la géométrie sélectionnée + """ + # affectation de la géométrie sélectionnée au label du panneau maillage + maillage.lblGeom2.setText(str(self.appli.etude.geometrie[0])) + + # affectation de la sous géométrie au label du panneau maillage + maillage.lblSousGeom2.setText(str(sousGeom)) + + # récupération des mailles correspondants + import eelihCL + maillage.cl=eelihCL.CLinit() + # récupération de l'IOR des sous géométries + GEOMIor = [] + for iorSousGeom in self.appli.mw.geometrie.controleurGeom.dicoSousGeom.keys(): + GEOMIor.append(iorSousGeom) + maillage.cl.GetOrCreateCL(iorSousGeom) + #self.appli.mw.maillage.cl.traiteCL() + maillage.cl.get_geoms() + maillage.cl.get_maillages() +# + maillage.cl.MainShapes(0) +# + listeMaillage = maillage.cl.Possibles(0, str(self.appli.etude.geometrie[0])) + # insertion des maillages trouvés dans la listbox du panneau maillage + # si aucun maillage on disable la listbox + # sinon on disable le lineedit pour donner le nom d'un nouveau maillage + if listeMaillage != []: + maillage.lbMaillage.insertStrList(listeMaillage) + #maillage.lbMaillage.setEnabled(1) + #maillage.lblMaillage.setEnabled(1) + #maillage.lblNouveauMaillage.setEnabled(0) + #maillage.lnNouveauMaillage.setEnabled(0) + #else: + #maillage.lnNouveauMaillage.setEnabled(1) + #maillage.lblNouveauMaillage.setEnabled(1) + #maillage.lbMaillage.setEnabled(0) + #maillage.lblMaillage.setEnabled(0) + + + +dict_geom_numgroupe = { } +dict_geom_numface = { } diff --git a/src/EELIH/validationlineedit.py b/src/EELIH/validationlineedit.py new file mode 100644 index 00000000..7a2e62af --- /dev/null +++ b/src/EELIH/validationlineedit.py @@ -0,0 +1,37 @@ +# -*- coding: iso-8859-1 -*- + +# modules PyQt +from qt import * + +class ValidationLineEdit: + """ + crée un validateur pour un lineedit + """ + def __init__(self, min, max, decimal, widget): + """ + min = valeur minimale à saisir + max = valeur maximale à saisir + decimal = nombre de chiffres après la virgule autorisé + widget = widget associé au validateur + """ + self.widget = widget + if min == None and max == None and decimal == None: + val = QDoubleValidator(self.widget) + else: + val = QDoubleValidator(min, max, decimal, self.widget) + self.widget.setValidator(val) + + def isValid(self): + """ + si les données saisies dans le widget vérifient le validateur, + le widget devient blanc sinon le widget est rose + """ + correct = 0 + if self.widget.hasAcceptableInput(): + self.widget.setPaletteBackgroundColor(QColor(255, 255, 255)) + correct = 1 + else: + self.widget.setPaletteBackgroundColor(QColor(255, 170, 255)) + + return correct +