def __init__(self, solver_name):
"""
Constructor
Parameters
----------
solver_name : str
Name of solver to use
"""
msg.bold('pyro ...')
if solver_name not in valid_solvers:
msg.fail("ERROR: %s is not a valid solver" % solver_name)
self.pyro_home = os.path.dirname(os.path.realpath(__file__)) + '/'
# import desired solver under "solver" namespace
self.solver = importlib.import_module(solver_name)
self.solver_name = solver_name
# -------------------------------------------------------------------------
# runtime parameters
# -------------------------------------------------------------------------
# parameter defaults
self.rp = runparams.RuntimeParameters()
self.rp.load_params(self.pyro_home + "_defaults")
self.rp.load_params(self.pyro_home + solver_name + "/_defaults")
self.tc = profile.TimerCollection()
self.is_initialized = False
def setup_method(self):
""" this is run before each test """
self.rp = runparams.RuntimeParameters()
self.rp.params["mesh.nx"] = 8
self.rp.params["mesh.ny"] = 8
self.sim = sn.Simulation("advection", "test", self.rp)
self.sim.initialize()
def setup_method(self):
""" this is run before each test """
self.rp = runparams.RuntimeParameters()
self.rp.params["mesh.nx"] = 8
self.rp.params["mesh.ny"] = 8
self.rp.params["eos.gamma"] = 1.4
self.rp.params["compressible.grav"] = 1.0
self.sim = sn.Simulation("compressible", "test", self.rp)
self.sim.initialize()
def setup_method(self):
""" this is run before each test """
self.rp = runparams.RuntimeParameters()
self.rp.params["mesh.nx"] = 8
self.rp.params["mesh.ny"] = 8
self.rp.params["particles.do_particles"] = 0
self.rp.params["swe.grav"] = 1.0
self.sim = sn.Simulation("swe", "test", self.rp)
self.sim.initialize()
def test_grid_setup():
rp = runparams.RuntimeParameters()
rp.params["mesh.nx"] = 8
rp.params["mesh.ny"] = 16
rp.params["mesh.xmin"] = 0.0
rp.params["mesh.xmax"] = 1.0
rp.params["mesh.ymin"] = 0.0
rp.params["mesh.ymax"] = 2.0
g = sn.grid_setup(rp)
assert g.nx == 8
assert g.ny == 16
assert g.dx == 1.0 / 8
assert g.dy == 1.0 / 8
def setup_method(self):
""" this is run before each test """
self.rp = runparams.RuntimeParameters()
self.rp.params["driver.tmax"] = 1.0
self.rp.params["driver.max_steps"] = 100
self.rp.params["driver.init_tstep_factor"] = 0.5
self.rp.params["driver.max_dt_change"] = 1.2
self.rp.params["driver.fix_dt"] = -1.0
self.sim = sn.NullSimulation("test", "test", self.rp)
myg = patch.Grid2d(8, 16)
myd = patch.CellCenterData2d(myg)
bc = bnd.BC()
myd.register_var("a", bc)
myd.create()
self.sim.cc_data = myd
def setup_test(n_particles=50, extra_rp_params=None):
"""
Function for setting up Particles tests. Would use unittest for this, but
it doesn't seem to be possible/easy to pass in options to a setUp function.
Sets up runtime paramters, a blank simulation, fills it with a grid and sets
up the boundary conditions and simulation data.
Parameters
----------
n_particles : int
Number of particles to be generated.
extra_rp_params : dict
Dictionary of extra rp parameters.
"""
rp = runparams.RuntimeParameters()
rp.params["mesh.nx"] = 8
rp.params["mesh.ny"] = 8
rp.params["mesh.xmin"] = 0
rp.params["mesh.xmax"] = 1
rp.params["mesh.ymin"] = 0
rp.params["mesh.ymax"] = 1
rp.params["particles.do_particles"] = 1
n_particles = n_particles
if extra_rp_params is not None:
for param, value in extra_rp_params.items():
rp.params[param] = value
# set up sim
sim = NullSimulation("", "", rp)
# set up grid
my_grid = grid_setup(rp)
my_data = patch.CellCenterData2d(my_grid)
bc = bc_setup(rp)[0]
my_data.create()
sim.cc_data = my_data
return sim.cc_data, bc, n_particles
def setup_method(self):
""" this is run before each test """
self.rp = rp.RuntimeParameters()
self.rp.load_params("util/tests/test.ini")
def doit(solver_name, problem_name, param_file,
other_commands=None,
comp_bench=False, reset_bench_on_fail=False, make_bench=False):
"""The main driver to run pyro"""
msg.bold('pyro ...')
tc = profile.TimerCollection()
tm_main = tc.timer("main")
tm_main.begin()
# import desired solver under "solver" namespace
solver = importlib.import_module(solver_name)
#-------------------------------------------------------------------------
# runtime parameters
#-------------------------------------------------------------------------
# parameter defaults
rp = runparams.RuntimeParameters()
rp.load_params("_defaults")
rp.load_params(solver_name + "/_defaults")
# problem-specific runtime parameters
rp.load_params(solver_name + "/problems/_" + problem_name + ".defaults")
# now read in the inputs file
if not os.path.isfile(param_file):
# check if the param file lives in the solver's problems directory
param_file = solver_name + "/problems/" + param_file
if not os.path.isfile(param_file):
msg.fail("ERROR: inputs file does not exist")
rp.load_params(param_file, no_new=1)
# and any commandline overrides
if other_commands is not None:
rp.command_line_params(other_commands)
# write out the inputs.auto
rp.print_paramfile()
#-------------------------------------------------------------------------
# initialization
#-------------------------------------------------------------------------
# initialize the Simulation object -- this will hold the grid and
# data and know about the runtime parameters and which problem we
# are running
sim = solver.Simulation(solver_name, problem_name, rp, timers=tc)
sim.initialize()
sim.preevolve()
#-------------------------------------------------------------------------
# evolve
#-------------------------------------------------------------------------
verbose = rp.get_param("driver.verbose")
plt.ion()
sim.cc_data.t = 0.0
# output the 0th data
basename = rp.get_param("io.basename")
sim.write("{}{:04d}".format(basename, sim.n))
dovis = rp.get_param("vis.dovis")
if dovis:
plt.figure(num=1, figsize=(8, 6), dpi=100, facecolor='w')
sim.dovis()
while not sim.finished():
# fill boundary conditions
sim.cc_data.fill_BC_all()
# get the timestep
sim.compute_timestep()
# evolve for a single timestep
sim.evolve()
if verbose > 0:
print("%5d %10.5f %10.5f" % (sim.n, sim.cc_data.t, sim.dt))
# output
if sim.do_output():
if verbose > 0:
msg.warning("outputting...")
basename = rp.get_param("io.basename")
sim.write("{}{:04d}".format(basename, sim.n))
# visualization
if dovis:
tm_vis = tc.timer("vis")
tm_vis.begin()
sim.dovis()
store = rp.get_param("vis.store_images")
if store == 1:
basename = rp.get_param("io.basename")
plt.savefig("{}{:04d}.png".format(basename, sim.n))
tm_vis.end()
# final output
if verbose > 0:
msg.warning("outputting...")
basename = rp.get_param("io.basename")
sim.write("{}{:04d}".format(basename, sim.n))
tm_main.end()
#-------------------------------------------------------------------------
# benchmarks (for regression testing)
#-------------------------------------------------------------------------
result = 0
# are we comparing to a benchmark?
if comp_bench:
compare_file = "{}/tests/{}{:04d}".format(
solver_name, basename, sim.n)
msg.warning("comparing to: {} ".format(compare_file))
try:
sim_bench = io.read(compare_file)
except:
msg.warning("ERROR openning compare file")
return "ERROR openning compare file"
result = compare.compare(sim.cc_data, sim_bench.cc_data)
if result == 0:
msg.success("results match benchmark\n")
else:
msg.warning("ERROR: " + compare.errors[result] + "\n")
# are we storing a benchmark?
if make_bench or (result != 0 and reset_bench_on_fail):
if not os.path.isdir(solver_name + "/tests/"):
try:
os.mkdir(solver_name + "/tests/")
except:
msg.fail("ERROR: unable to create the solver's tests/ directory")
bench_file = solver_name + "/tests/" + basename + "%4.4d" % (sim.n)
msg.warning("storing new benchmark: {}\n".format(bench_file))
sim.write(bench_file)
#-------------------------------------------------------------------------
# final reports
#-------------------------------------------------------------------------
if verbose > 0:
rp.print_unused_params()
tc.report()
sim.finalize()
if comp_bench:
return result
import os
import glob
from util import runparams
pfiles = ["../_defaults"]
for path, dirs, files in os.walk("../"):
for d in dirs:
for f in glob.iglob(os.path.join(path, d, "_defaults")):
pfiles.append(f)
for f in pfiles:
rp = runparams.RuntimeParameters()
rp.load_params(f)
pre, name = os.path.split(f)
outfile = "source/{}{}.inc".format(pre.replace(".", ""), name)
rp.print_sphinx_tables(outfile=outfile.format(os.path.basename(f)))
