def launchGUI(self, WorkSpace, aCase, sobjXML, Args):
"""
mw.dockWidgetBrowser is the Browser of the CFD MainView
"""
log.debug("launchGUI")
from code_saturne.cs_gui import process_cmd_line
from code_saturne.Base.MainView import MainView
from code_saturne.cs_package import package
if sobjXML == None:
Title = "unnamed"
else:
Title = sobjXML.GetName()
self.Workspace = WorkSpace
# Get current solver name
_solver_name = getCFDSolverName()
pkg = package(name=_solver_name)
case, splash = process_cmd_line(Args)
try:
mw = MainView(pkg, case, aCase)
except:
mess = "Error in Opening CFD GUI"
QMessageBox.warning(None, "Warning", mess, QMessageBox.Ok,
QMessageBox.NoButton)
return None
# Put the standard panel of the MainView inside a QDockWidget
# in the SALOME Desktop
aTitle = self.setWindowTitle_CFD(mw, aCase, Title)
dsk = sgPyQt.getDesktop()
#####
objectBrowserDockWindow = findObjectBrowserDockWindow()
self.mainWin = QMainWindow()
self.mainWin.setWindowTitle(aTitle)
self.mainWin.setCentralWidget(mw.centralwidget)
self.mainWin.addDockWidget(Qt.LeftDockWidgetArea, mw.dockWidgetBrowser)
#####
self.dockMainWin = QDockWidget(aTitle)
self.dockMainWin.setWidget(self.mainWin)
##
dsk.addDockWidget(Qt.LeftDockWidgetArea, self.dockMainWin)
self.dockMainWin.setVisible(True)
self.dockMainWin.show()
self.dockMainWin.raise_()
objectBrowserDockWindow.visibilityChanged["bool"].connect(
self.resizeObjectBrowserDock)
#Add Dock windows are managed by CFDGUI_Management class
aStudyCFD = aCase.GetFather()
aCaseCFD = aCase
xmlFileName = str(Title)
_c_CFDGUI.set_d_CfdCases(self.dockMainWin, mw, aStudyCFD, aCaseCFD,
xmlFileName, sobjXML)
dockMain = _c_CFDGUI.getDockWithCFDNames(aStudyCFD.GetName(),
aCaseCFD.GetName(),
xmlFileName)
if dockMain != None:
dockMain.visibilityChanged["bool"].connect(
self.resizeMainWindowDock)
updateObjectBrowser()
return mw
def onNeptuneHelpKernel(self):
from code_saturne.cs_package import package
argv_info = ['--guide', 'theory']
cs_info.main(argv_info, package(name='neptune_cfd'))
def onNeptuneHelpDoxygen(self):
from code_saturne.cs_package import package
from neptune_cfd.nc_package import package
argv_info = ['--guide', 'Doxygen']
cs_info.main(argv_info, package(name='neptune_cfd'))
def onSaturneHelpRefcard(self):
from code_saturne.cs_package import package
argv_info = ['--guide', 'refcard']
cs_info.main(argv_info, package())
def onSaturneHelpDoxygen(self):
from code_saturne.cs_package import package
argv_info = ['--guide', 'Doxygen']
cs_info.main(argv_info, package())
def onSaturneHelpManual(self):
from code_saturne.cs_package import package
argv_info = ['--guide', 'user']
cs_info.main(argv_info, package())
def onSaturneHelpKernel(self):
from code_saturne.cs_package import package
argv_info = ['--guide', 'theory']
cs_info.main(argv_info, package())
return 1
cmd = [pkg.get_io_dump(), '--diff']
cmd += argv
# Set environment modules if present
cs_exec_environment.set_modules(pkg)
cs_exec_environment.source_rcfile(pkg)
# Run executable
return cs_exec_environment.run_command(cmd)
#-------------------------------------------------------------------------------
if __name__ == '__main__':
# Run package
from code_saturne.cs_package import package
pkg = package()
retval = main(sys.argv[1:], pkg)
sys.exit(retval)
#-------------------------------------------------------------------------------
# End
#-------------------------------------------------------------------------------
def run(argv=[], pkg=None, run_args=None, submit_args=None):
"""
Run calculation;
returns return code, run id, and results directory path when created.
"""
if not pkg:
from code_saturne.cs_package import package
pkg = package()
if run_args == None:
options = parse_cmd_line(argv, pkg)
else:
options = run_args
i_c = cs_run_conf.get_install_config_info(pkg)
if options.resource_name != None:
c['resource_name'] = options.resource_name.lower()
r_c, s_c, run_conf = process_options(options, pkg)
if not r_c['casedir'] and not r_c['staging_dir']:
return 1, None, None
# Read run configuration
read_run_config_file(i_c, r_c, s_c, pkg, run_conf=run_conf)
# Determine compute stages
update_run_steps(s_c, None, final=True)
stages = {'prepare_data': s_c['stage'],
'initialize': s_c['initialize'],
'run_solver': s_c['compute'],
'save_results': s_c['finalize']}
# Use alternate compute (back-end) package if defined
pkg_compute = None
if not r_c['compute_build']:
if i_c['compute_builds']:
r_c['compute_build'] = i_c['compute_builds'][0]
if r_c['compute_build']:
pkg_compute = pkg.get_alternate_version(r_c['compute_build'])
# Specific case for coupling
if r_c['coupled_domains'] != []:
from code_saturne import cs_case_coupling
domains = r_c['coupled_domains']
verbose = True
if r_c['suggest_id']:
verbose = False
c = cs_case_coupling.coupling(pkg,
domains,
r_c['casedir'],
r_c['dest_dir'],
staging_dir=r_c['staging_dir'],
verbose=verbose,
package_compute=pkg_compute)
else:
# Values in case and associated domain set from parameters
d = cs_case_domain.domain(pkg,
package_compute=pkg_compute,
param=r_c['param'])
# Now handle case for the corresponding calculation domain(s).
c = cs_case.case(pkg,
package_compute=pkg_compute,
case_dir=r_c['casedir'],
dest_dir=r_c['dest_dir'],
staging_dir=r_c['staging_dir'],
domains=d)
# Determine run id if not forced
if not r_c['run_id']:
r_c['run_id'] = c.suggest_id(r_c['id_prefix'], r_c['id_suffix'])
if r_c['suggest_id']:
print(r_c['run_id'])
return 0, r_c['run_id'], None
if submit_args != None:
submit_stages = {'prepare_data': False}
for s in ('initialize', 'run_solver', 'save_results'):
submit_stages[s] = stages[s]
stages[s] = False
c.run_prologue = r_c['run_prologue']
c.run_epilogue = r_c['run_epilogue']
c.compute_prologue = r_c['compute_prologue']
c.compute_epilogue = r_c['compute_epilogue']
# Now run case
retval = c.run(n_procs=r_c['n_procs'],
n_threads=r_c['n_threads'],
time_limit=r_c['time_limit'],
run_id=r_c['run_id'],
force_id=r_c['force_id'],
stages=stages)
if submit_args != None:
resource_name = cs_run_conf.get_resource_name(i_c)
run_cfg_path = os.path.join(c.result_dir, 'run.cfg')
if len(submit_args) > 1:
job_parameters = cs_exec_environment.assemble_args(submit_args)
r_c['job_parameters'] = job_parameters
generate_run_config_file(run_cfg_path, resource_name,
r_c, submit_stages, pkg)
return retval, c.result_dir, r_c
def onNeptuneHelpDoxygen(self):
from neptune_cfd.nc_package import package
argv_info = ['--guide', 'Doxygen']
cs_info.main(argv_info, package())
def onNeptuneHelpKernel(self):
from neptune_cfd.nc_package import package
argv_info = ['--guide', 'theory']
cs_info.main(argv_info, package())
def onNeptuneHelpTutorial(self):
from neptune_cfd.nc_package import package
argv_info = ['--guide', 'tutorial']
cs_info.main(argv_info, package())
def onNeptuneHelpManual(self):
from neptune_cfd.nc_package import package
argv_info = ['--guide', 'user']
cs_info.main(argv_info, package())
def build_template(self, package=None, study_name=None, case_name=None,
ignore_batch=False):
"""
Build batch file template
"""
import os, stat
from code_saturne.cs_exec_environment import append_shell_shebang, \
append_script_comment, prepend_path_command
if not package:
from code_saturne import cs_package
package = cs_package.package()
self.lines = []
append_shell_shebang(self.lines)
# Add batch system info if necessary
batch_template = None
config = configparser.ConfigParser()
config.read(package.get_configfiles())
if not ignore_batch and config.has_option('install', 'batch'):
batch_template = config.get('install', 'batch')
if not os.path.isabs(batch_template):
batch_template = os.path.join(package.get_batchdir(),
'batch.' + batch_template)
fdt = open(batch_template, 'r')
import re, string
kwd1 = re.compile('nameandcase')
# Determine or build default names if required
if not case_name or not study_name:
topdir, scriptdir = os.path.split(os.path.split(self.path)[0])
if scriptdir == 'SCRIPTS':
studydir, casedir = os.path.split(topdir)
studydir = os.path.split(studydir)[1]
else:
casedir = ''
studydir = scriptdir
if not case_name:
if casedir:
case_name = casedir
else:
case_name = ''
if not study_name:
study_name = studydir
studycasename = study_name.lower() + case_name.lower()
# For some systems, names are limited to 15 caracters
studycasename = studycasename[:15]
for line in fdt:
line = line.rstrip()
line = re.sub(kwd1, studycasename, line)
self.lines.append(line)
fdt.close()
# Add command to execute.
append_script_comment(self.lines, 'Ensure the correct command is found:')
self.lines.append(prepend_path_command('PATH',
package.get_dir("bindir")))
self.lines.append('')
append_script_comment(self.lines, 'Run command:\n')
# On Linux systems, add a backslash to prevent aliases
if sys.platform.startswith('win'):
run_cmd = ''
else:
run_cmd = '\\'
run_cmd += package.name + ' run'
self.run_cmd_line_id = len(self.lines)
self.lines.append(run_cmd)
self.save()
st = os.stat(self.path)
mode = st[stat.ST_MODE]
os.chmod(self.path, mode | stat.S_IEXEC)
