mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2025-04-09 21:27:26 +05:00
404 lines
15 KiB
Python
404 lines
15 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright (C) 2006-2020 EDF R&D
|
|
#
|
|
# This library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Lesser General Public
|
|
# License as published by the Free Software Foundation; either
|
|
# version 2.1 of the License, or (at your option) any later version.
|
|
#
|
|
# This library is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with this library; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
#
|
|
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
|
|
#
|
|
|
|
# if you already have plugins defined in a salome_plugins.py file, add this file at the end.
|
|
# if not, copy this file as ${HOME}/Plugins/smesh_plugins.py or ${APPLI}/Plugins/smesh_plugins.py
|
|
|
|
import os
|
|
import math
|
|
import sys
|
|
import traceback
|
|
|
|
from blocFissure import gmu
|
|
|
|
|
|
def fissureCoudeDlg(context):
|
|
# get context study, salomeGui
|
|
study = context.study
|
|
sg = context.sg
|
|
|
|
#import subprocess
|
|
#import tempfile
|
|
from qtsalome import QFileDialog, QMessageBox, QPalette, QColor, QDialog
|
|
from blocFissure.ihm.fissureCoude_ui import Ui_Dialog
|
|
|
|
class fissureCoudeDialog(QDialog):
|
|
|
|
def __init__(self):
|
|
QDialog.__init__(self)
|
|
# Set up the user interface from Designer.
|
|
self.ui = Ui_Dialog()
|
|
self.ui.setupUi(self)
|
|
|
|
self.blackPalette = self.ui.dsb_angle.palette()
|
|
self.redPalette = QPalette()
|
|
self.redPalette.setColor(QPalette.Text, QColor(255,0,0))
|
|
self.NOK = False
|
|
|
|
self.initDefaut()
|
|
self.initDialog(self.defaut)
|
|
self.ui.dsb_angle.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_rCintr.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_lTubeP1.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_lTubeP2.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_epais.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_dext.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_profondeur.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_longueur.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_azimut.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_orientation.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_posiAngul.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_absCurv.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.sb_nbTranches.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.sb_nbCouronne.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.sb_nbSecteur.setSpecialValueText("saisie_obligatoire")
|
|
self.ui.dsb_aretesFaceFissure.setSpecialValueText("automatique")
|
|
self.ui.dsb_influence.setSpecialValueText("automatique")
|
|
self.ui.lb_calcul.hide()
|
|
|
|
# Connect up the buttons.
|
|
self.ui.pb_valPrec.clicked.connect(self.readValPrec)
|
|
self.ui.pb_reset.clicked.connect(self.resetVal)
|
|
self.ui.pb_recharger.clicked.connect(self.recharger)
|
|
self.ui.pb_sauver.clicked.connect(self.sauver)
|
|
self.ui.buttonBox.accepted.disconnect(self.accept)
|
|
self.ui.buttonBox.accepted.connect(self.execute)
|
|
|
|
def initDefaut(self):
|
|
self.defaut = dict( \
|
|
angle = -181.0, \
|
|
rCintr = 0.0, \
|
|
lTubeP1 = 0.0, \
|
|
lTubeP2 = 0.0, \
|
|
epais = 0.0, \
|
|
dext = 0.0, \
|
|
profondeur = 0.0, \
|
|
longueur = 0.0, \
|
|
azimut = -181.0, \
|
|
orientation = -1.0, \
|
|
posiAngul = -181.0, \
|
|
absCurv = 0.0, \
|
|
nbTranches = 7, \
|
|
nbCouronnes = 1, \
|
|
nbSecteurs = 3, \
|
|
cbOptDiscrSain = False, \
|
|
cbOptDiscrFiss = False, \
|
|
rbPosiAngul = True, \
|
|
rbFissExt = True, \
|
|
cbForceEllipse = False, \
|
|
nbAxeTubeP1 = 15, \
|
|
nbAxeTubeP2 = 15, \
|
|
nbAxeCoude = 10, \
|
|
nbCirconf = 20, \
|
|
nbEpaisseur = 3, \
|
|
rayonTore = 2.0, \
|
|
aretesFaceFissure = 0.0, \
|
|
influence = 0.0, \
|
|
)
|
|
|
|
def initDialog(self, dico):
|
|
self.ui.dsb_angle.setValue(dico['angle'])
|
|
self.ui.dsb_rCintr.setValue(dico['rCintr'])
|
|
self.ui.dsb_lTubeP1.setValue(dico['lTubeP1'])
|
|
self.ui.dsb_lTubeP2.setValue(dico['lTubeP2'])
|
|
self.ui.dsb_epais.setValue(dico['epais'])
|
|
self.ui.dsb_dext.setValue(dico['dext'])
|
|
self.ui.dsb_profondeur.setValue(dico['profondeur'])
|
|
self.ui.dsb_longueur.setValue(dico['longueur'])
|
|
self.ui.dsb_azimut.setValue(dico['azimut'])
|
|
self.ui.dsb_orientation.setValue(dico['orientation'])
|
|
self.ui.dsb_posiAngul.setValue(dico['posiAngul'])
|
|
self.ui.dsb_absCurv.setValue(dico['absCurv'])
|
|
self.ui.sb_nbTranches.setValue(dico['nbTranches'])
|
|
self.ui.sb_nbCouronne.setValue(dico['nbCouronnes'])
|
|
self.ui.sb_nbSecteur.setValue(dico['nbSecteurs'])
|
|
self.ui.dsb_aretesFaceFissure.setValue(dico['aretesFaceFissure'])
|
|
self.ui.dsb_influence.setValue(dico['influence'])
|
|
self.ui.sb_nbAxeTubeP1.setValue(dico['nbAxeTubeP1'])
|
|
self.ui.sb_nbAxeTubeP2.setValue(dico['nbAxeTubeP2'])
|
|
self.ui.sb_nbAxeCoude.setValue(dico['nbAxeCoude'])
|
|
self.ui.sb_nbCirconf.setValue(dico['nbCirconf'])
|
|
self.ui.sb_nbEpaisseur.setValue(dico['nbEpaisseur'])
|
|
self.ui.dsb_rayonTore.setValue(dico['rayonTore'])
|
|
#self.ui.cb_optDiscrSain.setChecked(False)
|
|
#self.ui.gb_discrSain.setShown(False)
|
|
self.ui.cb_optDiscrSain.setChecked(not(dico['cbOptDiscrSain']))
|
|
self.ui.cb_optDiscrSain.click()
|
|
self.ui.cb_optDiscrFiss.setChecked(not(dico['cbOptDiscrFiss']))
|
|
self.ui.cb_optDiscrFiss.click()
|
|
if dico['rbPosiAngul']:
|
|
self.ui.dsb_absCurv.setEnabled(False)
|
|
self.ui.dsb_posiAngul.setEnabled(True)
|
|
self.ui.rb_posiAngul.setChecked(True)
|
|
#self.ui.rb_posiAngul.click()
|
|
else:
|
|
self.ui.dsb_absCurv.setEnabled(True)
|
|
self.ui.dsb_posiAngul.setEnabled(False)
|
|
self.ui.rb_absCurv.setChecked(True)
|
|
#self.ui.rb_absCurv.click()
|
|
self.ui.rb_fissExt.setChecked(dico['rbFissExt'])
|
|
self.ui.cb_forceEllipse.setChecked(dico['cbForceEllipse'])
|
|
incomplet = self.testval(dico)
|
|
pass
|
|
|
|
def testval(self, dico):
|
|
incomplet = False
|
|
if dico['angle'] < -180.0:
|
|
self.ui.dsb_angle.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_angle.setPalette(self.blackPalette)
|
|
|
|
if dico['rCintr'] == 0.0:
|
|
self.ui.dsb_rCintr.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_rCintr.setPalette(self.blackPalette)
|
|
|
|
if dico['lTubeP1'] == 0.0:
|
|
self.ui.dsb_lTubeP1.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_lTubeP1.setPalette(self.blackPalette)
|
|
|
|
if dico['lTubeP2'] == 0.0:
|
|
self.ui.dsb_lTubeP2.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_lTubeP2.setPalette(self.blackPalette)
|
|
|
|
if dico['epais'] == 0.0:
|
|
self.ui.dsb_epais.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_epais.setPalette(self.blackPalette)
|
|
|
|
if dico['dext'] == 0.0:
|
|
self.ui.dsb_dext.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_dext.setPalette(self.blackPalette)
|
|
|
|
if dico['profondeur'] == 0.0:
|
|
self.ui.dsb_profondeur.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_profondeur.setPalette(self.blackPalette)
|
|
|
|
if dico['longueur'] == 0.0:
|
|
self.ui.dsb_longueur.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_longueur.setPalette(self.blackPalette)
|
|
|
|
if dico['azimut'] < -180.0:
|
|
self.ui.dsb_azimut.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_azimut.setPalette(self.blackPalette)
|
|
|
|
if dico['orientation'] < 0.0:
|
|
self.ui.dsb_orientation.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_orientation.setPalette(self.blackPalette)
|
|
|
|
if ( ( dico['posiAngul'] < -180.0 ) and dico['rbPosiAngul'] ):
|
|
self.ui.dsb_posiAngul.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_posiAngul.setPalette(self.blackPalette)
|
|
|
|
if ( ( dico['absCurv'] == 0.0 ) and ( not dico['rbPosiAngul'] ) ):
|
|
self.ui.dsb_absCurv.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.dsb_absCurv.setPalette(self.blackPalette)
|
|
|
|
if dico['nbTranches'] == 7:
|
|
self.ui.sb_nbTranches.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.sb_nbTranches.setPalette(self.blackPalette)
|
|
|
|
if dico['nbCouronnes'] == 1:
|
|
self.ui.sb_nbCouronne.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.sb_nbCouronne.setPalette(self.blackPalette)
|
|
|
|
if dico['nbSecteurs'] == 3:
|
|
self.ui.sb_nbSecteur.setPalette(self.redPalette)
|
|
incomplet = True
|
|
else:
|
|
self.ui.sb_nbSecteur.setPalette(self.blackPalette)
|
|
|
|
print("incomplet: ", incomplet)
|
|
return incomplet
|
|
|
|
def fileDefault(self):
|
|
filedef = os.path.expanduser( os.path.join(os.environ["HOME"],".config", "salome", "dialogFissureCoude.dic") )
|
|
print(filedef)
|
|
return filedef
|
|
|
|
def writeDefault(self, dico):
|
|
filedef = self.fileDefault()
|
|
with open(filedef, 'w') as f:
|
|
f.write(str(dico))
|
|
|
|
def readValPrec(self):
|
|
filedef = self.fileDefault()
|
|
if os.path.exists(filedef):
|
|
with open(filedef, 'r') as f:
|
|
txt = f.read()
|
|
dico = eval(txt)
|
|
print(dico)
|
|
self.initDialog(dico)
|
|
|
|
def resetVal(self):
|
|
#self.initDefaut()
|
|
self.initDialog(self.defaut)
|
|
|
|
def sauver(self):
|
|
print("sauver")
|
|
fileDiag = QFileDialog(self)
|
|
fileDiag.setFileMode(QFileDialog.AnyFile)
|
|
fileDiag.setNameFilter("Parametres *.dic (*.dic)")
|
|
fileDiag.setViewMode(QFileDialog.List)
|
|
if fileDiag.exec_() :
|
|
fileNames = fileDiag.selectedFiles()
|
|
filedef = fileNames[0]
|
|
dico = self.creeDico()
|
|
with open(filedef, 'w') as f:
|
|
f.write(str(dico))
|
|
|
|
def recharger(self):
|
|
print("recharger")
|
|
fileDiag = QFileDialog(self)
|
|
fileDiag.setFileMode(QFileDialog.ExistingFile)
|
|
fileDiag.setNameFilter("Parametres *.dic (*.dic)")
|
|
fileDiag.setViewMode(QFileDialog.Detail)
|
|
if fileDiag.exec_() :
|
|
fileNames = fileDiag.selectedFiles()
|
|
filedef = fileNames[0]
|
|
print(filedef)
|
|
if os.path.exists(filedef):
|
|
with open(filedef, 'r') as f:
|
|
txt = f.read()
|
|
dico = eval(txt)
|
|
print(dico)
|
|
self.initDialog(dico)
|
|
|
|
def creeDico(self):
|
|
dico = dict( \
|
|
angle = self.ui.dsb_angle.value(), \
|
|
rCintr = self.ui.dsb_rCintr.value(), \
|
|
lTubeP1 = self.ui.dsb_lTubeP1.value(), \
|
|
lTubeP2 = self.ui.dsb_lTubeP2.value(), \
|
|
epais = self.ui.dsb_epais.value(), \
|
|
dext = self.ui.dsb_dext.value(), \
|
|
profondeur = self.ui.dsb_profondeur.value(), \
|
|
longueur = self.ui.dsb_longueur.value(), \
|
|
azimut = self.ui.dsb_azimut.value(), \
|
|
orientation = self.ui.dsb_orientation.value(), \
|
|
posiAngul = self.ui.dsb_posiAngul.value(), \
|
|
absCurv = self.ui.dsb_absCurv.value(), \
|
|
nbTranches = self.ui.sb_nbTranches.value(), \
|
|
nbCouronnes = self.ui.sb_nbCouronne.value(), \
|
|
nbSecteurs = self.ui.sb_nbSecteur.value(), \
|
|
cbOptDiscrSain = self.ui.cb_optDiscrSain.isChecked(), \
|
|
cbOptDiscrFiss = self.ui.cb_optDiscrFiss.isChecked(), \
|
|
rbPosiAngul = self.ui.rb_posiAngul.isChecked(), \
|
|
rbFissExt = self.ui.rb_fissExt.isChecked(), \
|
|
cbForceEllipse = self.ui.cb_forceEllipse.isChecked(), \
|
|
nbAxeTubeP1 = self.ui.sb_nbAxeTubeP1.value(), \
|
|
nbAxeTubeP2 = self.ui.sb_nbAxeTubeP2.value(), \
|
|
nbAxeCoude = self.ui.sb_nbAxeCoude.value(), \
|
|
nbCirconf = self.ui.sb_nbCirconf.value(), \
|
|
nbEpaisseur = self.ui.sb_nbEpaisseur.value(), \
|
|
rayonTore = self.ui.dsb_rayonTore.value(), \
|
|
aretesFaceFissure = self.ui.dsb_aretesFaceFissure.value(), \
|
|
influence = self.ui.dsb_influence.value(), \
|
|
)
|
|
print(dico)
|
|
return dico
|
|
|
|
def checkValues(self):
|
|
return self.NOK
|
|
|
|
def execute(self):
|
|
from blocFissure.gmu import initLog
|
|
#initLog.setDebug()
|
|
initLog.setVerbose() # don't set the level too early, to be able to modify it
|
|
from blocFissure.gmu import geomsmesh
|
|
from blocFissure.gmu.casStandard import casStandard
|
|
from blocFissure.ihm.fissureCoude_ihm import fissureCoude_ihm
|
|
|
|
dico = self.creeDico()
|
|
NOK = self.testval(dico)
|
|
if not(NOK):
|
|
dico['lenSegPipe'] = (dico['longueur'] + math.pi*dico['profondeur'])/dico['nbTranches']
|
|
print('lenSegPipe', dico['lenSegPipe'])
|
|
areteMinAngle = (dico['rCintr'] -dico['dext']/2.0)*(dico['angle']*math.pi/180.0)/dico['nbAxeCoude']
|
|
print('areteMinAngle', areteMinAngle)
|
|
areteMinCirco = dico['dext']*math.pi/(2*dico['nbCirconf'])
|
|
print('areteMinCirco', areteMinCirco)
|
|
areteMinEpais = dico['epais']/dico['nbEpaisseur']
|
|
print('areteMinEpais', areteMinEpais)
|
|
if dico['influence'] == 0:
|
|
dico['influence'] = max(areteMinAngle, areteMinCirco, areteMinEpais)
|
|
print('influence', dico['influence'])
|
|
if dico['aretesFaceFissure'] == 0:
|
|
dico['aretesFaceFissure'] = (areteMinAngle + areteMinCirco)/2.0
|
|
print('aretesFaceFissure', dico['aretesFaceFissure'])
|
|
if not dico['rbPosiAngul']:
|
|
rmoy = (dico['dext'] - dico['epais'])/2.0
|
|
eta = 1
|
|
if not dico['rbFissExt']:
|
|
eta = -1
|
|
dico['posiAngul'] = (180.0/math.pi)*dico['absCurv']/(dico['rCintr']+(rmoy+eta*dico['epais']/2.0)*math.cos(math.pi*dico['azimut']/180.))
|
|
print('posiAngul' , dico['posiAngul'])
|
|
|
|
self.writeDefault(dico)
|
|
self.ui.lb_calcul.show()
|
|
probleme = fissureCoude_ihm(0)
|
|
probleme.setDicoParams(dico)
|
|
probleme.executeProbleme()
|
|
self.NOK = NOK
|
|
self.accept()
|
|
|
|
# ----------------------------------------------------------------------------
|
|
|
|
window = fissureCoudeDialog()
|
|
# window.ui.dsb_tolerance.setValue(0.01)
|
|
retry = True
|
|
while(retry):
|
|
retry = False
|
|
window.exec_()
|
|
result = window.result()
|
|
if result:
|
|
# dialog accepted
|
|
print("dialog accepted, check")
|
|
retry = window.checkValues()
|
|
else:
|
|
print("dialog rejected, exit")
|
|
|