diff --git a/docs/source/adding_a_problem_jupyter.ipynb b/docs/source/adding_a_problem_jupyter.ipynb new file mode 100644 index 000000000..b7bcb44d1 --- /dev/null +++ b/docs/source/adding_a_problem_jupyter.ipynb @@ -0,0 +1,444 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4dd6cc8c-f7e5-4d09-8507-267c7028e731", + "metadata": {}, + "source": [ + "# Defining our own problem in Jupyter" + ] + }, + { + "cell_type": "markdown", + "id": "2a88375d-4be8-42b0-9977-6a021100bdd9", + "metadata": {}, + "source": [ + "Here we explore how to add our own problem setup to a solver by\n", + "writing the function to initialize the data outside of the pyro\n", + "directory structure." + ] + }, + { + "cell_type": "markdown", + "id": "3a19b940-f028-435c-a7ae-5801f78d23f9", + "metadata": {}, + "source": [ + "We'll do the linear advection setup, but the idea is the same for any solver.\n", + "\n", + "Let's create the initial conditions:\n", + "\n", + "$$\\rho(x) = \\cos(m \\pi x / L) \\sin(n \\pi y / L)$$\n", + "\n", + "where $m$ is the number of wavelengths in $x$ and $n$ is in $y$, and $L$\n", + "is the domain width (which we'll assume is 1)." + ] + }, + { + "cell_type": "markdown", + "id": "0919312f-450a-42f1-8f92-016624dd961b", + "metadata": {}, + "source": [ + "We'll call this problem setup \"waves\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c338ff6e-85c1-442b-a058-1e0a112d9c06", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4dbc1140-cb59-4ef4-9e81-505dc52c8898", + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 1, 64)\n", + "y = np.linspace(0, 1, 64)\n", + "\n", + "x2d, y2d = np.meshgrid(x, y, indexing=\"ij\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b118c570-7c6f-47d1-bf5f-423ad26f9ec5", + "metadata": {}, + "outputs": [], + "source": [ + "m = 4\n", + "n = 5\n", + "d = np.cos(m * np.pi * x2d) * np.sin(n * np.pi * y2d)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "20fadd76-785e-4901-ae34-73a256afa7cb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.imshow(d.T, origin=\"lower\")" + ] + }, + { + "cell_type": "markdown", + "id": "6f682998-c452-4fdf-87dc-bac340e9e9df", + "metadata": {}, + "source": [ + "Here's what the `smooth` setup looks like for the `advection` solver:\n", + "https://github.com/python-hydro/pyro2/blob/main/pyro/advection/problems/smooth.py" + ] + }, + { + "cell_type": "markdown", + "id": "bdcd4eb0-8158-4f93-9ddc-6c7c38a055bf", + "metadata": {}, + "source": [ + "To define a problem, we need to create the `init_data()` function and a list of runtime parameters needed by the problem." + ] + }, + { + "cell_type": "markdown", + "id": "7042f4e1-d352-4ef0-8e25-31b728654afa", + "metadata": {}, + "source": [ + "First the parameters--we'll use $m$ and $n$ as the parameters we might\n", + "want to set at runtime." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0d8dae4c-4dc1-481d-92b2-1433b8d50f7a", + "metadata": {}, + "outputs": [], + "source": [ + "params = {\"waves.m\": 4, \"waves.n\": 5}" + ] + }, + { + "cell_type": "markdown", + "id": "a310aee4-892b-4176-ad48-ad6432daa9c6", + "metadata": {}, + "source": [ + "Our problem initialization routine gets a `RuntimeParameters` object\n", + "passed in, so we can access these values when we do the initialization." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b2624cf-0548-4261-80f8-ebc3795b4dca", + "metadata": {}, + "outputs": [], + "source": [ + "def init_data(my_data, rp):\n", + " \"\"\" initialize the waves problem \"\"\"\n", + "\n", + " dens = my_data.get_var(\"density\")\n", + " g = my_data.grid\n", + " \n", + " xmin = my_data.grid.xmin\n", + " xmax = my_data.grid.xmax\n", + " L_x = xmax - xmin\n", + " \n", + " ymin = my_data.grid.ymin\n", + " ymax = my_data.grid.ymax\n", + " L_y = ymax - ymin\n", + "\n", + " m = rp.get_param(\"waves.m\")\n", + " n = rp.get_param(\"waves.n\")\n", + " \n", + " dens[:, :] = np.cos(m * np.pi * g.x2d / L_x) * \\\n", + " np.sin(n * np.pi * g.y2d / L_y)" + ] + }, + { + "cell_type": "markdown", + "id": "40e0013c-a1bd-43eb-b788-11f2ee28ad29", + "metadata": {}, + "source": [ + "Now we can use our new problem setup. We need to register it with the solver by using the `add_problem()` method. Then everything works the\n", + "same as any standard problem." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bf4507fc-1f57-4256-92f8-59dc203fc532", + "metadata": {}, + "outputs": [], + "source": [ + "from pyro import Pyro" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "13b716fd-ae4a-4722-be37-c153990160fc", + "metadata": {}, + "outputs": [], + "source": [ + "p = Pyro(\"advection\")\n", + "p.add_problem(\"waves\", init_data, problem_params=params)\n", + "p.initialize_problem(\"waves\")" + ] + }, + { + "cell_type": "markdown", + "id": "6617a2e6-21db-4d9a-b49a-96447a4b0dbe", + "metadata": {}, + "source": [ + "We can already look at the initial conditions" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "feb5a2e4-2dd4-4795-bb13-47e984c03b5b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p.sim.dovis()" + ] + }, + { + "cell_type": "markdown", + "id": "69b031ad-9bc4-4ac7-ab07-a93f7b226721", + "metadata": {}, + "source": [ + "If we wanted to change the number of wavelengths, we could override\n", + "the default values of the runtime parameters when we call `initialize_problem()`.\n", + "\n", + "We also need to change the boundary conditions. For problems that we \n", + "define this way, there is not a default \"inputs\" file that sets up\n", + "the domain, etc. for us. But we can see what the default value of\n", + "all the parameters for the simulation are:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e671c3a6-b4bd-48b8-9906-c9ff76e94fa1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solver = advection\n", + "Problem = waves\n", + "Simulation time = 0.0\n", + "Simulation step number = 0\n", + "\n", + "Runtime Parameters\n", + "------------------\n", + "advection.limiter = 2\n", + "advection.u = 1.0\n", + "advection.v = 1.0\n", + "driver.cfl = 0.8\n", + "driver.fix_dt = -1.0\n", + "driver.init_tstep_factor = 0.01\n", + "driver.max_dt_change = 2.0\n", + "driver.max_steps = 10000\n", + "driver.tmax = 1.0\n", + "driver.verbose = 0\n", + "io.basename = pyro_\n", + "io.do_io = 1\n", + "io.dt_out = 0.1\n", + "io.n_out = 10000\n", + "mesh.grid_type = Cartesian2d\n", + "mesh.nx = 25\n", + "mesh.ny = 25\n", + "mesh.xlboundary = reflect\n", + "mesh.xmax = 1.0\n", + "mesh.xmin = 0.0\n", + "mesh.xrboundary = reflect\n", + "mesh.ylboundary = reflect\n", + "mesh.ymax = 1.0\n", + "mesh.ymin = 0.0\n", + "mesh.yrboundary = reflect\n", + "particles.do_particles = 0\n", + "particles.n_particles = 100\n", + "particles.particle_generator = grid\n", + "vis.dovis = 0\n", + "vis.store_images = 0\n", + "waves.m = 4\n", + "waves.n = 5\n", + "\n" + ] + } + ], + "source": [ + "print(p)" + ] + }, + { + "cell_type": "markdown", + "id": "bdbbde5f-08e1-47f2-b3f6-8fefb9d37487", + "metadata": {}, + "source": [ + "The main thing we need to change is the boundary conditions--we'll make\n", + "them periodic. We'll also set the grid size to $32^2$." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d9ea2697-f7df-4fbf-ae30-1e4d0cb9b118", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = Pyro(\"advection\")\n", + "p.add_problem(\"waves\", init_data, problem_params=params)\n", + "p.initialize_problem(\"waves\",\n", + " inputs_dict={\"mesh.nx\": 32,\n", + " \"mesh.ny\": 32,\n", + " \"mesh.xlboundary\": \"periodic\",\n", + " \"mesh.xrboundary\": \"periodic\",\n", + " \"mesh.ylboundary\": \"periodic\",\n", + " \"mesh.yrboundary\": \"periodic\",\n", + " \"waves.m\": 2})\n", + "p.sim.dovis()" + ] + }, + { + "cell_type": "markdown", + "id": "a62d9476-dc79-4193-a13e-856b465cada1", + "metadata": {}, + "source": [ + "Now let's evolve it" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1793bf37-cfec-4dc2-9cc6-8dc4a3509d28", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p.run_sim()\n", + "p.sim.dovis()" + ] + }, + { + "cell_type": "markdown", + "id": "d59f8e16-81a2-4ee8-a2e9-2ba64bae53e6", + "metadata": {}, + "source": [ + "The simulation is quite coarse, so the extrema are clipped a bit from the \n", + "initial values, but we can fix that by increasing `mesh.nx` and `mesh.ny`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/index.rst b/docs/source/index.rst index 261764cb5..283979fe2 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -72,6 +72,7 @@ new ideas. :hidden: compressible-rt-compare.ipynb + adding_a_problem_jupyter.ipynb advection-error.ipynb compressible-convergence.ipynb diff --git a/pyro/advection/simulation.py b/pyro/advection/simulation.py index a9544f9aa..668ae7318 100644 --- a/pyro/advection/simulation.py +++ b/pyro/advection/simulation.py @@ -1,5 +1,3 @@ -import importlib - import matplotlib.pyplot as plt import numpy as np @@ -35,8 +33,7 @@ def initialize(self): self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator) # now set the initial conditions for the problem - problem = importlib.import_module(f"pyro.advection.problems.{self.problem_name}") - problem.init_data(self.cc_data, self.rp) + self.problem_func(self.cc_data, self.rp) def method_compute_timestep(self): """ diff --git a/pyro/advection/tests/test_advection.py b/pyro/advection/tests/test_advection.py index 0fbc35949..b15cb6d9e 100644 --- a/pyro/advection/tests/test_advection.py +++ b/pyro/advection/tests/test_advection.py @@ -1,4 +1,5 @@ -import pyro.advection.simulation as sn +import pyro.advection.simulation as sim +from pyro.advection.problems import test from pyro.util import runparams @@ -19,7 +20,7 @@ def setup_method(self): self.rp.params["mesh.ny"] = 8 self.rp.params["particles.do_particles"] = 0 - self.sim = sn.Simulation("advection", "test", self.rp) + self.sim = sim.Simulation("advection", "test", test.init_data, self.rp) self.sim.initialize() def teardown_method(self): diff --git a/pyro/advection_fv4/simulation.py b/pyro/advection_fv4/simulation.py index b3e998236..a0ffd17ef 100644 --- a/pyro/advection_fv4/simulation.py +++ b/pyro/advection_fv4/simulation.py @@ -1,5 +1,3 @@ -import importlib - import pyro.advection_fv4.fluxes as flx import pyro.mesh.array_indexer as ai from pyro import advection_rk @@ -32,8 +30,7 @@ def initialize(self): self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator) # now set the initial conditions for the problem - problem = importlib.import_module(f"pyro.advection_fv4.problems.{self.problem_name}") - problem.init_data(self.cc_data, self.rp) + self.problem_func(self.cc_data, self.rp) def substep(self, myd): """ diff --git a/pyro/advection_nonuniform/simulation.py b/pyro/advection_nonuniform/simulation.py index 46a0424f3..869f7f278 100755 --- a/pyro/advection_nonuniform/simulation.py +++ b/pyro/advection_nonuniform/simulation.py @@ -1,5 +1,3 @@ -import importlib - import matplotlib.pyplot as plt import numpy as np @@ -55,8 +53,7 @@ def shift(velocity): self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator) # now set the initial conditions for the problem - problem = importlib.import_module(f"pyro.advection_nonuniform.problems.{self.problem_name}") - problem.init_data(self.cc_data, self.rp) + self.problem_func(self.cc_data, self.rp) # compute the required shift for each node using corresponding velocity at the node shx = self.cc_data.get_var("x-shift") diff --git a/pyro/advection_nonuniform/tests/test_advection_nonuniform.py b/pyro/advection_nonuniform/tests/test_advection_nonuniform.py index 81681938d..ab363feb4 100755 --- a/pyro/advection_nonuniform/tests/test_advection_nonuniform.py +++ b/pyro/advection_nonuniform/tests/test_advection_nonuniform.py @@ -1,4 +1,5 @@ -import pyro.advection_nonuniform.simulation as sn +import pyro.advection_nonuniform.simulation as sim +from pyro.advection_nonuniform.problems import test from pyro.util import runparams @@ -19,7 +20,7 @@ def setup_method(self): self.rp.params["mesh.ny"] = 8 self.rp.params["particles.do_particles"] = 0 - self.sim = sn.Simulation("advection_nonuniform", "test", self.rp) + self.sim = sim.Simulation("advection_nonuniform", "test", test.init_data, self.rp) self.sim.initialize() def teardown_method(self): diff --git a/pyro/burgers/simulation.py b/pyro/burgers/simulation.py index fcbbc71f4..6f83d37a0 100644 --- a/pyro/burgers/simulation.py +++ b/pyro/burgers/simulation.py @@ -1,5 +1,3 @@ -import importlib - import matplotlib.pyplot as plt import numpy as np @@ -43,8 +41,7 @@ def initialize(self): self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator) # now set the initial conditions for the problem - problem = importlib.import_module(f"pyro.burgers.problems.{self.problem_name}") - problem.init_data(self.cc_data, self.rp) + self.problem_func(self.cc_data, self.rp) def method_compute_timestep(self): """ diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py index 7b75c573b..843285611 100644 --- a/pyro/compressible/simulation.py +++ b/pyro/compressible/simulation.py @@ -1,5 +1,3 @@ -import importlib - import matplotlib.pyplot as plt import numpy as np @@ -167,8 +165,7 @@ def initialize(self, *, extra_vars=None, ng=4): self.cc_data.add_derived(derives.derive_primitives) # initial conditions for the problem - problem = importlib.import_module(f"pyro.{self.solver_name}.problems.{self.problem_name}") - problem.init_data(self.cc_data, self.rp) + self.problem_func(self.cc_data, self.rp) if self.verbose > 0: print(my_data) diff --git a/pyro/compressible/tests/test_compressible.py b/pyro/compressible/tests/test_compressible.py index ad862f0b6..61870bb07 100644 --- a/pyro/compressible/tests/test_compressible.py +++ b/pyro/compressible/tests/test_compressible.py @@ -2,7 +2,8 @@ import pytest from numpy.testing import assert_array_equal -import pyro.compressible.simulation as sn +import pyro.compressible.simulation as sim +from pyro.compressible.problems import test from pyro.util import runparams @@ -26,7 +27,7 @@ def setup_method(self): self.rp.params["eos.gamma"] = 1.4 self.rp.params["compressible.grav"] = 1.0 - self.sim = sn.Simulation("compressible", "test", self.rp) + self.sim = sim.Simulation("compressible", "test", test.init_data, self.rp) self.sim.initialize() def teardown_method(self): @@ -45,13 +46,13 @@ def test_prim(self): # U -> q gamma = self.sim.cc_data.get_aux("gamma") - q = sn.cons_to_prim(self.sim.cc_data.data, gamma, self.sim.ivars, self.sim.cc_data.grid) + q = sim.cons_to_prim(self.sim.cc_data.data, gamma, self.sim.ivars, self.sim.cc_data.grid) assert q[:, :, self.sim.ivars.ip].min() == pytest.approx(1.0) and \ q[:, :, self.sim.ivars.ip].max() == pytest.approx(1.0) # q -> U - U = sn.prim_to_cons(q, gamma, self.sim.ivars, self.sim.cc_data.grid) + U = sim.prim_to_cons(q, gamma, self.sim.ivars, self.sim.cc_data.grid) assert_array_equal(U, self.sim.cc_data.data) def test_derives(self): diff --git a/pyro/compressible_fv4/simulation.py b/pyro/compressible_fv4/simulation.py index f7c44a8df..b47d19821 100644 --- a/pyro/compressible_fv4/simulation.py +++ b/pyro/compressible_fv4/simulation.py @@ -5,9 +5,11 @@ class Simulation(compressible_rk.Simulation): - def __init__(self, solver_name, problem_name, rp, *, - timers=None, data_class=fv.FV2d): - super().__init__(solver_name, problem_name, rp, timers=timers, data_class=data_class) + def __init__(self, solver_name, problem_name, problem_func, rp, *, + problem_finalize_func=None, timers=None, data_class=fv.FV2d): + super().__init__(solver_name, problem_name, problem_func, rp, + problem_finalize_func=problem_finalize_func, + timers=timers, data_class=data_class) def substep(self, myd): """ diff --git a/pyro/compressible_rk/tests/test_compressible_rk.py b/pyro/compressible_rk/tests/test_compressible_rk.py index 0fba61d68..04dc6d12b 100644 --- a/pyro/compressible_rk/tests/test_compressible_rk.py +++ b/pyro/compressible_rk/tests/test_compressible_rk.py @@ -1,4 +1,5 @@ -import pyro.compressible_rk.simulation as sn +import pyro.compressible_rk.simulation as sim +from pyro.compressible_rk.problems import test from pyro.util import runparams @@ -22,7 +23,7 @@ def setup_method(self): self.rp.params["eos.gamma"] = 1.4 self.rp.params["compressible.grav"] = 1.0 - self.sim = sn.Simulation("compressible", "test", self.rp) + self.sim = sim.Simulation("compressible", "test", test.init_data, self.rp) self.sim.initialize() def teardown_method(self): diff --git a/pyro/diffusion/simulation.py b/pyro/diffusion/simulation.py index 442135bcb..5d8cab2b8 100644 --- a/pyro/diffusion/simulation.py +++ b/pyro/diffusion/simulation.py @@ -1,8 +1,5 @@ """ A simulation of diffusion """ -import importlib -import math - import matplotlib.pyplot as plt import numpy as np @@ -28,7 +25,7 @@ def initialize(self): if my_grid.nx != my_grid.ny: msg.fail("need nx = ny for diffusion problems") - n = int(math.log(my_grid.nx)/math.log(2.0)) + n = int(np.log(my_grid.nx)/np.log(2.0)) if 2**n != my_grid.nx: msg.fail("grid needs to be a power of 2") @@ -50,8 +47,7 @@ def initialize(self): self.cc_data = my_data # now set the initial conditions for the problem - problem = importlib.import_module(f"pyro.diffusion.problems.{self.problem_name}") - problem.init_data(self.cc_data, self.rp) + self.problem_func(self.cc_data, self.rp) def method_compute_timestep(self): """ diff --git a/pyro/diffusion/tests/test_diffusion.py b/pyro/diffusion/tests/test_diffusion.py index 192fb06c5..fbd2f5b56 100644 --- a/pyro/diffusion/tests/test_diffusion.py +++ b/pyro/diffusion/tests/test_diffusion.py @@ -1,4 +1,5 @@ -import pyro.diffusion.simulation as sn +import pyro.diffusion.simulation as sim +from pyro.diffusion.problems import test from pyro.util import runparams @@ -19,7 +20,7 @@ def setup_method(self): self.rp.params["mesh.nx"] = 8 self.rp.params["mesh.ny"] = 8 - self.sim = sn.Simulation("diffusion", "test", self.rp) + self.sim = sim.Simulation("diffusion", "test", test.init_data, self.rp) self.sim.initialize() def teardown_method(self): diff --git a/pyro/incompressible/simulation.py b/pyro/incompressible/simulation.py index b7ca0fb64..7c2e4930e 100644 --- a/pyro/incompressible/simulation.py +++ b/pyro/incompressible/simulation.py @@ -1,5 +1,3 @@ -import importlib - import matplotlib.pyplot as plt import numpy as np @@ -64,8 +62,7 @@ def initialize(self, *, other_bc=False, aux_vars=()): self.in_preevolve = False # now set the initial conditions for the problem - problem = importlib.import_module(f"pyro.{self.solver_name}.problems.{self.problem_name}") - problem.init_data(self.cc_data, self.rp) + self.problem_func(self.cc_data, self.rp) def preevolve(self): """ diff --git a/pyro/lm_atm/simulation.py b/pyro/lm_atm/simulation.py index cf0a23c86..91fa35438 100644 --- a/pyro/lm_atm/simulation.py +++ b/pyro/lm_atm/simulation.py @@ -1,5 +1,3 @@ -import importlib - import matplotlib.pyplot as plt import numpy as np @@ -37,9 +35,11 @@ def jp(self, shift, buf=0): class Simulation(NullSimulation): - def __init__(self, solver_name, problem_name, rp, *, timers=None): + def __init__(self, solver_name, problem_name, problem_func, rp, *, + problem_finalize_func=None, timers=None): - NullSimulation.__init__(self, solver_name, problem_name, rp, timers=timers) + super().__init__(solver_name, problem_name, problem_func, rp, + problem_finalize_func=problem_finalize_func, timers=timers) self.base = {} self.aux_data = None @@ -114,8 +114,7 @@ def initialize(self): self.base["p0"] = Basestate(myg.ny, ng=myg.ng) # now set the initial conditions for the problem - problem = importlib.import_module(f"pyro.lm_atm.problems.{self.problem_name}") - problem.init_data(self.cc_data, self.base, self.rp) + self.problem_func(self.cc_data, self.base, self.rp) # Construct beta_0 gamma = self.rp.get_param("eos.gamma") diff --git a/pyro/particles/tests/test_particles.py b/pyro/particles/tests/test_particles.py index 6558fc2ce..e0b46425f 100644 --- a/pyro/particles/tests/test_particles.py +++ b/pyro/particles/tests/test_particles.py @@ -53,7 +53,7 @@ def setup_test(n_particles=50, extra_rp_params=None): rp.params[param] = value # set up sim - sim = NullSimulation("", "", rp) + sim = NullSimulation("", "", rp, None) # set up grid my_grid = grid_setup(rp) diff --git a/pyro/pyro_sim.py b/pyro/pyro_sim.py index a31086f92..95d8591e7 100755 --- a/pyro/pyro_sim.py +++ b/pyro/pyro_sim.py @@ -67,9 +67,16 @@ def __init__(self, solver_name, *, from_commandline=False): self.solver = importlib.import_module(solver_import) self.solver_name = solver_name - # ------------------------------------------------------------------------- + self.problem_name = None + self.problem_func = None + self.problem_params = None + self.problem_finalize = None + + # custom problems + + self.custom_problems = {} + # runtime parameters - # ------------------------------------------------------------------------- # parameter defaults self.rp = RuntimeParameters() @@ -80,6 +87,23 @@ def __init__(self, solver_name, *, from_commandline=False): self.is_initialized = False + def add_problem(self, name, problem_func, *, problem_params=None): + """Add a problem setup for this solver. + + Parameters + ---------- + name : str + The descriptive name of the problem + problem_func : function + The function to initialize the state data + problem_params : dict + A dictionary of runtime parameters needed for the problem setup + """ + + if problem_params is None: + problem_params = {} + self.custom_problems[name] = (problem_func, problem_params) + def initialize_problem(self, problem_name, *, inputs_file=None, inputs_dict=None): """ Initialize the specific problem @@ -95,16 +119,27 @@ def initialize_problem(self, problem_name, *, inputs_file=None, inputs_dict=None """ # pylint: disable=attribute-defined-outside-init - problem = importlib.import_module("pyro.{}.problems.{}".format(self.solver_name, problem_name)) + if problem_name in self.custom_problems: + # this is a problem we added via self.add_problem + self.problem_name = problem_name + self.problem_func, self.problem_params = self.custom_problems[problem_name] + self.problem_finalize = None + + else: + problem = importlib.import_module("pyro.{}.problems.{}".format(self.solver_name, problem_name)) + self.problem_name = problem_name + self.problem_func = problem.init_data + self.problem_params = problem.PROBLEM_PARAMS + self.problem_finalize = problem.finalize + + if inputs_file is None: + inputs_file = problem.DEFAULT_INPUTS # problem-specific runtime parameters - for k, v in problem.PROBLEM_PARAMS.items(): + for k, v in self.problem_params.items(): self.rp.set_param(k, v, no_new=False) # now read in the inputs file - if inputs_file is None: - inputs_file = problem.DEFAULT_INPUTS - if inputs_file is not None: if not os.path.isfile(inputs_file): # check if the param file lives in the solver's problems directory @@ -138,7 +173,8 @@ def initialize_problem(self, problem_name, *, inputs_file=None, inputs_dict=None # data and know about the runtime parameters and which problem we # are running self.sim = self.solver.Simulation( - self.solver_name, problem_name, self.rp, timers=self.tc) + self.solver_name, self.problem_name, self.problem_func, self.rp, + problem_finalize_func=self.problem_finalize, timers=self.tc) self.sim.initialize() self.sim.preevolve() diff --git a/pyro/simulation_null.py b/pyro/simulation_null.py index c714117ab..81c86cc0d 100644 --- a/pyro/simulation_null.py +++ b/pyro/simulation_null.py @@ -1,5 +1,3 @@ -import importlib - import h5py import pyro.mesh.boundary as bnd @@ -102,20 +100,29 @@ def bc_setup(rp): class NullSimulation: - def __init__(self, solver_name, problem_name, rp, *, + def __init__(self, solver_name, problem_name, problem_func, rp, *, + problem_finalize_func=None, timers=None, data_class=patch.CellCenterData2d): """ Initialize the Simulation object Parameters ---------- + solver_name : str + The name of the solver we are using problem_name : str - The name of the problem we wish to run. This should - correspond to one of the modules in advection/problems/ + The descriptive name for the problem (used in output) + problem_func : function + The function to call to initialize the problem rp : RuntimeParameters object The runtime parameters for the simulation + problem_finalize_func : function + An (optional) function to call when the simulation is + over. timers : TimerCollection object, optional - The timers used for profiling this simulation + The timers used for profiling this simulation. + data_class : CellCenterData2d or FV2d + The class that manages the data. """ self.n = 0 @@ -142,6 +149,8 @@ def __init__(self, solver_name, problem_name, rp, *, self.solver_name = solver_name self.problem_name = problem_name + self.problem_func = problem_func + self.problem_finalize = problem_finalize_func if timers is None: self.tc = profile.TimerCollection() @@ -230,10 +239,9 @@ def finalize(self): Do any final clean-ups for the simulation and call the problem's finalize() method. """ - # there should be a cleaner way of doing this - problem = importlib.import_module("pyro.{}.problems.{}".format(self.solver_name, self.problem_name)) - problem.finalize() + if self.problem_finalize: + self.problem_finalize() def write(self, filename): """ diff --git a/pyro/swe/simulation.py b/pyro/swe/simulation.py index a0bb073bc..a58a15b39 100644 --- a/pyro/swe/simulation.py +++ b/pyro/swe/simulation.py @@ -1,5 +1,3 @@ -import importlib - import matplotlib.pyplot as plt import numpy as np @@ -146,9 +144,7 @@ def initialize(self, *, extra_vars=None, ng=4): self.cc_data.add_derived(derives.derive_primitives) # initial conditions for the problem - problem = importlib.import_module("pyro.{}.problems.{}".format( - self.solver_name, self.problem_name)) - problem.init_data(self.cc_data, self.rp) + self.problem_func(self.cc_data, self.rp) if self.verbose > 0: print(my_data) diff --git a/pyro/swe/tests/test_swe.py b/pyro/swe/tests/test_swe.py index 1a6da5412..13744cd7f 100644 --- a/pyro/swe/tests/test_swe.py +++ b/pyro/swe/tests/test_swe.py @@ -1,7 +1,8 @@ import numpy as np from numpy.testing import assert_array_equal -import pyro.swe.simulation as sn +import pyro.swe.simulation as sim +from pyro.swe.problems import test from pyro.util import runparams @@ -24,7 +25,7 @@ def setup_method(self): self.rp.params["swe.grav"] = 1.0 - self.sim = sn.Simulation("swe", "test", self.rp) + self.sim = sim.Simulation("swe", "test", test.init_data, self.rp) self.sim.initialize() def teardown_method(self): @@ -39,10 +40,10 @@ def test_initializationst(self): def test_prim(self): # U -> q - q = sn.cons_to_prim(self.sim.cc_data.data, self.sim.ivars, self.sim.cc_data.grid) + q = sim.cons_to_prim(self.sim.cc_data.data, self.sim.ivars, self.sim.cc_data.grid) # q -> U - U = sn.prim_to_cons(q, self.sim.ivars, self.sim.cc_data.grid) + U = sim.prim_to_cons(q, self.sim.ivars, self.sim.cc_data.grid) assert_array_equal(U, self.sim.cc_data.data) def test_derives(self): diff --git a/pyro/tests/test_simulation.py b/pyro/tests/test_simulation.py index a15dddb90..b8954a7fe 100644 --- a/pyro/tests/test_simulation.py +++ b/pyro/tests/test_simulation.py @@ -1,5 +1,5 @@ import pyro.mesh.boundary as bnd -import pyro.simulation_null as sn +import pyro.simulation_null as sim from pyro.mesh import patch from pyro.util import runparams @@ -23,7 +23,7 @@ def setup_method(self): 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) + self.sim = sim.NullSimulation("test", "test", None, self.rp) myg = patch.Grid2d(8, 16) myd = patch.CellCenterData2d(myg) @@ -78,7 +78,7 @@ def test_grid_setup(): rp.params["mesh.ymin"] = 0.0 rp.params["mesh.ymax"] = 2.0 - g = sn.grid_setup(rp) + g = sim.grid_setup(rp) assert g.nx == 8 assert g.ny == 16 diff --git a/pyro/util/io_pyro.py b/pyro/util/io_pyro.py index 8188b53b3..2e72845a0 100644 --- a/pyro/util/io_pyro.py +++ b/pyro/util/io_pyro.py @@ -119,7 +119,7 @@ def read(filename): if solver_name is not None: solver = importlib.import_module(f"pyro.{solver_name}") - sim = solver.Simulation(solver_name, problem_name, None) + sim = solver.Simulation(solver_name, problem_name, None, None) sim.n = n sim.cc_data = myd sim.cc_data.t = t diff --git a/pyro/viscous_burgers/simulation.py b/pyro/viscous_burgers/simulation.py index a69858bab..bfbc7bfc4 100644 --- a/pyro/viscous_burgers/simulation.py +++ b/pyro/viscous_burgers/simulation.py @@ -1,49 +1,11 @@ -import importlib - from pyro.burgers import Simulation as burgers_sim from pyro.burgers import burgers_interface -from pyro.mesh import patch, reconstruction -from pyro.particles import particles -from pyro.simulation_null import bc_setup, grid_setup +from pyro.mesh import reconstruction from pyro.viscous_burgers import interface class Simulation(burgers_sim): - def initialize(self): - """ - Initialize the grid and variables for advection and set the initial - conditions for the chosen problem. - """ - - # create grid, self.rp contains mesh.nx and mesh.ny - my_grid = grid_setup(self.rp, ng=4) - - # create the variables - my_data = patch.CellCenterData2d(my_grid) - - # outputs: bc, bc_xodd and bc_yodd for reflection boundary cond - bc = bc_setup(self.rp)[0] - - # register variables in the data - # burgers equation advects velocity - - my_data.register_var("x-velocity", bc) - my_data.register_var("y-velocity", bc) - my_data.create() - - # holds various data, like time and registered variable. - self.cc_data = my_data - - if self.rp.get_param("particles.do_particles") == 1: - n_particles = self.rp.get_param("particles.n_particles") - particle_generator = self.rp.get_param("particles.particle_generator") - self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator) - - # now set the initial conditions for the problem - problem = importlib.import_module(f"pyro.viscous_burgers.problems.{self.problem_name}") - problem.init_data(self.cc_data, self.rp) - def evolve(self): """ Evolve the viscous burgers equation through one timestep.