Add files using upload-large-folder tool

.gitattributes

@@ -56,3 +56,23 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_2.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_15.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/valid/acoustic_scattering_maze_chunk_17.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_13.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/valid/acoustic_scattering_maze_chunk_16.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_10.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_5.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_3.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_6.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_4.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_14.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_0.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_1.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/test/acoustic_scattering_maze_chunk_18.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_8.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_7.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_11.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_12.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_maze_chunk_9.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/test/acoustic_scattering_maze_chunk_19.hdf5 filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,121 @@
+---
+language:
+- en
+license: cc-by-4.0
+tags:
+- physics
+
+task_categories:
+- time-series-forecasting
+- other
+task_ids:
+- multivariate-time-series-forecasting
+---
+
+# How To Load from HuggingFace Hub
+
+1. Be sure to have `the_well` installed (`pip install the_well`)
+2. Use the `WellDataModule` to retrieve data as follows:
+
+```python
+from the_well.benchmark.data import WellDataModule
+
+# The following line may take a couple of minutes to instantiate the datamodule
+datamodule = WellDataModule(
+    "hf://datasets/polymathic-ai/",
+    "acoustic_scattering_maze",
+)
+train_dataloader = datamodule.train_dataloader()
+
+for batch in dataloader:
+    # Process training batch
+    ...
+```
+
+# Acoustic Scattering - Maze
+
+**One line description of the data:** Simple acoustic wave propogation through maze-like structures.
+
+**Longer description of the data:** These variable-coefficient acoustic equations describe the propogation of an acoustic pressure wave through maze-like domains. Pressure waves emerge from point sources and propogate through domains consisting of low density maze paths and orders of magnitude higher density maze walls. This is built primarily as a challenge for machine learning methods, though has similar properties to optimal placement problems like WiFi in a building.
+
+**Domain expert**: [Michael McCabe](https://mikemccabe210.github.io/), Polymathic AI.
+
+**Code or software used to generate the data**: Clawpack,  adapted from [this example.](http://www.clawpack.org/gallery/pyclaw/gallery/acoustics_2d_interface.html)
+
+**Equation**:
+
+```math
+\begin{align}
+\frac{ \partial p}{\partial t} + K(x, y) \left( \frac{\partial u}{\partial x} + \frac{\partial v}{\partial y} \right) &= 0 \\
+\frac{ \partial u  }{\partial t} + \frac{1}{\rho(x, y)} \frac{\partial p}{\partial x} &= 0 \\
+\frac{ \partial v  }{\partial t} + \frac{1}{\rho(x, y)} \frac{\partial p}{\partial y} &= 0
+\end{align}
+```
+with \\(\rho\\) the material density, \\(u, v\\) the velocity in the \\(x, y\\) directions respectively, \\(p\\) the pressure, and \\(K\\) the bulk modulus.
+
+Example material densities can be seen below:
+
+![image](https://users.flatironinstitute.org/~polymathic/data/the_well/datasets/acoustic_scattering_maze/gif/mazes_density.png)
+
+Traversal can be seen:
+
+![Gif](https://users.flatironinstitute.org/~polymathic/data/the_well/datasets/acoustic_scattering_maze/gif/pressure_normalized.gif)
+
+| Dataset    | FNO | TFNO  | Unet | CNextU-net
+|:-:|:-:|:-:|:-:|:-:|
+| `acoustic_scattering_maze`  | 0.5062 | 0.5057| 0.0351| \\(\mathbf{0.0153}\\)|
+
+Table: VRMSE metrics on test sets (lower is better). Best results are shown in bold. VRMSE is scaled such that predicting the mean value of the target field results in a score of 1.
+
+# About the data
+
+**Dimension of discretized data:** 201 steps of 256 \\(\times\\) 256 images.
+
+**Fields available in the data:** pressure (scalar field), material density (constant scalar field), material speed of sound (constant scalar field), velocity field (vector field).
+
+**Number of trajectories:** 2000.
+
+**Estimated size of the ensemble of all simulations:** 311.3 GB.
+
+**Grid type:** uniform, cartesian coordinates.
+
+**Initial conditions:** Flat pressure static field with 1-6 high pressure rings randomly placed along paths of maze. The rings are defined with variable intensity \\(\sim \mathcal U(3., 5.)\\) and radius \\(\sim \mathcal U(.01, .04)\\). Any overlap with walls is removed.
+
+**Boundary conditions:** Open domain in \\(y\\), reflective walls in \\(x\\).
+
+**Simulation time-step:** Variable based on CFL with safety factor .25.
+
+**Data are stored separated by (\\(\Delta t\\)):** 2/201.
+
+**Total time range (\\(t_{min}\\) to \\(t_{max}\\)):** [0, 4.].
+
+**Spatial domain size (\\(L_x\\), \\(L_y\\)):** [-1, 1] x [-1, 1].
+
+**Set of coefficients or non-dimensional parameters evaluated:**
+
+- \\(K\\) is fixed at 4.0.
+
+- \\(\rho\\) is the primary coefficient here. We generated a maze with initial width between 6 and 16 pixels and upsample it via nearest neighbor resampling to create a 256 x 256 maze. The walls are set to \\(\rho=10^6\\) while paths are set to  \\(\rho=3\\).
+
+**Approximate time to generate the data:** ~20 minutes per simulation.
+
+**Hardware used to generate the data and precision used for generating the data:** 64 Intel Icelake cores per simulation. Generated in double precision.
+
+# What is interesting and challenging about the data:
+
+This is an example of simple dynamics in complicated geometry. The sharp discontinuities can be a significant problem for machine learning models, yet they are a common feature in many real-world physics. While visually the walls appear to stop the signal, it is actually simply the case that the speed of sound is much much lower inside the walls leading to partial reflection/absorbtion at the interfaces.
+
+
+Please cite the associated paper if you use this data in your research:
+
+```
+@article{mandli2016clawpack,
+  title={Clawpack: building an open source ecosystem for solving hyperbolic PDEs},
+  author={Mandli, Kyle T and Ahmadia, Aron J and Berger, Marsha and Calhoun, Donna and George, David L and Hadjimichael, Yiannis and Ketcheson, David I and Lemoine, Grady I and LeVeque, Randall J},
+  journal={PeerJ Computer Science},
+  volume={2},
+  pages={e68},
+  year={2016},
+  publisher={PeerJ Inc.}
+}
+```

acoustic_scattering_maze.yaml

@@ -0,0 +1,28 @@
+dataset_name: acoustic_scattering_maze
+n_spatial_dims: 2
+spatial_resolution:
+- 256
+- 256
+scalar_names: []
+constant_scalar_names: []
+field_names:
+  0:
+  - pressure
+  1:
+  - velocity_x
+  - velocity_y
+  2: []
+constant_field_names:
+  0:
+  - density
+  - speed_of_sound
+  1: []
+  2: []
+boundary_condition_types:
+- OPEN
+- WALL
+n_simulations: 2
+n_steps_per_simulation:
+- 202
+- 202
+grid_type: cartesian

data/test/acoustic_scattering_maze_chunk_18.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd7198b4227c902e258426d6dc99ca6bf5a28832abcb6050b0a7df303c8ab248
+size 15980298240

data/test/acoustic_scattering_maze_chunk_19.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:927cc101432e0efe9bfe5808a0a4afb08c8176fb300431f7624e5fe0d8a835ef
+size 15980298240

data/train/acoustic_scattering_maze_chunk_0.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93694c368e8bb7cec8bf4dc9524820981e4d02a4dc181a011ec3e41d7031c07e
+size 15980298240

data/train/acoustic_scattering_maze_chunk_1.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92585de6aaf0a57562b4f83b776eec66715d15a52fb84b09de5ee28a3db97ce5
+size 15980298240

data/train/acoustic_scattering_maze_chunk_10.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:448436567a51940ed8bc5127d5465e0272604e4b009ab495373251ed568a2c18
+size 15980298240

data/train/acoustic_scattering_maze_chunk_11.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79aba95ca7fca3ad8d74970263f2c1a5dd1f36623666b3d3bd6ba594520529bf
+size 15980298240

data/train/acoustic_scattering_maze_chunk_12.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f21aaf96fbf1be6699f6e6647c355df0e25f5bb3120768bbc04ead9a0609278
+size 15980298240

data/train/acoustic_scattering_maze_chunk_13.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d97d779f880b72caa10bdaffa2f049a1acf31b69ad59ce3596da1d0f3017c63
+size 15980298240

data/train/acoustic_scattering_maze_chunk_14.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e7bb146d0f4af87ca0d7d11ae3830402bc084c7451720f4a84627c862e656e4
+size 15980298240

data/train/acoustic_scattering_maze_chunk_15.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64bc378064b72534d88a2fe59d162599006938f250ce9638bf5f642a95e84a23
+size 15980298240

data/train/acoustic_scattering_maze_chunk_2.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de777cceebff1a0a1861ae1781e1a2edfdfc5bb805410481cfaf5dc25e6e7490
+size 15980298240

data/train/acoustic_scattering_maze_chunk_3.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94a7f3155f36078244a2df857861be39a4a2cbd9ebba1690601adc16ff1996b6
+size 15980298240

data/train/acoustic_scattering_maze_chunk_4.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebf5e08d3b9c60791a6a8fd3ca9da39587fe5b5100f3416e9f65ce94f024cd3b
+size 15980298240

data/train/acoustic_scattering_maze_chunk_5.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff2a462d42006c0be6418faf43b141b757551fd0e769f94dcdcd47edc4813e31
+size 15980298240

data/train/acoustic_scattering_maze_chunk_6.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e0d05bf5df449fefd005869c8d10041b6aba1d147fa160cd915475fb23e60e0
+size 15980298240

data/train/acoustic_scattering_maze_chunk_7.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d122b10420393649f8612ab677fddd04ff8bf06e14dee51d6f873496effc8b2
+size 15980298240

data/train/acoustic_scattering_maze_chunk_8.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a857a307c96e34c1d62202e1082f4f60a8c82629b79085ee76817ef8b082e30b
+size 15980298240

data/train/acoustic_scattering_maze_chunk_9.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3659717ee915394ffc6d9c3c9476bf54d40bfaa02dabc71f0af5b8ce49561270
+size 15980298240

data/valid/acoustic_scattering_maze_chunk_16.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36cca5d9775479f37d50ed94028d2e9590b369384da204adf1958e5091198ba4
+size 15980298240

data/valid/acoustic_scattering_maze_chunk_17.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70d471bb96ca25e3fc870c3da6ee2ccabea72656ee947c8ec243a55ad452c48d
+size 15980298240

generation/acoustics_2d_interface_maze.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python
+# encoding: utf-8
+r"""
+Two-dimensional variable-coefficient acoustics
+==============================================
+
+Solve the variable-coefficient acoustics equations in 2D:
+
+.. math::
+    p_t + K(x,y) (u_x + v_y) & = 0 \\
+    u_t + p_x / \rho(x,y) & = 0 \\
+    v_t + p_y / \rho(x,y) & = 0.
+
+Here p is the pressure, (u,v) is the velocity, :math:`K(x,y)` is the bulk modulus,
+and :math:`\rho(x,y)` is the density.
+
+This example shows how to solve a problem with variable coefficients.
+The left and right halves of the domain consist of different materials.
+"""
+
+from functools import partial
+
+import matplotlib.pyplot as plt
+import numpy as np
+from skimage.transform import resize
+
+
+def create_maze(dim, seed):
+    # Create a grid filled with walls
+    maze = np.ones((dim * 2 + 1, dim * 2 + 1))
+
+    # Define the starting point
+    x, y = (0, 0)
+    maze[2 * x + 1, 2 * y + 1] = 0
+
+    # Initialize the stack with the starting point
+    stack = [(x, y)]
+    while len(stack) > 0:
+        x, y = stack[-1]
+
+        # Define possible directions
+        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+        directions = seed.permutation(directions)
+
+        for dx, dy in directions:
+            nx, ny = x + dx, y + dy
+            if (
+                nx >= 0
+                and ny >= 0
+                and nx < dim
+                and ny < dim
+                and maze[2 * nx + 1, 2 * ny + 1] == 1
+            ):
+                maze[2 * nx + 1, 2 * ny + 1] = 0
+                maze[2 * x + 1 + dx, 2 * y + 1 + dy] = 0
+                stack.append((nx, ny))
+                break
+        else:
+            stack.pop()
+
+    # Create an entrance and an exit
+    maze[1, 0] = 0
+    maze[-2, -1] = 0
+
+    return maze
+
+
+def setup(
+    kernel_language="Fortran",
+    use_petsc=False,
+    outdir="./_output",
+    solver_type="classic",
+    time_integrator="SSP104",
+    lim_type=2,
+    disable_output=False,
+    num_cells=(256, 256),
+    seed=None,
+    T_max=4.0,
+    num_steps=201,
+):
+    """
+    Example python script for solving the 2d acoustics equations.
+    """
+    from clawpack import riemann
+
+    if seed is None:
+        seed = np.random.default_rng()
+    if use_petsc:
+        import clawpack.petclaw as pyclaw
+    else:
+        from clawpack import pyclaw
+
+    if solver_type == "classic":
+        solver = pyclaw.ClawSolver2D(riemann.vc_acoustics_2D)
+        solver.dimensional_split = False
+        solver.limiters = pyclaw.limiters.tvd.MC
+    elif solver_type == "sharpclaw":
+        solver = pyclaw.SharpClawSolver2D(riemann.vc_acoustics_2D)
+        solver.time_integrator = time_integrator
+        if time_integrator == "SSPLMMk2":
+            solver.lmm_steps = 3
+            solver.cfl_max = 0.25
+            solver.cfl_desired = 0.24
+
+    solver.bc_lower[0] = pyclaw.BC.wall
+    solver.bc_upper[0] = pyclaw.BC.extrap
+    solver.bc_lower[1] = pyclaw.BC.wall
+    solver.bc_upper[1] = pyclaw.BC.extrap
+    solver.aux_bc_lower[0] = pyclaw.BC.wall
+    solver.aux_bc_upper[0] = pyclaw.BC.extrap
+    solver.aux_bc_lower[1] = pyclaw.BC.wall
+    solver.aux_bc_upper[1] = pyclaw.BC.extrap
+
+    x = pyclaw.Dimension(-1.0, 1.0, num_cells[0], name="x")
+    y = pyclaw.Dimension(-1.0, 1.0, num_cells[1], name="y")
+    domain = pyclaw.Domain([x, y])
+
+    num_eqn = 3
+    num_aux = 2  # density, sound speed
+    state = pyclaw.State(domain, num_eqn, num_aux)
+
+    grid = state.grid
+    X, Y = grid.p_centers
+
+    def construct_maze_background(aux, seed, base_maze_low=3, base_maze_high=8):
+        maze_size = seed.integers(base_maze_low, base_maze_high + 1)
+        maze = create_maze(maze_size, seed)
+        maze = resize(maze, (aux[0].shape[-2], aux[0].shape[-1]), order=0)
+        rho = maze * 1e6 + 3
+        return rho
+
+    rho = construct_maze_background(state.aux, seed)
+    c = np.sqrt(4.0 / rho)
+    state.aux[0, :, :] = rho
+    state.aux[1, :, :] = c
+
+    state.q[0, :, :] = 0.0
+    state.q[1, :, :] = 0.0
+    state.q[2, :, :] = 0.0
+    # Set initial condition
+    n_waves = seed.integers(1, 6)
+    mask = rho < 100
+    for i in range(n_waves):
+        center_pixel = seed.choice(rho[mask].shape[0])
+        x0 = X[mask][center_pixel]
+        y0 = Y[mask][center_pixel]
+        width = seed.uniform(0.01, 0.02)
+        rad = seed.uniform(0.01, 0.04)
+        intensity = seed.uniform(3.0, 5.0)
+        # x0 = -0.5; y0 = 0.
+        r = np.sqrt((X - x0) ** 2 + (Y - y0) ** 2)
+        # width = 0.1; rad = 0.25
+        state.q[0, :, :] += (np.abs(r - rad) <= width) * (
+            intensity + np.cos(np.pi * (r - rad) / width)
+        )
+
+    state.q[0][~mask] = 0.0
+
+    claw = pyclaw.Controller()
+    claw.keep_copy = True
+    if disable_output:
+        claw.output_format = None
+    claw.solution = pyclaw.Solution(state, domain)
+    claw.solver = solver
+    claw.outdir = outdir
+    claw.tfinal = T_max
+    claw.num_output_times = num_steps
+    claw.write_aux_init = True
+    claw.setplot = setplot
+    claw.output_options = {"format": "binary"}
+    if use_petsc:
+        claw.output_options = {"format": "binary"}
+
+    return claw
+
+
+def setplot(plotdata):
+    """
+    Plot solution using VisClaw.
+
+    This example shows how to mark an internal boundary on a 2D plot.
+    """
+
+    from clawpack.visclaw import colormaps
+
+    plotdata.clearfigures()  # clear any old figures,axes,items data
+
+    # Figure for pressure
+    plotfigure = plotdata.new_plotfigure(name="Pressure", figno=0)
+
+    # Set up for axes in this figure:
+    plotaxes = plotfigure.new_plotaxes()
+    plotaxes.title = "Pressure"
+    plotaxes.scaled = True  # so aspect ratio is 1
+    plotaxes.afteraxes = mark_interface
+
+    # Set up for item on these axes:
+    plotitem = plotaxes.new_plotitem(plot_type="2d_pcolor")
+    plotitem.plot_var = 0
+    plotitem.pcolor_cmap = colormaps.yellow_red_blue
+    plotitem.add_colorbar = True
+    plotitem.pcolor_cmin = 0.0
+    plotitem.pcolor_cmax = 1.0
+
+    # Figure for x-velocity plot
+    plotfigure = plotdata.new_plotfigure(name="x-Velocity", figno=1)
+
+    # Set up for axes in this figure:
+    plotaxes = plotfigure.new_plotaxes()
+    plotaxes.title = "u"
+    plotaxes.afteraxes = mark_interface
+
+    plotitem = plotaxes.new_plotitem(plot_type="2d_pcolor")
+    plotitem.plot_var = 1
+    plotitem.pcolor_cmap = colormaps.yellow_red_blue
+    plotitem.add_colorbar = True
+    plotitem.pcolor_cmin = -0.3
+    plotitem.pcolor_cmax = 0.3
+
+    return plotdata
+
+
+def mark_interface(current_data):
+    plt.plot((0.0, 0.0), (-1.0, 1.0), "-k", linewidth=2)
+
+
+if __name__ == "__main__":
+    from clawpack.pyclaw.util import run_app_from_main
+
+    setup_wrapped = partial(setup, seed=np.random.default_rng(1))
+    output = run_app_from_main(setup_wrapped, setplot)

generation/generate_acoustics_data.py

@@ -0,0 +1,166 @@
+import argparse
+import multiprocessing as mp
+from functools import partial
+
+import numpy as np
+from acoustics_2d_interface_maze import setup as maze_setup
+from acoustics_2d_interface_random_medium import setup as random_setup
+
+# Time/steps/samples
+steps_map = {
+    "continuous": (2.0, 101, 2000),
+    "discontinuous": (2.0, 101, 2000),
+    "inclusions": (2.0, 101, 4000),
+    "maze": (4.0, 201, 2000),
+}
+
+
+def mp_wrapper(
+    seed,
+    discontinuous,
+    inclusions,
+    maze,
+    output_dir="/mnt/home/polymathic/ceph/the_well/testing_before_adding/clawpack_data/acoustics_2d_variable/",
+):
+    if discontinuous:
+        run_func = partial(
+            inner_gen_sample,
+            discontinuous=True,
+            inclusions=False,
+            maze=False,
+            output_dir=output_dir,
+        )
+        num_samples = 2000
+    elif inclusions:
+        run_func = partial(
+            inner_gen_sample,
+            discontinuous=False,
+            inclusions=True,
+            maze=False,
+            output_dir=output_dir,
+        )
+        num_samples = 4000
+    elif maze:
+        run_func = partial(
+            inner_gen_sample,
+            discontinuous=False,
+            inclusions=False,
+            maze=True,
+            output_dir=output_dir,
+        )
+        num_samples = 2000
+    else:
+        run_func = partial(
+            inner_gen_sample,
+            discontinuous=False,
+            inclusions=False,
+            maze=False,
+            output_dir=output_dir,
+        )
+        num_samples = 2000
+    cores = mp.cpu_count()
+    seeds = seed.spawn(num_samples)
+    with mp.Pool(cores // 2) as pool:
+        pool.map(run_func, seeds)
+    # run_func(seeds[0])
+
+
+def inner_gen_sample(
+    seed=0, discontinuous=False, inclusions=False, maze=False, output_dir=""
+):
+    """
+    Iterate num samples times and enerate sample file. Use
+    it to overwrite qinit, then run .make output to generate trajectory.
+
+    Make sure overwrite is False in the make file before running.
+    """
+    # Check conditions and set up names
+    file_suffix = f"{str(seed.bit_generator.seed_seq.entropy)}_{str(seed.bit_generator.seed_seq.spawn_key)}"
+    if discontinuous:
+        file_suffix = "discontinuous_" + file_suffix
+        run_func = partial(
+            random_setup,
+            seed=seed,
+            include_splits=True,
+            include_inclusions=False,
+            outdir=output_dir + file_suffix,
+            T_max=2.0,
+            num_steps=101,
+        )
+    elif inclusions:
+        file_suffix = "inclusions_" + file_suffix
+        run_func = partial(
+            random_setup,
+            seed=seed,
+            include_splits=True,
+            include_inclusions=True,
+            outdir=output_dir + file_suffix,
+            T_max=2.0,
+            num_steps=101,
+        )
+    elif maze:
+        file_suffix = "maze_" + file_suffix
+        run_func = partial(
+            maze_setup,
+            seed=seed,
+            outdir=output_dir + file_suffix,
+            T_max=4.0,
+            num_steps=201,
+        )
+    else:
+        file_suffix = "continuous_" + file_suffix
+        run_func = partial(
+            random_setup,
+            seed=seed,
+            include_splits=False,
+            include_inclusions=False,
+            outdir=output_dir + file_suffix,
+            T_max=2.0,
+            num_steps=101,
+        )
+
+    claw = run_func(output_dir + file_suffix)
+    claw.run()
+
+
+if __name__ == "__main__":
+    # print(len(gases))
+    parser = argparse.ArgumentParser(
+        description="Generate initial conditions for 2D Euler quadrants"
+    )
+    # parser.add_argument('--num_samples', type=int, default=1000, help='Number of samples to generate')
+    parser.add_argument(
+        "--discontinuity",
+        action="store_true",
+        help="Whether to generate random samples",
+    )
+    parser.add_argument(
+        "--inclusions", action="store_true", help="Whether to generate random samples"
+    )
+    parser.add_argument(
+        "--switch_to_maze",
+        action="store_true",
+        help="Whether to generate random samples",
+    )
+    # parser.add_argument('--bc', type=str, default='extrap', help='Boundary conditions')
+    # parser.add_argument('--gas_index', type=int, default=0, help='Index of gas to use (0-9 inclusive)')
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=0,
+        help="Seed for random samples - use different one per gas/bc if par",
+    )
+    parser.add_argument(
+        "--raw_output_dir",
+        type=str,
+        default=" /mnt/home/polymathic/ceph/the_well/testing_before_adding/clawpack_data/",
+        help="Directory to store raw output",
+    )
+    args = parser.parse_args()
+    seed = np.random.default_rng(
+        args.seed
+        + 100 * int(args.discontinuity)
+        + 1000 * int(args.inclusions)
+        + 10000 * int(args.switch_to_maze)
+    )
+    mp_wrapper(seed, args.discontinuity, args.inclusions, args.switch_to_maze)

generation/run_mazes.sh

@@ -0,0 +1,12 @@
+#!/bin/bash -l
+#SBATCH --time=24:00:00
+#SBATCH -p cmbas
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH -J acou_maze
+#SBATCH -o acou_maze
+#SBATCH -C icelake
+
+source ~/venvs/clawpack/bin/activate
+
+srun python generate_acoustics_data.py --switch_to_maze

stats.yaml

@@ -0,0 +1,14 @@
+mean:
+  bulk_modulus: 0.4914537656565528
+  density: 575388.1413726807
+  pressure: 0.011643124502395175
+  velocity:
+  - 7.811991663938063e-05
+  - 0.00013353731981243736
+std:
+  bulk_modulus: 0.5697618996294348
+  density: 494284.41251997923
+  pressure: 0.12435384628054441
+  velocity:
+  - 0.024985422681220726
+  - 0.025001445400120472