def __init__(self, case):
"""FluidCharacteristicsModel Constuctor."""
self.case = case
self.node_models = self.case.xmlGetNode('thermophysical_models')
self.node_prop = self.case.xmlGetNode('physical_properties')
self.node_fluid = self.node_prop.xmlInitNode('fluid_properties')
self.node_comp = self.node_models.xmlInitNode('compressible_model',
'model')
self.node_gas = self.node_models.xmlInitNode('gas_combustion', 'model')
self.node_coal = self.node_models.xmlInitNode('solid_fuels', 'model')
self.node_density = self.setNewFluidProperty(self.node_fluid,
'density')
self.node_viscosity = self.setNewFluidProperty(self.node_fluid,
'molecular_viscosity')
self.node_heat = self.setNewFluidProperty(self.node_fluid,
'specific_heat')
self.node_cond = self.setNewFluidProperty(self.node_fluid,
'thermal_conductivity')
import code_saturne.cs_config as cs_config
cfg = cs_config.config()
self.freesteam = 0
if cfg.libs['freesteam'].have != "no":
self.freesteam = 1
self.coolprop = 0
if cfg.libs['coolprop'].have != "no":
self.coolprop = 1
def print_modules(pkg):
"""
Print Code_Saturne environment modules info.
"""
from code_saturne import cs_config
c = cs_config.config()
if c.env_modulecmd:
print("Module command: " + str(c.env_modulecmd))
print("Environment modules: " + str(c.env_modules))
def __init__(self, case):
"""FluidCharacteristicsModel Constuctor."""
self.case = case
self.node_models = self.case.xmlGetNode('thermophysical_models')
self.node_prop = self.case.xmlGetNode('physical_properties')
self.node_fluid = self.node_prop.xmlInitNode('fluid_properties')
self.node_comp = self.node_models.xmlInitNode('compressible_model', 'model')
self.node_gas = self.node_models.xmlInitNode('gas_combustion', 'model')
self.node_coal = self.node_models.xmlInitNode('solid_fuels', 'model')
self.node_density = self.setNewFluidProperty(self.node_fluid, 'density')
self.node_viscosity = self.setNewFluidProperty(self.node_fluid, 'molecular_viscosity')
self.node_heat = self.setNewFluidProperty(self.node_fluid, 'specific_heat')
self.node_cond = self.setNewFluidProperty(self.node_fluid, 'thermal_conductivity')
import code_saturne.cs_config as cs_config
cfg = cs_config.config()
self.freesteam = 0
if cfg.libs['freesteam'].have != "no":
self.freesteam = 1
def main(argv, pkg):
"""
Start Qt and a session of the application.
"""
from code_saturne.cs_exec_environment import set_modules, source_rcfile
set_modules(pkg)
source_rcfile(pkg)
images_path = os.path.join(pkg.get_dir('pkgdatadir'), 'images')
# Test if EOS modules could be imported
cfg = cs_config.config()
if cfg.libs['eos'].have == "yes":
eosprefix = cfg.libs['eos'].prefix
try:
from distutils import sysconfig
eospath = os.path.join(
sysconfig.get_python_lib(0, 0, prefix=eosprefix), 'eos')
except Exception:
eospath = ''
if sys.platform.startswith('win'):
eospath = os.path.join(eosprefix, 'lib',
'python' + sys.version[:3], 'site-packages',
'eos')
if eospath:
if os.path.isdir(eospath) and not eospath in sys.path:
sys.path.insert(0, eospath)
case, spl = process_cmd_line(argv)
app = QApplication(sys.argv)
app.setOrganizationName(
pkg.code_name) # Defines the name of subdirectory under .config
app.setOrganizationDomain(pkg.url)
app.setApplicationName("gui") # Defines the name of the configuration file
#app.setWindowIcon(QIcon(":/icon.png"))
app.lastWindowClosed.connect(app.quit)
# Locale detection
locale = QLocale.system().name()
translator = QTranslator(app)
tr_file = "code_saturne"
localedir = pkg.get_dir('localedir')
tr_loaded = translator.load(QLocale(), tr_file, "_", localedir, ".qm")
if tr_loaded:
app.installTranslator(translator)
if spl:
app.setOverrideCursor(QCursor(Qt.WaitCursor))
pixmap = QPixmap('%s/splashscreen.png' % images_path)
splash = QSplashScreen(pixmap, Qt.WindowStaysOnTopHint)
splash.setMask(pixmap.mask(
)) # this is useful if the splashscreen is not a regular ractangle...
splash.show()
if pkg.name == 'neptune_cfd':
splash.showMessage("%(name)s %(vers)s starting..." \
% {'name': pkg.name, 'vers':pkg.version},
Qt.AlignHCenter | Qt.AlignVCenter, Qt.black)
app.processEvents()
QTimer.singleShot(1500, splash.hide)
if os.path.split(case)[1] == "run.cfg":
from code_saturne.Base.QCouplingEditorView import QCouplingEditor
mv = QCouplingEditor(cfgfile=case, standalone_mode=True)
def __init__(self, case):
"""FluidCharacteristicsModel Constuctor."""
self.case = case
self.node_models = self.case.xmlGetNode('thermophysical_models')
self.node_prop = self.case.xmlGetNode('physical_properties')
self.node_fluid = self.node_prop.xmlInitNode('fluid_properties')
self.node_comp = self.node_models.xmlInitNode('compressible_model',
'model')
self.node_gas = self.node_models.xmlInitNode('gas_combustion', 'model')
self.node_coal = self.node_models.xmlInitNode('solid_fuels', 'model')
# Info on available libraries
self.mask_builtin = 1 << 0
self.mask_CoolProp = 1 << 1
self.mask_EOS = 1 << 2
self.mask_freesteam = 1 << 3
self.tables = 0
from code_saturne import cs_config
cfg = cs_config.config()
self.lib_properties = {}
self.lib_properties['user_material'] = self.mask_builtin
if EOS == 1:
self.tables += self.mask_EOS
self.ava = eosAva.EosAvailable()
# suppress perfect gas
fls = self.ava.whichFluids()
for fli in fls:
if fli in eos_excl:
continue
if fli not in self.lib_properties.keys():
self.lib_properties[fli] = self.mask_EOS
else:
self.lib_properties[fli] += self.mask_EOS
if cfg.libs['freesteam'].have != "no":
self.tables += self.mask_freesteam
fli = 'Water'
if fli not in self.lib_properties.keys():
self.lib_properties[fli] = self.mask_freesteam
else:
self.lib_properties[fli] += self.mask_freesteam
if coolprop_fluids:
if cfg.libs['coolprop'].have != "no":
self.tables += self.mask_CoolProp
for fli in coolprop_fluids:
if fli not in self.lib_properties.keys():
self.lib_properties[fli] = self.mask_CoolProp
else:
self.lib_properties[fli] += self.mask_CoolProp
# Base model needs density and molecular viscosity
self.lst = [('density', 'Rho'), ('molecular_viscosity', 'Mu')]
self.node_density = self.setNewFluidProperty(self.node_fluid, \
'density')
self.node_viscosity = self.setNewFluidProperty(self.node_fluid, \
'molecular_viscosity')
self.node_lst = [self.node_density, self.node_viscosity]
self.node_heat = None
self.node_cond = None
self.node_vol_visc = None
self.node_dyn = None
# Get thermal scalar and model
thm = ThermalScalarModel(self.case)
tsn = thm.getThermalScalarName()
self.tsm = thm.getThermalScalarModel()
# If thermal model enabled, add thermal conductivity and specific heat
if self.tsm != "off":
self.lst.extend([('specific_heat', 'Cp'), \
('thermal_conductivity', 'Al')])
self.node_heat = self.setNewFluidProperty(self.node_fluid, \
'specific_heat')
self.node_cond = self.setNewFluidProperty(self.node_fluid, \
'thermal_conductivity')
self.node_lst.extend([self.node_heat, self.node_cond])
# Define volume viscosity for compressible model
if self.node_comp['model'] not in [None, "off"]:
self.lst.append(('volume_viscosity', 'Viscv0'))
self.node_vol_visc = self.setNewFluidProperty(self.node_fluid, \
'volume_viscosity')
self.node_lst.append(self.node_vol_visc)
# Define dynamic diffusion for reactive flow
elif self.node_coal['model'] not in [None, "off"] \
or self.node_gas['model'] not in [None, "off"]:
self.lst.append(('dynamic_diffusion', 'Diftl0'))
self.node_dyn = self.setNewFluidProperty(self.node_fluid, \
'dynamic_diffusion')
self.node_lst.append(self.node_dyn)
# Build scalars list
self.list_scalars = []
if self.tsm == "temperature_celsius":
self.list_scalars.append(
(tsn, self.tr("Thermal scalar: temperature (\xB0 C)")))
elif self.tsm == "temperature_kelvin":
self.list_scalars.append(
(tsn, self.tr("Thermal scalar: temperature (K)")))
elif self.tsm != "off":
self.list_scalars.append((tsn, self.tr("Thermal scalar")))
self.m_sca = DefineUserScalarsModel(self.case)
for s in self.m_sca.getUserScalarNameList():
self.list_scalars.append((s, self.tr("Additional scalar")))
# Notebook
self.notebook = NotebookModel(self.case)
pass
# Perfect gases to exclude from EOS choices
eos_excl = ["Argon", "Nitrogen", "Hydrogen", "Oxygen", "Helium", "Air"]
#-------------------------------------------------------------------------------
# Coolprop
#-------------------------------------------------------------------------------
from code_saturne import cs_config
coolprop_fluids = []
coolprop_warn = False
if cs_config.config().libs['coolprop'].have != "no" and not coolprop_fluids:
try:
import sys
sys.path.insert(
0,
cs_config.config().libs['coolprop'].flags['pythonpath'])
import CoolProp
sys.path.pop(0)
self.coolprop_fluids = []
for f in CoolProp.__fluids__:
coolprop_fluids.append(f)
coolprop_fluids.sort()
except Exception: # CoolProp might be available but not its Python bindings
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_ImmersedBoundariesNeptune.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.ibm = ImmersedBoundariesModel(self.case)
self.current_obj = None
# Models
self.modelFSI = StandardItemModelFSI(self.ibm)
self.tableViewFSI.setModel(self.modelFSI)
for obj in range(1, self.ibm.getNumberOfFSIObjects() + 1):
self.modelFSI.addItem(self.ibm.getObjectName(obj),
self.ibm.getObjectInteraction(obj))
if QT_API == "PYQT4":
self.tableViewFSI.verticalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.tableViewFSI.horizontalHeader().setResizeMode(
QHeaderView.ResizeToContents)
# self.tableViewFSI.horizontalHeader().setResizeMode(2, QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewFSI.verticalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.tableViewFSI.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
# self.tableViewFSI.horizontalHeader().setSectionResizeMode(2, QHeaderView.Stretch)
self.modelFSI.dataChanged.connect(self.dataChanged)
delegateObjectLabel = FSIObjectNameDelegate(self.tableViewFSI)
self.tableViewFSI.setItemDelegateForColumn(0, delegateObjectLabel)
delegateObjectType = FSITypeDelegate(self.tableViewFSI, self.ibm)
self.tableViewFSI.setItemDelegateForColumn(1, delegateObjectType)
self.checkBoxActivate.stateChanged.connect(self.slotCheckActivate)
self.tableViewFSI.clicked[QModelIndex].connect(
self.slotChangedSelection)
for ind in ['Explicit', 'MEDCoupling']:
eval('self.radioButton' + ind +
'.toggled.connect(self.slotRadioButton)')
# Connections
self.pushButtonAddFSI.clicked.connect(self.slotAddFSI)
self.pushButtonDeleteFSI.clicked.connect(self.slotDeleteFSI)
self.pushButtonExplicit.clicked.connect(self.slotExplicitFormula)
validatorDensity = DoubleValidator(self.lineEditObjDensity, min=0.0)
self.lineEditObjDensity.setValidator(validatorDensity)
self.lineEditObjDensity.textChanged[str].connect(self.slotObjDensity)
validatorStiffness = DoubleValidator(self.lineEditObjStiffness,
min=0.0)
self.lineEditObjStiffness.setValidator(validatorStiffness)
self.lineEditObjStiffness.textChanged[str].connect(
self.slotObjStiffness)
validatorDamping = DoubleValidator(self.lineEditObjDamping, min=0.0)
self.lineEditObjDamping.setValidator(validatorDamping)
self.lineEditObjDamping.textChanged[str].connect(self.slotObjDamping)
self.lineEditXInit.textChanged[str].connect(self.slotObjXinit)
self.lineEditYInit.textChanged[str].connect(self.slotObjYinit)
self.lineEditZInit.textChanged[str].connect(self.slotObjZinit)
self.lineEditXEq.textChanged[str].connect(self.slotObjXeq)
self.lineEditYEq.textChanged[str].connect(self.slotObjYeq)
self.lineEditZEq.textChanged[str].connect(self.slotObjZeq)
self.lineEditVelXInit.textChanged[str].connect(self.slotObjVelXinit)
self.lineEditVelYInit.textChanged[str].connect(self.slotObjVelYinit)
self.lineEditVelZInit.textChanged[str].connect(self.slotObjVelZinit)
self.lineEditAccXInit.textChanged[str].connect(self.slotObjAccXinit)
self.lineEditAccYInit.textChanged[str].connect(self.slotObjAccYinit)
self.lineEditAccZInit.textChanged[str].connect(self.slotObjAccZinit)
# Check for MEDCoupling presence
from code_saturne import cs_config
cfg = cs_config.config()
self.has_medcoupling = cfg.libs['medcoupling'].have == 'yes'
# deactivated for the moment
self.has_medcoupling = False
self.radioButtonMEDCoupling.setEnabled(self.has_medcoupling)
if self.ibm.getMethod(
) == 'medcoupling' and self.has_medcoupling == False:
self.setMethod('explicit')
# Show/hide widgets on start
if self.ibm.getOnOff() == 'off':
self.groupBoxMethod.hide()
self.groupBoxObjects.hide()
self.groupBoxObjProperties.hide()
self.groupBoxExplicit.hide()
self.groupBoxMEDCoupling.hide()
else:
self.groupBoxMethod.show()
self.groupBoxObjects.show()
if self.ibm.getMethod() == 'explicit':
self.groupBoxExplicit.show()
else:
self.groupBoxMEDCoupling.show()
self.updatePageView()
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_PerformanceTuningForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = PerformanceTuningModel(self.case)
# Combo models and items
self.modelPartType = ComboModel(self.comboBox_PartType, 4, 1)
self.modelPartOut = ComboModel(self.comboBox_PartOutput, 3, 1)
self.modelPartType.addItem(self.tr("Default"), 'default')
self.modelPartType.addItem(self.tr("PT-SCOTCH / SCOTCH"), 'scotch')
self.modelPartType.addItem(self.tr("ParMETIS / METIS"), 'metis')
self.modelPartType.addItem(self.tr("Morton curve (bounding box)"),
'morton sfc')
self.modelPartType.addItem(self.tr("Morton curve (bounding cube)"),
'morton sfc cube')
self.modelPartType.addItem(self.tr("Hilbert curve (bounding box)"),
'hilbert sfc')
self.modelPartType.addItem(self.tr("Hilbert curve (bounding cube)"),
'hilbert sfc cube')
self.modelPartType.addItem(self.tr("Block (unoptimized)"), 'block')
from code_saturne import cs_config
cfg = cs_config.config()
if cfg.libs['scotch'].have == "no":
self.comboBox_PartType.setItemData(1, QColor(Qt.red),
Qt.TextColorRole)
if cfg.libs['metis'].have == "no":
self.comboBox_PartType.setItemData(2, QColor(Qt.red),
Qt.TextColorRole)
self.modelPartOut.addItem(self.tr("No"), 'no')
self.modelPartOut.addItem(self.tr("For graph-based partitioning"),
'default')
self.modelPartOut.addItem(self.tr("Yes"), 'yes')
self.modelBlockIORead = ComboModel(self.comboBox_IORead, 6, 1)
self.modelBlockIOWrite = ComboModel(self.comboBox_IOWrite, 4, 1)
self.modelBlockIORead.addItem(self.tr("Default"), 'default')
self.modelBlockIORead.addItem(self.tr("Standard I/O, serial"),
'stdio serial')
self.modelBlockIORead.addItem(self.tr("Standard I/O, parallel"),
'stdio parallel')
self.modelBlockIORead.addItem(self.tr("MPI I/O, independent"),
'mpi independent')
self.modelBlockIORead.addItem(self.tr("MPI I/O, non-collective"),
'mpi noncollective')
self.modelBlockIORead.addItem(self.tr("MPI I/O, collective"),
'mpi collective')
self.modelBlockIOWrite.addItem(self.tr("Default"), 'default')
self.modelBlockIOWrite.addItem(self.tr("Standard I/O, serial"),
'stdio serial')
self.modelBlockIOWrite.addItem(self.tr("MPI I/O, non-collective"),
'mpi noncollective')
self.modelBlockIOWrite.addItem(self.tr("MPI I/O, collective"),
'mpi collective')
# Validators
partListVd = RegExpValidator(self.lineEdit_PartList,
QRegExp("[0-9- ]*"))
self.lineEdit_PartList.setValidator(partListVd)
# Connections
self.radioButtonYes.clicked.connect(self.slotPartition)
self.radioButtonNo.clicked.connect(self.slotPartition)
self.toolButton_PartInputDir.pressed.connect(
self.slotSearchPartInputDirectory)
self.comboBox_PartOutput.activated[str].connect(self.slotPartOut)
self.comboBox_PartType.activated[str].connect(self.slotPartType)
self.lineEdit_PartList.textChanged[str].connect(self.slotPartitionList)
self.spinBoxRankStep.valueChanged[int].connect(self.slotRankStep)
self.checkBox_IgnorePerio.clicked[bool].connect(self.slotIgnorePerio)
self.comboBox_IORead.activated[str].connect(self.slotBlockIOReadMethod)
self.comboBox_IOWrite.activated[str].connect(
self.slotBlockIOWriteMethod)
self.spinBoxIORankStep.valueChanged[int].connect(
self.slotBlockIORankStep)
self.spinBoxIOMinBlockSize.valueChanged[int].connect(
self.slotBlockIOMinSize)
self.tabWidget.currentChanged[int].connect(self.slotchanged)
# Widget initialization
self.partinput_path = self.mdl.getPartitionInputPath()
if self.partinput_path:
if not os.path.isdir(
os.path.join(self.case['case_path'], self.partinput_path)):
title = self.tr("WARNING")
msg = self.tr("Invalid path in %s!" % self.partinput_path)
QMessageBox.warning(self, title, msg)
self.radioButtonYes.setChecked(True)
self.radioButtonNo.setChecked(False)
def __init__(self, case):
"""FluidCharacteristicsModel Constuctor."""
self.case = case
self.node_models = self.case.xmlGetNode('thermophysical_models')
self.node_prop = self.case.xmlGetNode('physical_properties')
self.node_fluid = self.node_prop.xmlInitNode('fluid_properties')
self.node_comp = self.node_models.xmlInitNode('compressible_model', 'model')
self.node_gas = self.node_models.xmlInitNode('gas_combustion', 'model')
self.node_coal = self.node_models.xmlInitNode('solid_fuels', 'model')
# Base model needs density and molecular viscosity
self.lst = [('density', 'Rho'),('molecular_viscosity', 'Mu')]
self.node_density = self.setNewFluidProperty(self.node_fluid, \
'density')
self.node_viscosity = self.setNewFluidProperty(self.node_fluid, \
'molecular_viscosity')
self.node_lst = [self.node_density, self.node_viscosity]
self.node_heat = None
self.node_cond = None
self.node_vol_visc = None
self.node_dyn = None
# Get thermal scalar and model
thm = ThermalScalarModel(self.case)
tsn = thm.getThermalScalarName()
self.tsm = thm.getThermalScalarModel()
# If thermal model enabled, add thermal conductivity and specific heat
if self.tsm != "off":
self.lst.extend([('specific_heat', 'Cp'), \
('thermal_conductivity', 'Al')])
self.node_heat = self.setNewFluidProperty(self.node_fluid, \
'specific_heat')
self.node_cond = self.setNewFluidProperty(self.node_fluid, \
'thermal_conductivity')
self.node_lst.extend([self.node_heat, self.node_cond])
# Define volume viscosity for compressible model
if self.node_comp['model'] not in [None, "off"]:
self.lst.append(('volume_viscosity', 'Viscv0'))
self.node_vol_visc = self.setNewFluidProperty(self.node_fluid, \
'volume_viscosity')
self.node_lst.append(self.node_vol_visc)
# Define dynamic diffusion for reactive flow
elif self.node_coal['model'] not in [None, "off"] \
or self.node_gas['model'] not in [None, "off"]:
self.lst.append(('dynamic_diffusion', 'Diftl0'))
self.node_dyn = self.setNewFluidProperty(self.node_fluid, \
'dynamic_diffusion')
self.node_lst.append(self.node_dyn)
# Build scalars list
self.list_scalars = []
if self.tsm == "temperature_celsius":
self.list_scalars.append((tsn, self.tr("Thermal scalar: temperature (\xB0 C)")))
elif self.tsm == "temperature_kelvin":
self.list_scalars.append((tsn, self.tr("Thermal scalar: temperature (K)")))
elif self.tsm != "off":
self.list_scalars.append((tsn, self.tr("Thermal scalar")))
self.m_sca = DefineUserScalarsModel(self.case)
for s in self.m_sca.getUserScalarNameList():
self.list_scalars.append((s, self.tr("Additional scalar")))
# Look for thermo tables
import code_saturne.cs_config as cs_config
cfg = cs_config.config()
self.freesteam = 0
if cfg.libs['freesteam'].have != "no":
self.freesteam = 1
self.coolprop = 0
if cfg.libs['coolprop'].have != "no":
self.coolprop = 1
# Notebook
self.notebook = NotebookModel(self.case)
