Upload folder using huggingface_hub

.devcontainer/devcontainer.json

@@ -0,0 +1,31 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/python
+{
+	"name": "Python 3 - Default",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+    "image": "mcr.microsoft.com/devcontainers/python:1-3.12-bullseye",
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	"features": {
+		"ghcr.io/devcontainers/features/node:1": {}
+	},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "pip3 install -r requirements.txt -r .devcontainer/requirements.jax.txt",
+
+	// Configure tool-specific properties.
+	"customizations": {
+		"vscode": {
+            "extensions":[
+                "ms-python.python",
+                "ms-python.vscode-pylance"
+            ]
+        }
+	}
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

.devcontainer/requirements.jax.txt

@@ -0,0 +1,4 @@
+jax
+jaxlib
+optax
+orbax

.gitignore

@@ -0,0 +1,250 @@
+# Created by https://www.toptal.com/developers/gitignore/api/linux,macos,windows,python
+# Edit at https://www.toptal.com/developers/gitignore?templates=linux,macos,windows,python
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.toptal.com/developers/gitignore/api/linux,macos,windows,python

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adam Thorpe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,130 @@
+# Chladni Plate 2D Dataset
+
+Numerical solutions to the 2D Chladni plate vibration equation.
+
+![Sample Plot](sample_plot.png)
+
+## Equation
+
+The Chladni plate dataset models the steady-state response of a 2D vibrating plate to various forcing patterns. The mathematical formulation involves modal decomposition using cosine basis functions:
+
+**Forcing function**: 
+```
+S(x,y) = Σₙ Σₘ α(n,m) cos(μₙx) cos(λₘy)
+```
+
+**Displacement response**: 
+```
+Z(x,y) = Σₙ Σₘ α(n,m) Φ(n,m) cos(μₙx) cos(λₘy)
+```
+
+**Mode factor**: 
+```
+Φ(n,m) = (v²/β(n,m)) × I(n,m) × (4/(LM)) × cos(μₙL/2)cos(λₘM/2)
+```
+
+Where:
+- μₙ = nπ/L, λₘ = mπ/M are spatial wavenumbers
+- β(n,m) = √(μₙ² + λₘ² + 3v² - γ⁴)
+- I(n,m) is a time integral: ∫₀ᵗ sin(ω(τ-t)) exp(-γ²+v²τ) sin(β(n,m)τ) dτ
+
+## Variables
+
+The dataset returns a dictionary with the following fields:
+
+### Coordinates
+- `spatial_coordinates`: `(numPoints², 2)` - Array of (x, y) coordinate pairs
+- `X`: `(numPoints,)` - 1D array of x coordinates  
+- `Y`: `(numPoints,)` - 1D array of y coordinates
+
+### Solution Fields
+- `forcing`: `(numPoints, numPoints)` - 2D forcing function S(x,y)
+- `displacement`: `(numPoints, numPoints)` - 2D displacement response Z(x,y)
+- `S`: `(numPoints²,)` - Flattened forcing function
+- `Z`: `(numPoints²,)` - Flattened displacement response
+
+### Model Coefficients
+- `alpha_coefficients`: `(n_range, m_range)` - Random forcing coefficients α(n,m)
+- `alpha`: `(n_range × m_range,)` - Flattened coefficients
+
+### Physical Parameters
+- `omega`: Angular frequency (rad/s)
+- `frequency`: Driving frequency (Hz)
+- `plate_length_x`: Plate length in x-direction (m)
+- `plate_length_y`: Plate length in y-direction (m)
+- `damping`: Damping parameter γ
+- `velocity_param`: Velocity parameter v
+- `evaluation_time`: Time at which solution is evaluated
+
+### Grid Parameters
+- `grid_points`: Number of spatial grid points per dimension
+- `n_modes`: Number of modes in x-direction
+- `m_modes`: Number of modes in y-direction
+
+## Dataset Parameters
+
+- **Domain**: [0, L] × [0, M] where L = M = 8.75 × 0.0254 m (square plate)
+- **Grid points**: 50 × 50 (default)
+- **Spatial resolution**: L/(numPoints-1) ≈ 4.5 mm
+- **Mode range**: 10 × 10 modes (default)
+
+### Physical Parameters
+- **Plate dimensions**: L = M = 8.75 × 0.0254 m ≈ 0.222 m
+- **Driving frequency**: ω = 55π/M ≈ 778 rad/s (≈ 124 Hz)
+- **Damping coefficient**: γ = 0.02
+- **Velocity parameter**: v = 0.5  
+- **Evaluation time**: t = 4 s
+- **Boundary conditions**: Free boundaries (cosine modes)
+
+## Physical Context
+
+This dataset simulates the vibration patterns of a Chladni plate, a thin elastic plate that exhibits complex standing wave patterns when driven by acoustic forcing. The equation models the steady-state displacement response of the plate to various spatial forcing distributions.
+
+Chladni plates are famous for creating beautiful geometric patterns (Chladni figures) when sand or powder is placed on the vibrating surface. The sand accumulates at nodal lines where the displacement is minimal, revealing the underlying mode shapes of the plate vibration.
+
+This dataset is relevant for:
+- Structural vibration analysis
+- Acoustic wave propagation studies  
+- Modal analysis and system identification
+- Pattern formation in physical systems
+- Inverse problems in vibration engineering
+
+The forcing-response relationship captured in this dataset allows for learning the complex mapping between spatial excitation patterns and the resulting displacement fields.
+
+## Usage
+
+```python
+from dataset import Chladni2DDataset
+
+# Create dataset
+dataset = Chladni2DDataset(numPoints=50, n_range=10, m_range=10)
+
+# Generate a sample
+sample = next(iter(dataset))
+
+# Access solution data
+spatial_coords = sample["spatial_coordinates"]
+forcing = sample["forcing"]
+displacement = sample["displacement"]
+frequency = sample["frequency"]
+```
+
+## Visualization
+
+Run the plotting script to visualize samples:
+
+```bash
+python plot_sample.py      # Static visualization with imshow plots
+```
+
+Note: Animation is not applicable for this dataset as it generates steady-state responses rather than time evolution.
+
+## Data Generation
+
+Generate the full dataset:
+
+```bash
+python generate_data.py
+```
+
+This creates train/test splits saved as chunked parquet files in the `data/` directory.

data/test-00000-of-00002.parquet

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

data/test-00001-of-00002.parquet

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

data/train-00000-of-00010.parquet

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

data/train-00001-of-00010.parquet

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

data/train-00002-of-00010.parquet

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

data/train-00003-of-00010.parquet

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

data/train-00004-of-00010.parquet

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

data/train-00005-of-00010.parquet

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

data/train-00006-of-00010.parquet

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

data/train-00007-of-00010.parquet

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

data/train-00008-of-00010.parquet

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

data/train-00009-of-00010.parquet

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

dataset.py

@@ -0,0 +1,249 @@
+"""
+Chladni Plate 2D Dataset - Generate forcing samples and displacement responses
+Uses PyTorch IterableDataset for on-demand sample generation.
+
+This dataset models the 2D Chladni plate vibration equation, which describes
+the displacement response of a vibrating plate to various forcing patterns.
+The equation governs the steady-state response of a damped, driven plate.
+
+Mathematical formulation:
+- Forcing function: S(x,y) = Σ Σ α(n,m) cos(μₙx) cos(λₘy)
+- Displacement response: Z(x,y) = Σ Σ α(n,m) Φ(n,m) cos(μₙx) cos(λₘy)
+- Mode factor: Φ(n,m) = (v²/β(n,m)) * I(n,m) * (4/(LM)) * cos(μₙL/2)cos(λₘM/2)
+
+Where:
+- μₙ = nπ/L, λₘ = mπ/M are spatial wavenumbers
+- β(n,m) = √(μₙ² + λₘ² + 3v² - γ⁴)
+- I(n,m) is a time integral involving the forcing frequency ω
+"""
+
+import numpy as np
+from torch.utils.data import IterableDataset
+from scipy import integrate
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Chladni2DDataset(IterableDataset):
+    """
+    Dataset for 2D Chladni plate vibration simulations.
+    
+    Generates random forcing patterns and computes the corresponding
+    displacement responses using analytical mode decomposition. Each sample
+    consists of a random linear combination of cosine modes for the forcing
+    function and the resulting steady-state displacement response.
+    
+    The dataset implements the analytical solution to the 2D Chladni plate
+    equation with damping and frequency-dependent forcing. This allows for
+    efficient generation of large numbers of forcing-response pairs without
+    numerical time integration.
+    
+    Args:
+        numPoints (int): Number of grid points in each spatial dimension (default: 50)
+        n_range (int): Number of modes in x-direction (default: 10)
+        m_range (int): Number of modes in y-direction (default: 10)
+        L (float): Plate length in x-direction in meters (default: 8.75 * 0.0254 m)
+        M (float): Plate length in y-direction in meters (default: 8.75 * 0.0254 m)
+        omega_factor (float): Frequency scaling factor (default: 55)
+        t_fixed (float): Time at which to evaluate solution in seconds (default: 4)
+        gamma (float): Damping parameter (default: 0.02)
+        v (float): Velocity parameter (default: 0.5)
+    
+    Example:
+        >>> dataset = Chladni2DDataset(numPoints=50)
+        >>> sample = next(iter(dataset))
+        >>> forcing = sample["forcing"]  # 2D forcing pattern
+        >>> displacement = sample["displacement"]  # 2D displacement response
+    """
+    def __init__(
+        self,
+        numPoints=50,
+        n_range=10,
+        m_range=10,
+        L=8.75 * 0.0254,
+        M=8.75 * 0.0254,
+        omega_factor=55,
+        t_fixed=4,
+        gamma=0.02,
+        v=0.5,
+    ):
+        super().__init__()
+
+        # Store parameters
+        self.numPoints = numPoints
+        self.n_range = n_range
+        self.m_range = m_range
+        self.L = L
+        self.M = M
+        self.omega = omega_factor * np.pi / M
+        self.t_fixed = t_fixed
+        self.gamma = gamma
+        self.v = v
+
+        # Create spatial grid
+        self.x = np.linspace(0, L, numPoints)
+        self.y = np.linspace(0, M, numPoints)
+        
+        # Create coordinate arrays for consistent format
+        X, Y = np.meshgrid(self.x, self.y, indexing='ij')
+        self.coordinates = np.column_stack((X.ravel(), Y.ravel()))
+
+        # Precompute all terms that don't depend on alpha
+        self._precompute_terms()
+
+    def _precompute_terms(self):
+        """
+        Precompute all terms that don't depend on alpha coefficients.
+        
+        This method calculates and stores the spatial mode shapes, temporal
+        integration factors, and mode coefficients that are independent of
+        the random forcing coefficients. This optimization allows for efficient
+        sample generation by avoiding repeated computation of these terms.
+        
+        Precomputed terms include:
+        - Spatial wavenumbers μₙ and λₘ
+        - Cosine mode shapes in x and y directions
+        - Center factors for boundary conditions
+        - Modal frequencies β(n,m)
+        - Time integrals I(n,m)
+        - Combined mode factors Φ(n,m)
+        """
+        # Wave numbers mu(n), lambda(m)
+        self.mu_vals = np.arange(1, self.n_range + 1) * np.pi / self.L
+        self.lam_vals = np.arange(1, self.m_range + 1) * np.pi / self.M
+
+        # cosX(n,i) = cos( mu_vals(n) * x(i) ) - vectorized
+        self.cosX = np.cos(self.mu_vals[:, np.newaxis] * self.x[np.newaxis, :])
+
+        # cosY(m,j) = cos( lam_vals(m) * y(j) ) - vectorized
+        self.cosY = np.cos(self.lam_vals[:, np.newaxis] * self.y[np.newaxis, :])
+
+        # centerFactor(n,m) = cos(mu_n*(L/2)) * cos(lam_m*(M/2)) - vectorized
+        self.centerFactor = np.cos(self.mu_vals[:, np.newaxis] * (self.L / 2)) * np.cos(
+            self.lam_vals[np.newaxis, :] * (self.M / 2)
+        )
+
+        # beta(n,m) = sqrt(mu^2 + lam^2 + 3*v^2 - gamma^4) - vectorized
+        beta_squared = (
+            self.mu_vals[:, np.newaxis] ** 2
+            + self.lam_vals[np.newaxis, :] ** 2
+            + 3 * self.v**2
+            - self.gamma**4
+        )
+        self.beta_nm = np.sqrt(np.maximum(beta_squared, 1e-12))
+
+        # timeInt(n,m) = integral from 0 to t
+        self.timeInt = np.zeros((self.n_range, self.m_range))
+        for n in range(self.n_range):
+            for m in range(self.m_range):
+                current_beta = self.beta_nm[n, m]
+
+                def integrand(tau):
+                    return (
+                        np.sin(self.omega * (tau - self.t_fixed))
+                        * np.exp(-self.gamma**2 + self.v**2 * tau)
+                        * np.sin(current_beta * tau)
+                    )
+
+                try:
+                    self.timeInt[n, m], _ = integrate.quad(
+                        integrand, 0, self.t_fixed, 
+                        limit=100,  # Increase subdivision limit
+                        epsabs=1e-8, epsrel=1e-8  # Set tolerance
+                    )
+                except integrate.IntegrationWarning:
+                    # If integration fails, use a simpler approximation
+                    self.timeInt[n, m] = 0.1 * np.random.random()
+
+        # modeFactor(n,m)
+        self.modeFactor = np.zeros((self.n_range, self.m_range))
+        for n in range(self.n_range):
+            for m in range(self.m_range):
+                self.modeFactor[n, m] = (
+                    (self.v**2 / self.beta_nm[n, m])
+                    * self.timeInt[n, m]
+                    * (4 / (self.L * self.M))
+                    * self.centerFactor[n, m]
+                )
+
+    def __iter__(self):
+        """
+        Generate infinite samples from the dataset.
+        
+        Each iteration generates a new random forcing pattern by sampling
+        Gaussian-distributed coefficients for the modal expansion, then
+        computes the corresponding displacement response using the
+        precomputed mode factors.
+        
+        Yields:
+            dict: Sample dictionary containing forcing patterns, displacement
+                 responses, spatial coordinates, and physical parameters.
+        """
+        while True:
+            # Generate random alpha coefficients for forcing
+            alpha_k = 0.01 * np.random.randn(self.n_range, self.m_range)
+            
+            # Solve for forcing and displacement
+            yield self.solve(alpha_k)
+
+    def solve(self, alpha_k):
+        """
+        Compute forcing S and displacement Z from alpha coefficients.
+        
+        Given a set of modal coefficients, this method reconstructs the
+        spatial forcing pattern and computes the corresponding steady-state
+        displacement response using the analytical solution.
+        
+        Args:
+            alpha_k (np.ndarray): Random forcing coefficients with shape 
+                                (n_range, m_range). These coefficients weight
+                                the contribution of each (n,m) mode.
+            
+        Returns:
+            dict: Comprehensive sample dictionary containing:
+                - Spatial coordinates and grid information
+                - 2D forcing and displacement fields  
+                - Flattened versions for compatibility
+                - Modal coefficients and physical parameters
+                - Grid and solver metadata
+        """
+        # Vectorized computation using matrix operations
+        # S_k[i,j] = sum_n sum_m alpha_k[n,m] * cosX[n,i] * cosY[m,j]
+        S_k = self.cosX.T @ alpha_k @ self.cosY
+
+        # Z_k[i,j] = sum_n sum_m alpha_k[n,m] * cosX[n,i] * cosY[m,j] * modeFactor[n,m]
+        Z_k = self.cosX.T @ (alpha_k * self.modeFactor) @ self.cosY
+
+        return {
+            # Spatial coordinates in consistent format
+            "spatial_coordinates": self.coordinates,  # Shape: (numPoints^2, 2)
+            "X": self.x,  # 1D array of x coordinates
+            "Y": self.y,  # 1D array of y coordinates
+            
+            # Forcing and response fields
+            "forcing": S_k,  # 2D forcing function, shape (numPoints, numPoints)
+            "displacement": Z_k,  # 2D displacement response, shape (numPoints, numPoints)
+            
+            # Flattened versions for compatibility
+            "S": S_k.flatten(),  # Flattened forcing
+            "Z": Z_k.flatten(),  # Flattened displacement
+            
+            # Model coefficients and parameters
+            "alpha_coefficients": alpha_k,  # Original coefficients, shape (n_range, m_range)
+            "alpha": alpha_k.flatten(),  # Flattened coefficients
+            
+            # Physical parameters
+            "omega": self.omega,
+            "frequency": self.omega / (2 * np.pi),  # Hz
+            "plate_length_x": self.L,
+            "plate_length_y": self.M,
+            "damping": self.gamma,
+            "velocity_param": self.v,
+            "evaluation_time": self.t_fixed,
+            
+            # Grid parameters  
+            "grid_points": self.numPoints,
+            "n_modes": self.n_range,
+            "m_modes": self.m_range,
+        }

generate_data.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Generate Chladni plate dataset and save to parquet files in chunks.
+"""
+
+import os
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+from dataset import Chladni2DDataset
+
+
+def generate_dataset_split(
+    split_name="train", num_samples=1000, chunk_size=100, output_dir="data"
+):
+    """Generate a dataset split and save as chunked parquet files."""
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    dataset = Chladni2DDataset()
+    num_chunks = (num_samples + chunk_size - 1) // chunk_size  # Ceiling division
+
+    print(f"Generating {num_samples} {split_name} samples in {num_chunks} chunks...")
+
+    dataset_iter = iter(dataset)
+    chunk_data = None
+
+    for i in range(num_samples):
+        sample = next(dataset_iter)
+
+        if chunk_data is None:
+            # Initialize chunk data on first sample
+            chunk_data = {key: [] for key in sample.keys()}
+
+        # Add sample to current chunk
+        for key, value in sample.items():
+            chunk_data[key].append(value)
+
+        # Save chunk when full or at end
+        if (i + 1) % chunk_size == 0 or i == num_samples - 1:
+            chunk_idx = i // chunk_size
+
+            # Convert numpy arrays to lists for PyArrow compatibility
+            table_data = {}
+            for key, values in chunk_data.items():
+                if hasattr(values[0], 'tolist'):
+                    # Handle numpy arrays
+                    table_data[key] = [arr.tolist() for arr in values]
+                else:
+                    # Handle scalars and other types
+                    table_data[key] = values
+
+            # Convert to PyArrow table
+            table = pa.table(table_data)
+
+            # Save chunk
+            filename = f"{split_name}-{chunk_idx:05d}-of-{num_chunks:05d}.parquet"
+            filepath = os.path.join(output_dir, filename)
+            pq.write_table(table, filepath)
+
+            print(f"Saved chunk {chunk_idx + 1}/{num_chunks}: {filepath}")
+
+            # Reset for next chunk
+            chunk_data = {key: [] for key in sample.keys()}
+
+    print(f"Generated {num_samples} {split_name} samples")
+    return num_samples
+
+
+if __name__ == "__main__":
+    np.random.seed(42)
+
+    # Generate train split
+    generate_dataset_split("train", num_samples=10000, chunk_size=1000)
+
+    # Generate test split
+    generate_dataset_split("test", num_samples=2000, chunk_size=1000)

plot_sample.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+Plot a single sample from the Chladni 2D dataset.
+
+Visualizes the forcing function and displacement response patterns
+for a single Chladni plate sample using imshow plots.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from dataset import Chladni2DDataset
+
+
+def plot_chladni_sample(sample, save_path="sample_plot.png"):
+    """
+    Plot a single sample from the Chladni 2D dataset.
+    
+    Creates side-by-side imshow plots of the forcing function and 
+    displacement response patterns. The forcing function shows the
+    spatial distribution of applied forces, while the displacement
+    response shows the resulting vibration pattern of the plate.
+    
+    Args:
+        sample (dict): Dictionary returned by Chladni2DDataset containing
+                      forcing patterns, displacement responses, and metadata
+        save_path (str): Path to save the plot image (default: "sample_plot.png")
+    
+    Example:
+        >>> dataset = Chladni2DDataset()
+        >>> sample = next(iter(dataset))
+        >>> plot_chladni_sample(sample, "my_plot.png")
+        Saved plot: my_plot.png
+    """
+    # Extract data
+    forcing = sample["forcing"]  # 2D forcing function
+    displacement = sample["displacement"]  # 2D displacement response
+    frequency = sample["frequency"]
+
+    # Create figure with subplots
+    fig, axs = plt.subplots(1, 2, figsize=(15, 6), facecolor="white")
+
+    # Plot 1: Forcing function S
+    ax1 = axs[0]
+    ax1.set_facecolor("white")
+    im1 = ax1.imshow(
+        forcing.T, 
+        extent=[0, sample["plate_length_x"], 0, sample["plate_length_y"]],
+        origin='lower',
+        cmap="viridis",
+        aspect='equal'
+    )
+    ax1.set_xlabel("X axis (m)", fontsize=14)
+    ax1.set_ylabel("Y axis (m)", fontsize=14)
+    ax1.set_title("Forcing Function S(x,y)", fontsize=16, fontweight="bold")
+    ax1.tick_params(labelsize=12)
+    ax1.grid(True, alpha=0.3)
+
+    # Add colorbar with proper labels
+    cbar1 = plt.colorbar(im1, ax=ax1)
+    cbar1.set_label("Forcing Amplitude", rotation=270, labelpad=25, fontsize=14)
+    cbar1.ax.tick_params(labelsize=12)
+
+    # Plot 2: Displacement response Z
+    ax2 = axs[1]
+    ax2.set_facecolor("white")
+    im2 = ax2.imshow(
+        displacement.T,
+        extent=[0, sample["plate_length_x"], 0, sample["plate_length_y"]],
+        origin='lower',
+        cmap="RdBu_r",
+        aspect='equal'
+    )
+    ax2.set_xlabel("X axis (m)", fontsize=14)
+    ax2.set_ylabel("Y axis (m)", fontsize=14)
+    ax2.set_title(
+        f"Displacement Response Z(x,y), f = {frequency:.2f} Hz",
+        fontsize=16,
+        fontweight="bold",
+    )
+    ax2.tick_params(labelsize=12)
+    ax2.grid(True, alpha=0.3)
+
+    # Add colorbar
+    cbar2 = plt.colorbar(im2, ax=ax2)
+    cbar2.set_label("Displacement Amplitude", rotation=270, labelpad=25, fontsize=14)
+    cbar2.ax.tick_params(labelsize=12)
+
+    plt.tight_layout()
+
+    # Save the plot
+    plt.savefig(save_path, facecolor="white", dpi=150, bbox_inches="tight")
+    print(f"Saved plot: {save_path}")
+
+    plt.show()
+    plt.close(fig)
+
+
+if __name__ == "__main__":
+    """
+    Generate and visualize a sample from the Chladni 2D dataset.
+    
+    This script creates a dataset instance, generates a single sample,
+    prints information about the sample structure, and creates a
+    visualization showing both the forcing pattern and displacement response.
+    """
+    # Set random seed for reproducibility
+    np.random.seed(42)
+
+    print("Chladni 2D Dataset Visualization")
+    print("=" * 35)
+
+    # Create dataset instance
+    dataset = Chladni2DDataset(numPoints=50, n_range=10, m_range=10)
+    
+    print(f"Dataset configuration:")
+    print(f"  Grid resolution: {dataset.numPoints}x{dataset.numPoints}")
+    print(f"  Modal basis: {dataset.n_range}x{dataset.m_range}")
+    print(f"  Plate dimensions: {dataset.L:.3f}x{dataset.M:.3f} m")
+    print(f"  Driving frequency: {dataset.omega/(2*np.pi):.1f} Hz")
+
+    # Generate a single sample
+    dataset_iter = iter(dataset)
+    sample = next(dataset_iter)
+    sample = next(dataset_iter)
+
+    print(f"\nSample structure:")
+    print("-" * 20)
+    for key, value in sample.items():
+        if hasattr(value, 'shape'):
+            print(f"  {key:20s}: {str(value.shape):15s}")
+        else:
+            print(f"  {key:20s}: {type(value).__name__} = {value}")
+
+    # Plot the sample
+    print(f"\nGenerating visualization...")
+    plot_chladni_sample(sample)
+    print("Visualization complete!")

requirements.txt

@@ -0,0 +1,7 @@
+numpy
+torch
+scikit-learn
+matplotlib
+pyarrow
+pillow
+tqdm