def testRunSupressOutput(self, subproc):
mooseutils.run_executable('command',
'-arg',
'-arg2',
suppress_output=True)
subproc.assert_called_with(['command', '-arg', '-arg2'],
encoding='utf-8',
stderr=subprocess.DEVNULL,
stdout=subprocess.DEVNULL)
def runner(infile, outfile, n_start, n_stop, mode, mpi):
data = dict(n_samples=[], total=[], per_proc=[], max_proc=[], time=[])
exe = mooseutils.find_moose_executable_recursive()
for n in xrange(n_start, n_stop + 1):
n_samples = 2**n
exe_args = [
'-i', infile, 'Samplers/mc/n_samples={}'.format(n_samples),
'MultiApps/runner/mode={}'.format(mode),
'Outputs/file_base={}'.format(mode)
]
print('{} {}'.format(exe, ' '.join(exe_args)))
t = time.time()
out = mooseutils.run_executable(exe,
exe_args,
mpi=mpi,
suppress_output=True)
t = time.time() - t
local = pandas.read_csv('{}.csv'.format(mode))
data['n_samples'].append(n_samples)
data['total'].append(local['total'].iloc[-1])
data['per_proc'].append(local['per_proc'].iloc[-1])
data['max_proc'].append(local['max_proc'].iloc[-1])
data['time'].append(t)
df = pandas.DataFrame(
data, columns=['n_samples', 'total', 'per_proc', 'max_proc', 'time'])
df.to_csv('{}_{}.csv'.format(outfile, mode), index=False)
def execute(infile, outfile, n_samples, processors, test_type):
"""Helper for running a memory study with increasing MPI ranks."""
data = dict(n_procs=[], n_samples=[], total=[], per_proc=[], max_proc=[], time=[])
exe = mooseutils.find_moose_executable_recursive()
for n_procs in processors:
file_base = '{}_{}'.format(infile[:-2], n_procs)
exe_args = ['-i', infile,
'Outputs/file_base={}'.format(file_base),
'Postprocessors/test/test_type={}'.format(test_type),
'Samplers/sampler/num_rows={}'.format(int(n_samples))]
print('mpiexec -n {} {} {}'.format(n_procs, exe, ' '.join(exe_args)))
t = time.time()
out = mooseutils.run_executable(exe, *exe_args, mpi=n_procs, suppress_output=True)
t = time.time() - t
local = pandas.read_csv('{}.csv'.format(file_base))
data['n_procs'].append(n_procs)
data['n_samples'].append(n_samples)
data['total'].append(local['total'].iloc[-1])
data['per_proc'].append(local['per_proc'].iloc[-1])
data['max_proc'].append(local['max_proc'].iloc[-1])
data['time'].append(t)
df = pandas.DataFrame(data, columns=['n_procs', 'n_samples', 'total', 'per_proc', 'max_proc', 'time'])
df.to_csv('{}.csv'.format(outfile), index=False)
def execute(self, **kwargs):
"""Perform app syntax checking"""
# Check that the supplied content dir exists
content_dir = mooseutils.eval_path(self.content_directory)
if not os.path.isdir(content_dir):
content_dir = os.path.join(self.working_dir, content_dir)
if not os.path.isdir(content_dir):
raise NotADirectoryError(
"'content_directory' input is not a directory: {}".format(
content_dir))
# Populate the available list of files
file_cache = mooseutils.git_ls_files(content_dir)
# Check that the supplied exe dir exists
exe_dir = mooseutils.eval_path(self.exe_directory)
if not os.path.isdir(exe_dir):
exe_dir = os.path.join(self.working_dir, exe_dir)
if not os.path.isdir(exe_dir):
raise NotADirectoryError(
"'exe_directory' input is not a directory: {}".format(exe_dir))
# Locate the executable
exe = mooseutils.find_moose_executable(exe_dir,
name=self.exe_name,
show_error=False)
if exe is None:
raise OSError(
"An executable was not found in '{}' with a name '{}'.".format(
exe_dir, self.exe_name))
# Build syntax tree if not provided
if self.app_syntax is None:
# Get the hidden/removed/alias information
hide = self._loadYamlFiles(self.hidden)
remove = self._loadYamlFiles(self.remove)
alias = self._loadYamlFiles(self.alias)
unregister = self._loadYamlFiles(self.unregister)
# Build the complete syntax tree
self.app_syntax = moosesyntax.get_moose_syntax_tree(
exe,
hide=hide,
remove=remove,
alias=alias,
unregister=unregister,
allow_test_objects=self.allow_test_objects)
# Determine the application type (e.g., MooseTestApp)
if self.app_types is None:
out = mooseutils.run_executable(exe, ['--type'])
match = re.search(r'^MooseApp Type:\s+(?P<type>.*?)$',
out,
flags=re.MULTILINE)
if match:
self.app_types = [
match.group("type").replace('TestApp', 'App')
]
# Perform the checks
kwargs.setdefault('syntax_prefix',
mooseutils.eval_path(self.syntax_prefix))
kwargs.setdefault('object_prefix',
mooseutils.eval_path(self.object_prefix))
logger = check_syntax(self.app_syntax, self.app_types, file_cache,
**kwargs)
# Create stub pages
if self.generate_stubs:
func = lambda n: (not n.removed) \
and ('_md_file' in n) \
and ((n['_md_file'] is None) or n['_is_stub']) \
and ((n.group in self.app_types) \
or (n.groups() == set(self.app_types)))
for node in moosetree.iterate(self.app_syntax, func):
self._createStubPage(node)
# Dump
if self.dump_syntax:
print(self.app_syntax)
return logger
def _runner(input_file, num_refinements, *args, **kwargs):
"""
Helper class for running MOOSE-based application input file for convergence study.
Inputs:
input_file[str]: The name of the input file to run
num_refinements: The number of refinements to perform
Optional Key-Value Options:
x_pp[str]: The Postprocessor to use for the x-axis; ignored for rtype=TEMPORAL (default: 'h')
y_pp[str]: The Postprocessor to use for the y-axis (default: 'error')
executable[str]: The executable to run, if not provided the executable is automatically
detected
csv[str]: The name of the CSV containing the Postprocessor data, if not provided the name
is assumed to be the standard output name if Outputs/csv=true in the input file
rtype[int]: SPATIAL or TEMPORAL
dt[float]: The initial timestep, only used with rtype=TEMPORAL (default: 1)
file_base[str]: A string pattern for outputting files
All additional arguments are passed to the executable
"""
x_pp = kwargs.get('x_pp', 'h')
y_pp = kwargs.get('y_pp', ['error'])
if not isinstance(y_pp, list):
y_pp = [y_pp]
executable = kwargs.get('executable', None)
csv = kwargs.get('csv', None)
console = kwargs.get('console', True)
mpi = kwargs.get('mpi', None)
rtype = kwargs.get('rtype') # SPATIAL or TEMPORAL
dt = kwargs.pop('dt', 1) # only used with rtype=TEMPORAL
file_base = kwargs.pop('file_base', None)
# Check that input file exists
if not os.path.isfile(input_file):
raise IOError(
"The supplied file, '{}', does not exist.".format(input_file))
# Assume output CSV file, if not specified
if csv is None:
fcsv = input_file.replace('.i', '_out.csv')
# Locate the executable
if executable is None:
executable = mooseutils.find_moose_executable_recursive(os.getcwd())
elif os.path.isdir(executable):
executable = mooseutils.find_moose_executable(executable)
elif not os.path.isfile(executable):
raise IOError("Unable to locate executable: {}".format(executable))
if executable is None:
raise IOError("No application executable found.")
# Build custom arguments
cli_args = ['-i', input_file]
cli_args += args
# Run input file and build up output
x = []
y = [[] for _ in range(len(y_pp))]
if not isinstance(num_refinements, list):
num_refinements = list(range(num_refinements))
for step in num_refinements:
a = copy.copy(cli_args)
if rtype == SPATIAL:
a.append('Mesh/uniform_refine={}'.format(step))
elif rtype == TEMPORAL:
a.append('Executioner/dt={}'.format(dt))
dt = dt / 2.
if file_base:
fbase = file_base.format(step)
a.append('Outputs/file_base={}'.format(fbase))
if csv is None:
fcsv = '{}.csv'.format(fbase)
print('Running:', executable, ' '.join(a))
out = mooseutils.run_executable(executable,
*a,
mpi=mpi,
suppress_output=not console)
# Check that CSV file exists
if not os.path.isfile(fcsv):
raise IOError("The CSV output does not exist: {}".format(csv))
# Load data for h and error
current = pandas.read_csv(fcsv)
if rtype == SPATIAL:
x.append(current[x_pp].iloc[-1])
for index, pp in enumerate(y_pp):
y[index].append(current[pp].iloc[-1])
elif rtype == TEMPORAL:
x.append(dt)
for index, pp in enumerate(y_pp):
y[index].append(current[pp].iloc[-1])
if rtype == SPATIAL:
x_pp == 'dt'
df_dict = {x_pp: x}
df_columns = [x_pp]
for i in range(len(y_pp)):
df_dict.update({y_pp[i]: y[i]})
df_columns.append(y_pp[i])
return pandas.DataFrame(df_dict, columns=df_columns)
def testRunMPI(self, subproc):
mooseutils.run_executable('command', '-arg', '-arg2', mpi=2)
subproc.assert_called_with(
['mpiexec', '-n', '2', 'command', '-arg', '-arg2'],
encoding='utf-8')
def testRun(self, subproc):
mooseutils.run_executable('command', '-arg', '-arg2')
subproc.assert_called_with(['command', '-arg', '-arg2'],
encoding='utf-8')
def _runner(input_file, num_refinements, *args, **kwargs):
"""
Helper class for running MOOSE-based application input file for convergence study.
Inputs:
input_file[str]: The name of the input file to run
num_refinements: The number of refinements to perform
Optional Key-Value Options:
x_pp[str]: The Postprocessor to use for the x-axis; ignored for rtype=TEMPORAL (default: 'h')
y_pp[str]: The Postprocessor to use for the y-axis (default: 'error')
executable[str]: The executable to run, if not provided the executable is automatically
detected
csv[str]: The name of the CSV containing the Postprocessor data, if not provided the name
is assumed to be the standard output name if Outputs/csv=true in the input file
rtype[int]: SPATIAL or TEMPORAL
dt[float]: The initial timestep, only used with rtype=TEMPORAL (default: 1)
All additional arguments are passed to the executable
"""
x_pp = kwargs.get('x_pp', 'h')
y_pp = kwargs.get('y_pp', 'error')
executable = kwargs.get('executable', None)
csv = kwargs.get('csv', None)
console = kwargs.get('console', True)
mpi = kwargs.get('mpi', None)
rtype = kwargs.get('rtype') # SPATIAL or TEMPORAL
dt = kwargs.pop('dt', 1) # only used with rtype=TEMPORAL
# Check that input file exists
if not os.path.isfile(input_file):
raise IOError(
"The supplied file, '{}', does not exist.".format(input_file))
# Assume output CSV file, if not specified
if csv is None:
csv = input_file.replace('.i', '_out.csv')
# Locate the executable
if executable is None:
executable = mooseutils.find_moose_executable_recursive(os.getcwd())
if executable is None:
raise IOError("No application executable found.")
# Build custom arguments
cli_args = ['-i', input_file]
cli_args += args
# Run input file and build up output
x = []
y = []
for step in xrange(0, num_refinements):
a = copy.copy(cli_args)
if rtype == SPATIAL:
a.append('Mesh/uniform_refine={}'.format(step))
elif rtype == TEMPORAL:
a.append('Executioner/dt={}'.format(dt))
dt = dt / 2.
print 'Running:', executable, ' '.join(a)
out = mooseutils.run_executable(executable,
a,
mpi=mpi,
suppress_output=not console)
# Check that CSV file exists
if not os.path.isfile(csv):
raise IOError("The CSV output does not exist: {}".format(csv))
# Load data for h and error
current = pandas.read_csv(csv)
if rtype == SPATIAL:
x.append(current[x_pp].iloc[-1])
y.append(current[y_pp].iloc[-1])
elif rtype == TEMPORAL:
x.append(dt)
y.append(current[y_pp].iloc[-1])
if rtype == SPATIAL:
x_pp == 'dt'
return pandas.DataFrame({x_pp: x, y_pp: y}, columns=[x_pp, y_pp])
