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_discontinuous_chunk_2.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/test/acoustic_scattering_discontinuous_chunk_18.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_8.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_6.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_0.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_4.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_15.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_13.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_7.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/valid/acoustic_scattering_discontinuous_chunk_17.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_11.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_10.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_5.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_12.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/valid/acoustic_scattering_discontinuous_chunk_16.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_1.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_14.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/test/acoustic_scattering_discontinuous_chunk_19.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_9.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/train/acoustic_scattering_discontinuous_chunk_3.hdf5 filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,114 @@
+---
+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_discontinuous",
+)
+train_dataloader = datamodule.train_dataloader()
+
+for batch in dataloader:
+    # Process training batch
+    ...
+```
+
+# Acoustic Scattering - Single Discontinuity
+
+**One line description of the data:** Simple acoustic wave propogation over a domain split into two continuously varying sub-domains with a single discountinuous interface.
+
+**Longer description of the data:** These variable-coefficient acoustic equations describe the propogation of an acoustic pressure wave through domains consisting of multiple materials with different scattering properties. This problem emerges in source optimization and it's inverse - that of identifying the material properties from the scattering of the wave - is a vital problem in geology and radar design. This is the simplest of three scenarios. In this case, we have a variable number of initial point sources and single discontinuity separating two sub-domains. Within each subdomain, the density of the underlying material varies smoothly.
+
+**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 v} &= 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_discontinuous/gif/discontinuous_density.png)
+
+# About the data
+
+**Dimension of discretized data:** 101 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:** 157.7 GB.
+
+**Grid type:** uniform, cartesian coordinates.
+
+**Initial conditions:** Flat pressure static field with 1-4 high pressure rings randomly placed in domain. The rings are defined with variable intensity \\(\sim \mathcal U(.5, 2)\\) and radius \\(\sim \mathcal U(.06, .15)\\).
+
+**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/101.
+
+**Total time range (\\(t_{min}\\) to \\(t_{max}\\)):** [0, 2]
+
+**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. Each side is generated with one of the following distributions:
+  - Gaussian Bump - Peak density samples from \\(\sim\mathcal U(1, 7)\\) and \\(\sigma \sim\mathcal U(.1, 5)\\) with the center of the bump uniformly sampled from the extent of the subdomain.
+  - Linear gradient - Four corners sampled with \\(\rho \sim \mathcal U(1, 7)\\). Inner density is bilinearly interpolated.
+  - Constant - Constant \\(\rho \sim\mathcal U(1, 7)\\).
+  - Smoothed Gaussian Noise - Constant background sampled \\(\rho \sim\mathcal U(1, 7)\\) with IID standard normal noise applied. This is then smoothed by a Gaussian filter of varying sigma \\(\sigma \sim\mathcal U(5, 10)\\).
+
+**Approximate time to generate the data:** ~15 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:
+Wave propogation through discontinuous media. Most existing machine learning datasets for computational physics are highly smooth and the acoustic challenges presented here offer challenging discontinuous scenarios that approximate complicated geometry through the variable density.
+
+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_discontinuous.yaml

@@ -0,0 +1,28 @@
+dataset_name: acoustic_scattering_discontinuous
+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:
+- 102
+- 102
+grid_type: cartesian

data/test/acoustic_scattering_discontinuous_chunk_18.hdf5

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

data/test/acoustic_scattering_discontinuous_chunk_19.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_0.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_1.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_10.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_11.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_12.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_13.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_14.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_15.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_2.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_3.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_4.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_5.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_6.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_7.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_8.hdf5

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

data/train/acoustic_scattering_discontinuous_chunk_9.hdf5

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

data/valid/acoustic_scattering_discontinuous_chunk_16.hdf5

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

data/valid/acoustic_scattering_discontinuous_chunk_17.hdf5

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

generation/acoustics_2d_interface_random_medium.py

@@ -0,0 +1,297 @@
+#!/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 numpy as np
+from scipy.ndimage import gaussian_filter
+
+
+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,
+    include_splits=True,
+    include_inclusions=True,
+    T_max=2.0,
+    num_steps=101,
+):
+    """
+    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
+    is_vert = seed.integers(0, 2)
+    midpoint = seed.uniform(-0.8, 0.8)
+    rho_left = seed.uniform(0.2, 7)  # 4.0  # Density in left half
+    rho_right = seed.uniform(0.2, 7)  # 1.0  # Density in right half
+    bulk_left = 4.0  # Bulk modulus in left half
+    bulk_right = 4.0  # Bulk modulus in right half
+
+    def gaussian_bump(
+        aux, mask, seed, rho_low=1, rho_high=7.0, sigma_low=0.1, sigma_high=5
+    ):
+        rho_bump = seed.uniform(rho_low, rho_high)
+        rho_base = seed.uniform(rho_low, rho_high)
+
+        Xmask = X[mask]
+        xmax = Xmask.max()
+        xmin = Xmask.min()
+        Ymask = Y[mask]
+        ymax = Ymask.max()
+        ymin = Ymask.min()
+
+        xc = seed.uniform(xmin, xmax)
+        yc = seed.uniform(ymin, ymax)
+        sigma = seed.uniform(sigma_low, sigma_high)
+        rho = rho_base + (rho_bump - rho_base) * np.exp(
+            -((Xmask - xc) ** 2 + (Ymask - yc) ** 2) / (sigma)
+        )
+        c = np.sqrt(bulk_left / rho)
+        aux[0][mask] = rho
+        aux[1][mask] = c
+
+    def linear_gradient(aux, mask, seed, rho_low=1, rho_high=7.0):
+        rho_x0 = seed.uniform(rho_low, rho_high)
+        rho_x1 = seed.uniform(rho_low, rho_high)
+        rho_y0 = seed.uniform(rho_low, rho_high)
+        rho_y1 = seed.uniform(rho_low, rho_high)
+
+        # Bilinearly interpolate between the four values
+        Xmask = (X[mask] + 1) / 2
+        xmax = Xmask.max()
+        xmin = Xmask.min()
+        Ymask = (Y[mask] + 1) / 2
+        ymax = Ymask.max()
+        ymin = Ymask.min()
+
+        Xrel = (Xmask - xmin) / (xmax - xmin)
+        Yrel = (Ymask - ymin) / (ymax - ymin)
+
+        rho = (
+            (1 - Xrel) * (1 - Yrel) * rho_x0
+            + Xrel * (1 - Yrel) * rho_x1
+            + (1 - Xrel) * Yrel * rho_y0
+            + Xrel * Yrel * rho_y1
+        )
+        c = np.sqrt(bulk_left / rho)
+        aux[0][mask] = rho
+        aux[1][mask] = c
+
+    def constant(aux, mask, seed, rho_low=1, rho_high=7.0):
+        rho = seed.uniform(rho_low, rho_high)
+        c = np.sqrt(bulk_left / rho)
+        aux[0][mask] = rho
+        aux[1][mask] = c
+
+    def smoothed_gaussian_noise(
+        aux, mask, seed, rho_low=1, rho_high=7.0, std=2, sigma_low=5, sigma_high=10
+    ):
+        rho = seed.uniform(rho_low, rho_high)
+        background = seed.standard_normal(mask.shape)
+        sigma = seed.uniform(sigma_low, sigma_high)
+
+        background = gaussian_filter(background, sigma)
+        rho = rho + background[mask]
+        c = np.sqrt(bulk_left / rho)
+        aux[0][mask] = rho
+        aux[1][mask] = c
+
+    gen_funcs = [gaussian_bump, linear_gradient, constant, smoothed_gaussian_noise]
+
+    c_left = np.sqrt(bulk_left / rho_left)  # Sound speed (left)
+    if include_splits:
+        if is_vert:
+            mask = Y < midpoint
+        else:
+            mask = X < midpoint
+        seed.choice(gen_funcs)(state.aux, (~mask), seed)
+    else:
+        mask = np.ones_like(X, dtype=bool)
+    seed.choice(gen_funcs)(state.aux, mask, seed)
+
+    state.q[0, :, :] = 0.0
+    state.q[1, :, :] = 0.0
+    state.q[2, :, :] = 0.0
+    # Set initial condition
+    n_waves = seed.integers(1, 4)
+    for i in range(n_waves):
+        center = seed.uniform(-0.95, 0.95, 2)
+        x0 = center[0]
+        y0 = center[1]
+        width = seed.uniform(0.05, 0.15)
+        rad = seed.uniform(width + 0.01, 0.3)
+        intensity = seed.uniform(0.5, 2.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)
+        )
+
+    if include_inclusions:
+        n_inclusions = seed.integers(0, 15)
+        for i in range(n_inclusions):
+            # Copied elipse code from
+            g_ell_center = seed.uniform(-0.95, 0.95, 2)
+            rads = seed.uniform(0.05, 0.6, 2)
+            g_ell_width = rads[0]
+            g_ell_height = rads[1]
+            angle = seed.uniform(-45, 45)
+
+            cos_angle = np.cos(np.radians(180.0 - angle))
+            sin_angle = np.sin(np.radians(180.0 - angle))
+
+            xc = X - g_ell_center[0]
+            yc = Y - g_ell_center[1]
+
+            xct = xc * cos_angle - yc * sin_angle
+            yct = xc * sin_angle + yc * cos_angle
+
+            rad_cc = (xct**2 / (g_ell_width / 2.0) ** 2) + (
+                yct**2 / (g_ell_height / 2.0) ** 2
+            )
+
+            inclusion_rho = np.exp(seed.uniform(-1, 10))
+            # r = np.sqrt((X-x0)**2 + (Y-y0)**2)
+            c_left = np.sqrt(bulk_left / inclusion_rho)  # Sound speed (left)
+            state.aux[0][rad_cc <= 1] = inclusion_rho
+            state.aux[1][rad_cc <= 1] = c_left
+            state.q[0][rad_cc <= 1] = 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):
+    import matplotlib.pyplot as plt
+
+    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(42))
+    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_discontinuous.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_disccont
+#SBATCH -o acou_disccont
+#SBATCH -C icelake
+
+source ~/venvs/clawpack/bin/activate
+
+srun python generate_acoustics_data.py --discontinuity

stats.yaml

@@ -0,0 +1,14 @@
+mean:
+  bulk_modulus: 1.084273461543434
+  density: 3.958672131453937
+  pressure: 0.10382298641950555
+  velocity:
+  - 0.004736874341594803
+  - 0.005733050392328638
+std:
+  bulk_modulus: 0.27286848219233156
+  density: 1.5745694576257623
+  pressure: 0.31642700584198546
+  velocity:
+  - 0.05996821345863354
+  - 0.05960856047624785