def setUp(self):
"""
This method is executed before all "check" methods.
"""
from code_saturne.model.XMLengine import Case
from code_saturne.model.XMLinitialize import XMLinit
self.case = Case()
XMLinit(self.case).initialize()
def setUp(self):
"""This method is executed before all "check" methods."""
from code_saturne.model.XMLengine import Case, XMLDocument
from code_saturne.model.XMLinitialize import XMLinit
GuiParam.lang = 'en'
self.case = Case(None)
XMLinit(self.case).initialize()
self.doc = XMLDocument()
def __setCsCase__(self):
"""
Initialize the cs_case structure according to the user provided
data
"""
from code_saturne.model.XMLengine import Case
paramfile = self.cfg.get('study_parameters', 'xmlfile')
fp = os.path.join(self.study_path, self.case_id, 'DATA', paramfile)
self.case = Case(package=self.pkg, file_name=fp)
self.case['xmlfile'] = fp
self.case.xmlCleanAllBlank(self.case.xmlRootNode())
if self.case['package'].name == 'code_saturne':
from code_saturne.model.XMLinitialize import XMLinit
else:
from code_saturne.model.XMLinitializeNeptune import XMLinitNeptune as XMLinit
XMLinit(self.case).initialize()
def load_case_setup_from_xml(xml_file, pkg=None):
"""
Load case from XML file.
@param xml_file: path to xml file
"""
pkg = None
if not pkg:
from code_saturne.base.cs_package import package
pkg = package()
from code_saturne.model.XMLengine import Case
try:
case_setup = Case(package=pkg, file_name=xml_file)
case_setup['xmlfile'] = xml_file
except:
print("Error while reading parameters files.")
print("This file is not in accordance with XML specifications.")
sys.exit(1)
module_name = case_setup.module_name()
if module_name == 'code_saturne':
from code_saturne.model.XMLinitialize import XMLinit
elif module_name == 'neptune_cfd':
from code_saturne.model.XMLinitializeNeptune import XMLinitNeptune as XMLinit
# internal functions of code_saturne to properly initialize the
# xml structure
case_setup.xmlCleanAllBlank(case_setup.xmlRootNode())
XMLinit(case_setup).initialize()
return case_setup
def setUp(self):
"""
This method is executed before all 'check' methods.
"""
from code_saturne.model.XMLengine import Case
from code_saturne.model.XMLinitialize import XMLinit
from code_saturne.model.Common import GuiParam
GuiParam.lang = 'en'
self.case = Case(None)
XMLinit(self.case).initialize()
domain = SolutionDomainModel(self.case)
domain.addMesh('mail1.des', 'des')
domain.addMesh('mail2.des', 'des')
domain.addMesh('mail3.des', 'des')
self.case['xmlfile'] = 'NEW.xml'
def setUp(self):
"""
This method is executed before all 'check' methods.
"""
from code_saturne.model.XMLengine import Case
from code_saturne.model.XMLinitialize import XMLinit
from code_saturne.model.Common import GuiParam
GuiParam.lang = 'en'
self.case = Case(None)
XMLinit(self.case).initialize()
self.case['scripts_path'] = os.getcwd()
self.case['runcase'] = cs_runcase.runcase('runcase')
lance_PBS = '# test \n'\
'#\n'\
'# CARTES BATCH POUR CLUSTERS sous PBS\n'\
'#\n'\
'#PBS -l nodes=16:ppn=1,walltime=34:77:22\n'\
'#PBS -j eo -N super_toto\n'
lance_LSF = '# test \n'\
'#\n'\
'# CARTES BATCH POUR LE CCRT (Platine sous LSF)\n'\
'#\n'\
'#BSUB -n 2\n'\
'#BSUB -c 00:05\n'\
'#BSUB -o super_tataco.%J\n'\
'#BSUB -e super_tatace.%J\n'\
'#BSUB -J super_truc\n'
self.f = open('lance_PBS', 'w')
self.f.write(lance_PBS)
self.f.close()
self.f = open('lance_LSF', 'w')
self.f.write(lance_LSF)
self.f.close()
class cfd_openturns_study:
"""
Class used for an OpenTurns study within SALOME_CFD
Public methods:
- init
- run
- study2code
- code2study
"""
# ------------------------------------------------------------------------------
# PUBLIC FUNCTIONS
# ------------------------------------------------------------------------------
# ---------------------------------------
def __init__(self, study_path, study_cfg, vars_dico):
'''
Classs constructor
'''
# --------------------------
# Init from user values
self.study_path = study_path
os.chdir(study_path)
self.cfg_name = study_cfg
cfg_path = os.path.join(study_path, study_cfg)
self.cfg_path = cfg_path
print("-----------------------------------")
print(cfg_path)
print("-----------------------------------")
self.cfg = configparser.ConfigParser()
self.cfg.read(cfg_path)
self.vars_dico = vars_dico
self.cs_launcher = None
self.ref_case = self.cfg.get('study_parameters', 'ref_case')
if self.cfg.get('host_parameters', 'host_name') == 'localhost':
self.run_type = 'local'
else:
self.run_type = 'distant'
# --------------------------
self.__setPackage__()
self.__setCaseId__()
# ---------------------------------------
# ---------------------------------------
def load_launcher(self, case_dir):
new_launcher = None
if self.run_type == 'local':
from CFDSTUDYOTURNS_LocalLauncher import cfd_openturns_local_launcher
new_launcher = cfd_openturns_local_launcher(case_dir = case_dir,
params_cfg = self.cfg,
package = self.pkg)
elif self.run_type == 'distant':
from CFDSTUDYOTURNS_DistantLauncher import CFDSTUDY_DistantLauncher
new_launcher = CFDSTUDY_DistantLauncher(case_dir = case_dir,
params_cfg = self.cfg,
package = self.pkg)
self.cs_launcher = new_launcher
# ---------------------------------------
# ---------------------------------------
def study2code(self):
'''
A function which takes into account the variables values given by
OpenTurns and creating a Code_Saturne case thanks to it.
'''
from glob import glob
case_dir = os.path.join(self.study_path, self.case_id)
case_resu_dir = os.path.join(case_dir, "RESU")
# Check if the case directory allready exists.
# if it exists, check if a case has allready been run
if os.path.isdir(case_dir):
dirs = [e for e in filter(os.path.isdir, glob(case_resu_dir + "/*"))]
self.__setCsCase__()
self.case['case_path'] = case_dir
self.load_launcher(case_dir)
if self.run_type == 'distant' and len(dirs) > 0:
dirs.sort(key=lambda x: os.path.getmtime(x))
resu_dir = dirs[-1]
self.cs_launcher.run_id = os.path.split(resu_dir)[-1]
self.cs_launcher.reload_job(resu_dir)
else:
self.__createCase__()
self.load_launcher(case_dir)
# os.chdir(case_resu_dir)
# ---------------------------------------
# ---------------------------------------
def run(self):
'''
This method launches a Code_Saturne computation based on the
values provided by OpenTurns
'''
self.cs_launcher.launch(force_submit=False)
if self.run_type == 'distant':
self.cs_launcher.sync_results()
while True:
if self.cs_launcher.need_restart():
old_run = self.cs_launcher.run_id
rst_dir = os.path.join('RESU', old_run)
self.__setRestartPath__(rst_dir)
self.cs_launcher.__setRunId__()
self.cs_launcher.launch(force_submit=True)
if self.cs_launcher.job_failed:
break
else:
break
self.cs_launcher.sync_results()
# ---------------------------------------
# ---------------------------------------
def code2study(self, n_values=1):
"""
Opens the results file specified by the user.
Returns a tuple of all the required values (needed by OpenTurns)
"""
resfile = "cs_uncertain_output.dat"
rspth = os.path.join(self.study_path,
self.case_id,
'RESU',
self.cs_launcher.run_id,
resfile)
results = ()
if os.path.exists(rspth):
r = open(rspth, 'r').readlines()
d = r[-1].split(',')
for ed in d:
results += (float(ed),)
if len(results) == 0:
results = (float('nan'),)*n_values
return results;
# ---------------------------------------
# ------------------------------------------------------------------------------
#
# ------------------------------------------------------------------------------
# INTERNAL UTILITY FUNCTIONS
# ------------------------------------------------------------------------------
# ---------------------------------------
def __setCaseId__(self):
"""
Setting the case id based on the variables names and values
"""
self.case_id = ''
items = []
for key in self.vars_dico.keys():
items.append(str(key[:4])+'_'+str(self.vars_dico[key]))
self.case_id = "_".join(items)
# ---------------------------------------
# ---------------------------------------
def __setPackage__(self):
"""
Setting the package according to the requested code by the user
"""
pkg_name = self.cfg.get('study_parameters', 'code_name')
if pkg_name == 'code_saturne':
from code_saturne.cs_package import package
elif pkg_name == 'neptune_cfd':
from neptune_cfd.nc_package import package
else:
raise Exception("Uknown package: "+pkg_name)
self.pkg = package()
# ---------------------------------------
# ---------------------------------------
def __createCase__(self):
"""
Creating the case for a given evaluation based on the user defined
reference case
"""
from code_saturne.model.NotebookModel import NotebookModel
# Creating the case from the ref case
from code_saturne.cs_script import master_script
case_create_args = ['create',
'-c',
os.path.join(self.study_path, self.case_id),
'--copy-from',
os.path.join(self.study_path, self.ref_case) ]
ms = master_script(case_create_args, self.pkg)
retcode = ms.execute()
self.__setCsCase__()
self.__setOtVarsVals__()
# ---------------------------------------
# ---------------------------------------
def __setCsCase__(self):
"""
Initialize the cs_case structure according to the user provided
data
"""
from code_saturne.model.XMLengine import Case
paramfile = self.cfg.get('study_parameters', 'xmlfile')
fp = os.path.join(self.study_path, self.case_id, 'DATA', paramfile)
self.case = Case(package=self.pkg, file_name=fp)
self.case['xmlfile'] = fp
self.case.xmlCleanAllBlank(self.case.xmlRootNode())
if self.case['package'].name == 'code_saturne':
from code_saturne.model.XMLinitialize import XMLinit
else:
from code_saturne.model.XMLinitializeNeptune import XMLinitNeptune as XMLinit
XMLinit(self.case).initialize()
# ---------------------------------------
# ---------------------------------------
def __setOtVarsVals__(self):
"""
This method translates the values provided by OpenTURNS into the
code xml input file
"""
# Update xml file
from code_saturne.model.NotebookModel import NotebookModel
nb = NotebookModel(self.case)
for key in self.vars_dico.keys():
if key in nb.getVarNameList():
nb.setVariableValue(val=str(self.vars_dico[key]),
var=key)
self.case.xmlSaveDocument()
# ---------------------------------------
# ---------------------------------------
def __setRestartPath__(self, restart_path):
"""
This method sets the restart path in the code xml input file
"""
from code_saturne.model.StartRestartModel import StartRestartModel
rs = StartRestartModel(self.case)
rp = os.path.join(restart_path, 'checkpoint')
rs.setRestartPath(rp)
rs.setRestartWithAuxiliaryStatus('on')
self.case.xmlSaveDocument()
