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 run_app(args=[]):
"""
Run the app and return the output.
Exits if the app failed to run for any reason.
"""
proc = None
app_name = mooseutils.find_moose_executable_recursive()
args.insert(0, app_name)
# "-options_left 0" is used to stop the debug version of PETSc from printing
# out WARNING messages that sometime confuse the json parser
args.insert(1, "-options_left")
args.insert(2, "0")
cmd_line = ' '.join(args)
try:
proc = subprocess.Popen(args,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
except OSError as e:
print("Problem running '%s'\nError: %s" % (cmd_line, e))
sys.exit(1)
data = proc.communicate()
stdout_data = data[0].decode("utf-8")
if proc.returncode != 0:
print("Failed with exit code %s" % proc.returncode)
sys.exit(proc.returncode)
return stdout_data
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(infile,
outfile,
mode,
samples,
mpi=None,
replicates=1,
write=True):
data = collections.defaultdict(list)
if mpi is None: mpi = [1] * len(samples)
exe = mooseutils.find_moose_executable_recursive()
for n_cores, n_samples in zip(mpi, samples):
cmd = [
'mpiexec', '-n',
str(n_cores), exe, '-i', infile,
'Samplers/mc/num_rows={}'.format(int(n_samples)),
'Executioner/num_steps={}'.format(replicates),
'MultiApps/runner/mode={}'.format(mode),
'Outputs/file_base={}'.format(mode)
]
print(' '.join(cmd))
out = subprocess.run(cmd,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
local = pandas.read_csv('{}.csv'.format(mode))
data['n_ranks'].append(n_cores)
data['n_samples'].append(n_samples)
data['mem_total'].append(local['total'].iloc[1])
data['mem_per_proc'].append(local['per_proc'].iloc[1])
data['mem_max_proc'].append(local['max_proc'].iloc[1])
data['run_time'].append(statistics.mean(local['run_time'].iloc[1:]))
data['run_time_min'].append(min(local['run_time'].iloc[1:]))
data['run_time_max'].append(max(local['run_time'].iloc[1:]))
df = pandas.DataFrame(data, columns=data.keys())
if write:
df.to_csv('results/{}_{}.csv'.format(outfile, mode))
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 _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])