"""Transform single values or lists to a whitespace-separated string"""

s = ''

if type(arg) == tuple or type(arg) == list:

for e in arg:

s += ' ' + str(e)

return s[1:]

else:

"""

if not os.path.isdir(path):

os.mkdir(path)

else:

l = os.listdir(path)

for f in l:

"""Base class for exception handling."""

def __init__(self, *args):

self.args = args

def __str__(self):

if len(self.args) == 1:

return str(self.args[0])

else:

"""

#---------------------------------------------------------------------------

def __init__(self,

package, # main package

code_name = '<undefined>', # code name

name = None, # domain name

n_procs_weight = None, # recommended number of processes

n_procs_min = 1, # min. number of processes

n_procs_max = None): # max. number of processes

# Package specific information

self.package = package

self.code_name = code_name

# User functions

self.user = {}

# Names, directories, and files in case structure

self.case_dir = None

self.case_root_dir = None

self.name = name # used for multiple domains only

self.data_dir = None

self.result_dir = None

self.src_dir = None

# Notebook and parametric definitions and additional user arguments

self.notebook = None

self.parametric_args = None

self.kw_args = None

# Working directory and executable

self.exec_dir = None

self.solver_path = None

# Is the case already staged ?

self.data_is_staged = False

# Execution options

self.n_procs = n_procs_weight

if not n_procs_min:

n_procs_min = 1

self.n_procs_min = max(1, n_procs_min)

self.n_procs_max = n_procs_max

if self.n_procs is None:

self.n_procs = 1

self.n_procs = max(self.n_procs, self.n_procs_min)

if self.n_procs_max != None:

self.n_procs = min(self.n_procs, self.n_procs_max)

# Error reporting

self.error = ''

self.error_long = ''

#---------------------------------------------------------------------------

def __input_path_abs_dir__(self, path):

"""

prefix, base = os.path.split(path)

while prefix != '':

if base in ('RESU', 'RESU_COUPLING', 'MESH'):

break

prefix, base = os.path.split(prefix)

if base in ('RESU', 'RESU_COUPLING'):

if self.dest_root_dir:

r_path = os.path.join(self.dest_root_dir, path)

if os.path.exists(r_path):

return r_path

c_path = os.path.join(self.case_root_dir, path)

if os.path.exists(c_path):

return c_path

# If path does not exist, assume it will be created

# later, in chich case we use dest_root_dir

return r_path

else:

return os.path.join(self.case_root_dir, path)

elif base == 'MESH':

return os.path.join(self.case_root_dir, path)

return os.path.join(self.case_dir, path)

#---------------------------------------------------------------------------

def set_case_dir(self, case_dir, staging_dir = None):

# Names, directories, and files in case structure

self.case_dir = case_dir

self.case_root_dir = case_dir

self.dest_root_dir = None

if self.name != None:

self.case_dir = os.path.join(self.case_dir, self.name)

self.case_root_dir = os.path.join(case_dir, self.name)

self.data_dir = os.path.join(self.case_dir, 'DATA')

self.result_dir = os.path.join(self.case_dir, 'RESU')

self.src_dir = os.path.join(self.case_dir, 'SRC')

# If computation is already staged, avoid reading data in upstream

# case directories, as it may have changed since staging.

if staging_dir:

self.case_dir = staging_dir

if self.name != None:

self.case_dir = os.path.join(self.case_dir, self.name)

self.data_dir = self.case_dir

self.src_dir = None

#---------------------------------------------------------------------------

def set_exec_dir(self, exec_dir):

if os.path.isabs(exec_dir):

self.exec_dir = exec_dir

else:

self.exec_dir = os.path.join(self.case_dir, 'RESU', exec_dir)

if self.name != None:

self.exec_dir = os.path.join(self.exec_dir, self.name)

if not os.path.isdir(self.exec_dir):

os.makedirs(self.exec_dir)

#---------------------------------------------------------------------------

def set_result_dir(self, name, given_dir = None, dest_root_dir=None):

"""

if given_dir is None:

self.result_dir = os.path.join(self.case_dir, 'RESU', name)

else:

self.result_dir = given_dir

if self.name != None:

self.result_dir = os.path.join(self.result_dir, self.name)

self.dest_root_dir = dest_root_dir

if not os.path.isdir(self.result_dir):

os.makedirs(self.result_dir)

#---------------------------------------------------------------------------

def copy_data(self):

"""

return

#---------------------------------------------------------------------------

def init_staged_data(self):

"""

self.data_is_staged = True

return

#---------------------------------------------------------------------------

def prepare_data(self):

"""

#---------------------------------------------------------------------------

def copy_result(self, name, purge=False):

"""

# Determine absolute source and destination names

if os.path.isabs(name):

src = name

dest = os.path.join(self.result_dir, os.path.basename(name))

else:

src = os.path.join(self.exec_dir, name)

dest = os.path.join(self.result_dir, name)

# If source and destination are identical, return

if src == dest:

return

# Copy single file

if os.path.isfile(src):

shutil.copy2(src, dest)

if purge:

os.remove(src)

# Copy single directory (possibly recursive)

# Unlike os.path.copytree, the destination directory

# may already exist.

elif os.path.isdir(src):

if not os.path.isdir(dest):

os.mkdir(dest)

l = os.listdir(src)

for f in l:

f_src = os.path.join(src, f)

f_dest = os.path.join(dest, f)

if os.path.isfile(f_src):

shutil.copy2(f_src, f_dest)

elif os.path.isdir(f_src):

self.copy_result(f_src, f_dest)

if purge:

if os.path.islink(src):

os.remove(f)

else:

shutil.rmtree(src)

#---------------------------------------------------------------------------

def purge_result(self, name):

"""

# Determine absolute name

if os.path.isabs(name):

f = name

else:

f = os.path.join(self.exec_dir, name)

# Remove file or directory

if os.path.isfile(f) or os.path.islink(f):

os.remove(f)

elif os.path.isdir(f):

shutil.rmtree(f)

#---------------------------------------------------------------------------

def get_n_procs(self):

"""

return [self.n_procs, self.n_procs_min, self.n_procs_max]

#---------------------------------------------------------------------------

def set_n_procs(self, n_procs):

"""

self.n_procs = n_procs

#---------------------------------------------------------------------------

def solver_command(self, need_abs_path=False):

"""

exec_path = self.solver_path

if not os.path.isabs(exec_path) and need_abs_path:

exec_path = os.path.join(self.exec_dir,

os.path.basename(exec_path))

return enquote_arg(self.exec_dir), enquote_arg(exec_path), ''

#---------------------------------------------------------------------------

def summary_info(self, s):

"""

if self.name:

name = self.name

exec_dir = os.path.join(self.exec_dir, name)

result_dir = os.path.join(self.result_dir, name)

else:

name = os.path.basename(self.case_dir)

exec_dir = self.exec_dir

result_dir = self.result_dir

s.write(' Case : ' + name + '\n')

s.write(' directory : ' + self.case_dir + '\n')

s.write(' results dir. : ' + self.result_dir + '\n')

if exec_dir != result_dir:

"""Handle running case."""

#---------------------------------------------------------------------------

def __init__(self,

package, # main package

package_compute = None, # package for compute environment

name = None, # domain name

n_procs_weight = None, # recommended number of processes

n_procs_min = None, # min. number of processes

n_procs_max = None, # max. number of processes

logging_args = None, # command-line options for logging

param = None, # XML parameters file

prefix = None, # installation prefix

adaptation = None): # HOMARD adaptation script

base_domain.__init__(self,

package,

'code_saturne',

name,

n_procs_weight,

n_procs_min,

n_procs_max)

# Compute package if different from front-end

if package_compute:

self.package_compute = package_compute

else:

self.package_compute = self.package

# Directories, and files in case structure

self.restart_input = None

self.restart_mesh_input = None

self.mesh_input = None

self.partition_input = None

# Default executable

self.solver_path = os.path.join(self.package_compute.get_dir("pkglibexecdir"),

self.package.solver)

# Preprocessor options

self.mesh_dir = None

self.meshes = None

# Solver options

self.preprocess_on_restart = False

self.exec_solver = True

if param:

self.param = os.path.basename(param)

else:

self.param = None

self.logging_args = logging_args

self.solver_args = None

# Additional data

self.prefix = prefix

self.compile_cflags = None

self.compile_cxxflags = None

self.compile_fcflags = None

self.compile_nvccflags = None

self.compile_libs = None

# Adaptation using HOMARD

self.adaptation = adaptation

# MEG expression generator

self.mci = None

#---------------------------------------------------------------------------

def __set_case_parameters__(self):

update_xml = (self.data_is_staged == False)

# We may now import user python script functions if present.

self.user_locals = None

user_scripts = os.path.join(self.exec_dir, 'cs_user_scripts.py')

if os.path.isfile(user_scripts):

try:

exec(compile(open(user_scripts).read(), user_scripts, 'exec'),

locals(),

locals())

self.user_locals = locals()

except Exception:

execfile(user_scripts, locals(), locals())

self.user_locals = locals()

# We may now parse the optional XML parameter file

# now that its path may be built and checked.

setup_path = os.path.join(self.exec_dir, "setup.xml")

if os.path.isfile(setup_path):

# Ensure XML file is up to date as a precaution,

# and filter it in case of parametric or notebook arguments.

case = self.__xml_case_initialize__(setup_path, apply_filters=True)

case['xmlfile'] = setup_path

P = cs_xml_reader.Parser(doc=case.doc)

params = P.getParams()

for k in list(params.keys()):

self.__dict__[k] = params[k]

case.xmlSaveDocument()

if params['xml_root_name'] == 'NEPTUNE_CFD_GUI':

solver_dir = self.package_compute.get_dir("pkglibexecdir")

solver_name = "nc_solver" + self.package_compute.config.exeext

self.solver_path = os.path.join(solver_dir, solver_name)

self.code_name = 'neptune_cfd'

self.param = "setup.xml"

else:

msg = ('Remark:\n'

' No setup.xml file was provided in the DATA folder.\n'

' Default settings will be used.\n')

print(msg, file = sys.stderr)

# Now override or complete data from the XML file.

if self.user_locals:

m = 'define_domain_parameters'

if m in self.user_locals.keys():

eval(m + '(self)', globals(), self.user_locals)

del self.user_locals[m]

# Finally, ensure some fields are of the required types

if type(self.meshes) != list:

self.meshes = [self.meshes,]

#---------------------------------------------------------------------------

def __set_auto_restart__(self):

"""

self.restart_input = None

from code_saturne.base.cs_exec_environment import get_command_output

results_dir = os.path.abspath(os.path.join(self.result_dir, '..'))

results = os.listdir(results_dir)

results.sort(reverse=True)

for r in results:

m = os.path.join(results_dir, r, 'checkpoint', 'main.csc')

if not os.path.isfile(m):

m = os.path.join(results_dir, r, 'checkpoint', 'main')

if os.path.isfile(m):

try:

cmd = self.package.get_io_dump()

cmd += ' --location 0 ' + m

res = get_command_output(cmd)

except Exception:

print('checkpoint of result: ' + r + ' does not seem usable')

continue

self.restart_input = os.path.join(results_dir, r, 'checkpoint')

break

return

#---------------------------------------------------------------------------

def __xml_case_initialize__(self, path, apply_filters=False):

"""

from code_saturne.model.XMLengine import Case

from code_saturne.model.SolutionDomainModel import getRunType

case = Case(package=self.package, file_name=path)

case['xmlfile'] = path

case.xmlCleanAllBlank(case.xmlRootNode())

preprocess_only = (getRunType(case) != 'standard')

module_name = case.module_name()

if module_name == 'code_saturne':

from code_saturne.model.XMLinitialize import XMLinit

XMLinit(case).initialize(preprocess_only)

elif module_name == 'neptune_cfd':

from code_saturne.model.XMLinitializeNeptune import XMLinitNeptune

XMLinitNeptune(case).initialize(preprocess_only)

if not apply_filters:

return case

# Apply changes defined through notebook or parametric options.

if self.parametric_args:

from code_saturne.base import cs_parametric_setup

cs_parametric_setup.update_case_setup(case, self.parametric_args,

pkg=self.package)

if self.notebook:

from code_saturne.model.NotebookModel import NotebookModel

notebookModel = NotebookModel(case)

nbk_vars = notebookModel.getVarNameList()

n_warnings = 0

for k in self.notebook.keys():

if k in nbk_vars:

vs = self.notebook[k]

v = None

try:

v = float(vs)

except Exception:

fmt = ("Warning: notebook variable '{0}'='{1}'"

" is not a real number.")

msg = fmt.format(k, vs)

print(msg, file = sys.stderr)

n_warnings += 1

if v != None:

notebookModel.setVariableValue(val=v, var=k)

else:

fmt = ('Warning: {0} is not a known notebook variable.')

msg = fmt.format(k)

print(msg, file = sys.stderr)

n_warnings += 1

if n_warnings > 0:

print(file = sys.stderr)

return case

#---------------------------------------------------------------------------

def for_domain_str(self):

if self.name is None:

return ''

else:

return 'for domain ' + str(self.name)

#---------------------------------------------------------------------------

def read_parameter_file(self, param):

"""

if param is None:

if os.path.isfile(os.path.join(self.data_dir, 'setup.xml')):

param = 'setup.xml'

if param != None:

version_str = '2.0'

P = cs_xml_reader.Parser(os.path.join(self.data_dir, param),

version_str = version_str)

params = P.getParams()

for k in list(params.keys()):

self.__dict__[k] = params[k]

self.param = param

#---------------------------------------------------------------------------

def copy_data(self):

"""

err_str = ""

# Create the src folder if there are files to compile in source path

src_files = []

if self.src_dir != None:

if os.path.exists(self.src_dir):

src_files = cs_compile.files_to_compile(self.src_dir)

if len(src_files) > 0:

exec_src = os.path.join(self.exec_dir, 'src')

make_clean_dir(exec_src)

# Add header files to list so as not to forget to copy them

dir_files = os.listdir(self.src_dir)

src_files = src_files + ( fnmatch.filter(dir_files, '*.h')

+ fnmatch.filter(dir_files, '*.hxx')

+ fnmatch.filter(dir_files, '*.hpp'))

# Copy source files to execution directory

for f in src_files:

src_file = os.path.join(self.src_dir, f)

dest_file = os.path.join(exec_src, f)

shutil.copy2(src_file, dest_file)

# Copy data files

dir_files = []

if self.data_dir != self.exec_dir:

dir_files = os.listdir(self.data_dir)

if self.package.name in dir_files:

dir_files.remove(self.package.name)

for f in dir_files:

src = os.path.join(self.data_dir, f)

if os.path.isfile(src):

shutil.copy2(src, os.path.join(self.exec_dir, f))

# Fixed parameter name

setup_path = os.path.join(self.exec_dir, "setup.xml")

if self.param != None:

param_base = os.path.basename(self.param)

if param_base != "setup.xml":

src_path = os.path.join(self.exec_dir, param_base)

if os.path.isfile(setup_path):

self.purge_result(setup_path) # in case of previous run here

fmt = ('Warning:\n'

' Both {0} and {1} exist in\n'

' {2}.\n'

' {0} will be used for the computation.\n'

' Be aware that to follow best practices '

'only one of the two should be present.\n\n')

msg = fmt.format(os.path.basename(self.param),

os.path.basename(setup_path),

self.data_dir)

print(msg, file = sys.stderr)

try:

if os.path.islink(setup_path):

os.remove(setup_path)

os.symlink(self.param, setup_path)

except Exception:

shutil.copy2(src_path, setup_path)

# Now set parameters

self.__set_case_parameters__()

#---------------------------------------------------------------------------

def init_staged_data(self):

"""

self.data_is_staged = True

# Now set parameters

self.__set_case_parameters__()

# Ensure correct executable is used.

exec_src = os.path.join(self.exec_dir, 'src')

if os.path.isdir(exec_src):

if len(cs_compile.files_to_compile(exec_src)) > 0:

solver_name = os.path.basename(self.solver_path)

self.solver_path = os.path.join('.', solver_name)

# Additional precaution (in case source files were removed)

solver = os.path.basename(self.solver_path)

if os.path.isfile(os.path.join(self.exec_dir, solver)):

self.solver_path = os.path.join('.', solver)

#---------------------------------------------------------------------------

def symlink(self, target, link=None, check_type=None):

"""

if target is None and link is None:

return

elif target is None:

err_str = 'No target for link: ' + link

raise RunCaseError(err_str)

elif link is None:

if self.exec_dir != None:

link = os.path.join(self.exec_dir,

os.path.basename(target))

else:

err_str = 'No path name given for link to: ' + target

raise RunCaseError(err_str)

if not os.path.exists(target):

if check_type != 'allow_future':

err_str = 'File: ' + target + ' does not exist.'

raise RunCaseError(err_str)

elif check_type == 'file':

if not os.path.isfile(target):

err_str = target + ' is not a regular file.'

raise RunCaseError(err_str)

elif check_type == 'dir':

if not os.path.isdir(target):

err_str = target + ' is not a directory.'

raise RunCaseError(err_str)

try:

os.symlink(target, link)

except AttributeError:

if not os.path.isdir(target):

shutil.copy2(target, link)

else:

if os.path.isdir(link):

shutil.rmtree(link)

shutil.copytree(target, link)

#---------------------------------------------------------------------------

def needs_compile(self):

"""

# Check if there are files to compile in source path

needs_comp = False

exec_src = os.path.join(self.exec_dir, 'src')

if os.path.isdir(exec_src):

src_files = cs_compile.files_to_compile(exec_src)

if self.exec_solver and len(src_files) > 0:

needs_comp = True

setup_path = os.path.join(self.exec_dir, "setup.xml")

if os.path.isfile(setup_path):

fp = os.path.join(self.exec_dir, self.param)

case = self.__xml_case_initialize__(fp)

# Do not call case.xmlSaveDocument() to avoid side effects in case

# directory; is not required as meg_to_c_interpreter works from

# case in memory

module_name = case.module_name()

self.mci = meg_to_c_interpreter(case,

module_name=module_name,

wdir = os.path.join(self.exec_dir, 'src'))

if self.mci.has_meg_code():

needs_comp = True

else:

self.mci = None

return needs_comp

#---------------------------------------------------------------------------

def compile_and_link(self):

"""

src_files = []

# Check if there are files to compile in source path

# or if MEG functions need to be generated

exec_src = os.path.join(self.exec_dir, 'src')

if os.path.isdir(exec_src):

src_files = cs_compile.files_to_compile(exec_src)

if len(src_files) > 0 or self.mci != None:

# Create the src folder if not done yet

if not os.path.isdir(exec_src):

os.mkdir(exec_src)

if len(src_files) > 0:

# Add header files to list so as not to forget to copy them

dir_files = os.listdir(exec_src)

src_files = src_files + ( fnmatch.filter(dir_files, '*.h')

+ fnmatch.filter(dir_files, '*.hxx')

+ fnmatch.filter(dir_files, '*.hpp'))

if self.mci != None:

mci_state = self.mci.save_all_functions()

if mci_state['state'] == -1:

self.error = 'compile or link'

self.error_long = ' missing mathematical expressions:\n\n'

for i, eme in enumerate(mci_state['exps']):

self.error_long += " (%d/%d) %s is not provided for %s for zone %s\n" % (i+1, mci_state['nexps'], eme['func'], eme['var'], eme['zone'])

return

elif mci_state['state'] == 2:

self.error = 'saving MEG generated sources'

self.error_long = ' Incorrect directory ?'

log_name = os.path.join(self.exec_dir, 'compile.log')

log = open(log_name, 'w')

solver_name = os.path.basename(self.solver_path)

retval = cs_compile.compile_and_link(self.package_compute,

solver_name,

exec_src,

self.exec_dir,

self.compile_cflags,

self.compile_cxxflags,

self.compile_fcflags,

self.compile_nvccflags,

self.compile_libs,

keep_going=True,

stdout=log,

stderr=log)

log.close()

if retval == 0:

solver_dir = '.'

self.solver_path = os.path.join(solver_dir, solver_name)

else:

# In case of error, copy source to results directory now,

# as no calculation is possible, then raise exception

for f in ['src', 'compile.log']:

self.copy_result(f)

self.error = 'compile or link'

#---------------------------------------------------------------------------

def prepare_data(self):

"""

err_str = ""

if not self.exec_solver:

return

# Prepare some output directories

# (Note: LUSTRE striping could be set here)

try:

os.mkdir(os.path.join(self.exec_dir, 'checkpoint'))

except Exception:

pass

# Call user script if necessary

if self.user_locals:

m = 'domain_prepare_data_add'

if m in self.user_locals.keys():

eval(m + '(self)', globals(), self.user_locals)

del self.user_locals[m]

# Files or directories which migh be required but not available

# yet (when the matching case may be staged but not run yet).

upstream_pending = None

# Restart files

# Handle automatic case first

ignore_checkpoint = False

if self.solver_args:

for a in ('--preprocess', '--quality', '-q'):

if a in self.solver_args:

ignore_checkpoint = True

if not ignore_checkpoint:

if self.restart_input == '*':

self.__set_auto_restart__()

if self.restart_input != None:

restart_input = os.path.expanduser(self.restart_input)