Upload folder using huggingface_hub

.devcontainer/devcontainer.json

@@ -0,0 +1,38 @@
+// 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 - Dedalus",
+	// 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/rocker-org/devcontainer-features/miniforge:2": {},
+		"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": "bash .devcontainer/setup.sh",
+	"containerEnv": {
+		"CONDA_DEFAULT_ENV": "dedalus3"
+	},
+ 
+	// Configure tool-specific properties.
+	"customizations": {
+		"vscode": {
+            "extensions":[
+                "ms-python.python",
+                "ms-python.vscode-pylance"
+            ],
+			"settings": {
+				"python.pythonPath": "/opt/conda/envs/dedalus3/bin/python"
+			}
+		}
+	}
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

.devcontainer/setup.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+set -e
+
+# Download the Dedalus install script to a temporary location
+DEDALUS_INSTALL_SCRIPT="$(mktemp)"
+curl -fsSL https://raw.githubusercontent.com/DedalusProject/dedalus_conda/master/conda_install_dedalus3.sh -o "$DEDALUS_INSTALL_SCRIPT"
+
+# Ensure conda is initialized (adjust path if needed for your container)
+if [ -f /opt/conda/etc/profile.d/conda.sh ]; then
+    source /opt/conda/etc/profile.d/conda.sh
+elif [ -f "$HOME/miniconda3/etc/profile.d/conda.sh" ]; then
+    source "$HOME/miniconda3/etc/profile.d/conda.sh"
+fi
+
+# Install Dedalus only if the environment does not exist
+if ! conda info --envs | grep -q dedalus3; then
+    conda activate base
+    bash "$DEDALUS_INSTALL_SCRIPT"
+fi
+
+
+conda activate dedalus3
+
+conda env config vars set OMP_NUM_THREADS=1
+conda env config vars set NUMEXPR_MAX_THREADS=1
+
+# Install additional Python packages from requirements.txt
+if [ -f requirements.txt ]; then
+    pip install -r requirements.txt
+fi
+
+# Clean up the temporary install script
+rm -f "$DEDALUS_INSTALL_SCRIPT"

.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,136 @@
+# Schrödinger Equation Dataset
+
+Numerical solutions to the 1D time-dependent Schrödinger equation with harmonic oscillator potential.
+
+![Sample Plot](sample_plot.png)
+
+## Equation
+
+**Time-dependent Schrödinger equation**:
+```
+iℏ ∂ψ/∂t = Ĥψ
+```
+
+where the Hamiltonian is:
+```
+Ĥ = -ℏ²/2m ∇² + V(x)
+```
+
+**Harmonic oscillator potential**:
+```
+V(x) = ½mω²x²
+```
+
+The complex wavefunction ψ = ψᵣ + iψᵢ is split into real and imaginary parts:
+- Real part: ∂ψᵣ/∂t = (ℏ/2m)∇²ψᵢ - V(x)ψᵢ/ℏ  
+- Imaginary part: ∂ψᵢ/∂t = -(ℏ/2m)∇²ψᵣ + V(x)ψᵣ/ℏ
+
+## Variables
+
+The dataset returns a dictionary with the following fields:
+
+### Coordinates
+- `spatial_coordinates`: `(Nx,)` - 1D spatial grid points x ∈ [-Lx/2, Lx/2]
+- `time_coordinates`: `(time_steps,)` - Time evolution points
+
+### Solution Fields  
+- `psi_r_initial`: `(Nx,)` - Real part of initial wavefunction
+- `psi_i_initial`: `(Nx,)` - Imaginary part of initial wavefunction
+- `psi_r_trajectory`: `(time_steps, Nx)` - Real part evolution
+- `psi_i_trajectory`: `(time_steps, Nx)` - Imaginary part evolution  
+- `state_trajectory`: `(time_steps, 2*Nx)` - Concatenated [ψᵣ, ψᵢ] for ML
+- `probability_density`: `(time_steps, Nx)` - |ψ|² probability density
+
+### Physical Quantities
+- `potential`: `(Nx,)` - Harmonic oscillator potential V(x) = ½mω²x²
+- `total_energy`: `(time_steps,)` - Total energy over time (conservation check)
+
+### Physical Parameters
+- `hbar`: Reduced Planck constant  
+- `mass`: Particle mass
+- `omega`: Harmonic oscillator frequency
+
+## Dataset Parameters
+
+- **Domain**: x ∈ [-10, 10] (symmetric around origin for harmonic oscillator)
+- **Grid points**: Nx = 256 (spectral resolution with Fourier basis)
+- **Time range**: [0, 2.0] (sufficient to see wave packet oscillations)
+- **Spatial resolution**: Δx ≈ 0.078 (domain length / grid points)  
+- **Temporal resolution**: Δt = 1e-3 (RK4 time stepping)
+
+### Physical Parameters
+- **Reduced Planck constant**: ℏ = 1.0
+- **Particle mass**: m = 1.0
+- **Harmonic oscillator frequency**: ω = 1.0  
+- **Boundary conditions**: Periodic (suitable for localized wave packets)
+
+### Initial Conditions
+- **Wave packet type**: Gaussian wave packets with random parameters
+- **Center position**: x₀ ∼ Uniform([-5, 5])
+- **Wave packet width**: σ ∼ Uniform([0.5, 2.0])
+- **Initial momentum**: k₀ ∼ Uniform([-2.0, 2.0])
+- **Amplitude**: A ∼ Uniform([0.5, 2.0]) (normalized after generation)
+
+## Physical Context
+
+This dataset simulates **quantum harmonic oscillator dynamics** governed by the time-dependent Schrödinger equation. The equation models the quantum mechanical evolution of a particle in a harmonic potential well V(x) = ½mω²x².
+
+**Key Physical Phenomena**:
+- **Wave packet oscillation**: Gaussian wave packets oscillate back and forth in the harmonic potential
+- **Quantum tunneling**: Wave function can extend into classically forbidden regions  
+- **Energy quantization**: Total energy is conserved and quantized in bound states
+- **Probability conservation**: |ψ|² integrates to 1 at all times
+- **Phase evolution**: Real and imaginary parts evolve with quantum phase relationships
+
+**Applications**:
+- **Quantum mechanics education**: Fundamental model system in quantum physics courses
+- **Atomic physics**: Models trapped atoms in harmonic potentials (laser cooling, optical traps)
+- **Quantum optics**: Describes coherent states and squeezed states of light
+- **Neural operator learning**: Provides rich training data for physics-informed machine learning
+- **Bose-Einstein condensates**: Mean-field dynamics in harmonic traps
+
+## Usage
+
+```python
+from dataset import SchrodingerDataset
+
+# Create dataset
+dataset = SchrodingerDataset(
+    Lx=20.0,                # Domain size
+    Nx=256,                 # Grid resolution
+    hbar=1.0, mass=1.0, omega=1.0,  # Physical parameters
+    stop_sim_time=2.0,      # Simulation time
+    timestep=1e-3
+)
+
+# Generate a sample
+sample = next(iter(dataset))
+
+# Access solution data
+x = sample["spatial_coordinates"]           # Spatial grid
+t = sample["time_coordinates"]             # Time points  
+psi_r = sample["psi_r_trajectory"]         # Real part evolution
+psi_i = sample["psi_i_trajectory"]         # Imaginary part evolution
+state = sample["state_trajectory"]         # Combined [ψᵣ, ψᵢ] for ML
+prob = sample["probability_density"]       # |ψ|² probability
+energy = sample["total_energy"]            # Energy conservation
+```
+
+## Visualization
+
+Run the plotting scripts to visualize samples:
+
+```bash
+python plot_sample.py      # Static visualization
+python plot_animation.py   # Animated 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:198996730dc120415309f4c34901d1ebdab5fa228adec1f5b06023027226599b
+size 43505176

data/test-00001-of-00002.parquet

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

data/train-00000-of-00010.parquet

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

data/train-00001-of-00010.parquet

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

data/train-00002-of-00010.parquet

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

data/train-00003-of-00010.parquet

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

data/train-00004-of-00010.parquet

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

data/train-00005-of-00010.parquet

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

data/train-00006-of-00010.parquet

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

data/train-00007-of-00010.parquet

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

data/train-00008-of-00010.parquet

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

data/train-00009-of-00010.parquet

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

dataset.py

@@ -0,0 +1,448 @@
+"""
+1D Time-Dependent Schrödinger Equation Dataset with Harmonic Oscillator Potential.
+
+Solves the time-dependent Schrödinger equation:
+    iℏ ∂ψ/∂t = Ĥψ
+where Ĥ = -ℏ²/2m ∇² + V(x) and V(x) = ½mω²x²
+
+The complex wavefunction ψ = ψᵣ + iψᵢ is split into real and imaginary parts,
+which are evolved separately and concatenated into a 2×Nx state vector.
+
+Physical applications: quantum mechanics, atom optics, Bose-Einstein condensates.
+"""
+
+import numpy as np
+from torch.utils.data import IterableDataset
+
+import dedalus.public as d3
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def generate_gaussian_wave_packet(x, x0, sigma, k0, amplitude=1.0):
+    """
+    Generate a Gaussian wave packet initial condition for the Schrödinger equation.
+    
+    Creates a localized wave packet: ψ(x) = A * exp[-(x-x₀)²/(2σ²)] * exp(ik₀x)
+    This represents a particle localized around position x₀ with momentum k₀.
+    
+    Args:
+        x: Spatial coordinates array
+        x0: Center position of the wave packet
+        sigma: Width parameter (standard deviation of Gaussian envelope)
+        k0: Initial momentum (wave number)
+        amplitude: Amplitude scaling factor
+        
+    Returns:
+        Complex wavefunction ψ = ψᵣ + iψᵢ as numpy array
+        
+    Notes:
+        The wave packet satisfies the normalization ∫|ψ|²dx = 1 after normalization
+        in the calling code.
+    """
+    envelope = amplitude * np.exp(-(x - x0)**2 / (2 * sigma**2))
+    phase = np.exp(1j * k0 * x)
+    return envelope * phase
+
+
+class SchrodingerDataset(IterableDataset):
+    """
+    Dataset for 1D time-dependent Schrödinger equation with harmonic oscillator potential.
+    
+    This dataset generates solutions to the quantum harmonic oscillator by solving:
+        iℏ ∂ψ/∂t = Ĥψ
+    where the Hamiltonian is:
+        Ĥ = -ℏ²/2m ∇² + V(x)
+    and the potential is:
+        V(x) = ½mω²x²
+    
+    The complex wavefunction ψ = ψᵣ + iψᵢ is split into real and imaginary parts
+    that are evolved separately using coupled PDEs:
+        ∂ψᵣ/∂t = (ℏ/2m)∇²ψᵢ - V(x)ψᵢ/ℏ
+        ∂ψᵢ/∂t = -(ℏ/2m)∇²ψᵣ + V(x)ψᵣ/ℏ
+        
+    For machine learning applications, the solution is provided as:
+    - Individual trajectories: ψᵣ(x,t) and ψᵢ(x,t)  
+    - Combined state vector: [ψᵣ, ψᵢ] with shape (2×Nx,)
+    - Probability density: |ψ|² = ψᵣ² + ψᵢ²
+    - Energy conservation: Total energy ⟨ψ|Ĥ|ψ⟩
+    
+    Physical Applications:
+        - Quantum mechanics education and visualization
+        - Trapped atom dynamics in optical/magnetic traps
+        - Bose-Einstein condensate mean-field dynamics
+        - Neural operator learning for quantum systems
+        
+    Mathematical Properties:
+        - Unitary evolution (probability conservation)
+        - Energy conservation in the absence of dissipation
+        - Spectral accuracy via Fourier pseudospectral methods
+    """
+    def __init__(
+        self,
+        # Domain parameters
+        Lx=20.0,                  # Domain length (centered around 0)
+        Nx=1024,                  # Number of grid points
+        
+        # Physical parameters
+        hbar=1.0,                 # Reduced Planck constant
+        mass=1.0,                 # Particle mass
+        omega=1.0,                # Harmonic oscillator frequency
+        
+        # Solver parameters
+        dealias=3/2,              # Dealiasing factor
+        stop_sim_time=5.0,        # Final simulation time
+        timestep=1e-3,            # Time step size
+        timestepper=d3.RK443,     # Time integration scheme
+        dtype=np.float64,
+    ):
+        """
+        Initialize Schrödinger equation dataset with harmonic oscillator potential.
+        
+        Sets up the numerical infrastructure to solve the time-dependent Schrödinger
+        equation using Dedalus spectral methods. Creates Fourier basis functions
+        for spatial derivatives and configures the coupled PDE system for real
+        and imaginary parts of the wavefunction.
+        
+        Mathematical Setup:
+            Domain: x ∈ [-Lx/2, Lx/2] with periodic boundary conditions
+            Grid: Nx Fourier modes with dealiasing for nonlinear terms
+            Time Integration: High-order Runge-Kutta schemes (RK443 recommended)
+            
+        Args:
+            Lx: Spatial domain length. Domain extends from -Lx/2 to +Lx/2.
+                Should be large enough to contain the wave packet throughout 
+                the simulation without significant boundary effects.
+            Nx: Number of Fourier modes. Higher values give better spatial
+                resolution. Recommended: 256-1024 for typical simulations.
+            hbar: Reduced Planck constant (ℏ). In natural units, often set to 1.
+            mass: Particle mass (m). Controls kinetic energy scale. 
+            omega: Harmonic oscillator frequency (ω). Sets potential energy scale
+                   and oscillation period T = 2π/ω.
+            dealias: Dealiasing factor for spectral methods. 3/2 removes aliasing
+                     for quadratic nonlinearities (standard for Schrödinger eq).
+            stop_sim_time: Maximum simulation time. Should be several oscillation
+                          periods (>> 2π/ω) to see full dynamics.
+            timestep: Time step size. Should satisfy CFL condition for stability.
+                      Recommended: dt ≤ 0.01 * (2π/ω) for accuracy.
+            timestepper: Dedalus time integration scheme. RK443 (4th order) 
+                        provides good accuracy/stability balance.
+            dtype: Floating point precision. np.float64 recommended for accuracy.
+                   
+        Raises:
+            ValueError: If domain or grid parameters are invalid.
+            ImportError: If Dedalus is not properly installed.
+        """
+        super().__init__()
+        
+        # Basic parameter validation
+        if Lx <= 0:
+            raise ValueError("Domain length Lx must be positive")
+        if Nx <= 0 or not isinstance(Nx, int):
+            raise ValueError("Grid points Nx must be a positive integer")
+        if hbar <= 0:
+            raise ValueError("Reduced Planck constant hbar must be positive")
+        if mass <= 0:
+            raise ValueError("Particle mass must be positive")
+        if omega <= 0:
+            raise ValueError("Oscillator frequency omega must be positive")
+        if timestep <= 0:
+            raise ValueError("Time step must be positive")
+        if stop_sim_time <= 0:
+            raise ValueError("Simulation time must be positive")
+        
+        # Store domain and grid parameters
+        self.Lx = Lx          # Physical domain size [-Lx/2, Lx/2]
+        self.Nx = Nx          # Number of Fourier modes for spatial resolution
+        
+        # Store physical parameters (in natural units where convenient)
+        self.hbar = hbar      # Reduced Planck constant - sets quantum scale
+        self.mass = mass      # Particle mass - affects kinetic energy
+        self.omega = omega    # Oscillator frequency - sets energy and time scales
+        
+        # Store numerical solver parameters
+        self.dealias = dealias              # Prevents aliasing in spectral methods
+        self.stop_sim_time = stop_sim_time  # Total evolution time
+        self.timestep = timestep            # Time step (must satisfy CFL condition)
+        self.timestepper = timestepper      # Runge-Kutta integration scheme
+        self.dtype = dtype                  # Floating point precision
+        
+        # Setup Dedalus spectral method infrastructure
+        self.xcoord = d3.Coordinate("x")     # Define spatial coordinate
+        self.dist = d3.Distributor(self.xcoord, dtype=dtype)  # Handle parallel distribution
+        
+        # Create Fourier basis: periodic functions on [-Lx/2, Lx/2]
+        # RealFourier uses cosines/sines, ideal for real-valued problems
+        self.xbasis = d3.RealFourier(self.xcoord, size=Nx, bounds=(-Lx/2, Lx/2), dealias=dealias)
+        
+        # Generate physical grid points for visualization and analysis
+        self.x = self.dist.local_grid(self.xbasis)
+
+    def __iter__(self):
+        """
+        Generate infinite samples from the dataset.
+        
+        Creates diverse quantum wave packet initial conditions by randomly sampling
+        Gaussian wave packet parameters. Each sample represents a different physical
+        scenario with varying localization, momentum, and energy.
+        
+        Initial Condition Generation:
+            1. Random wave packet center x₀ ~ U[-Lx/4, Lx/4] 
+            2. Random width σ ~ U[0.5, 2.0] (controls localization)
+            3. Random momentum k₀ ~ U[-2.0, 2.0] (initial velocity) 
+            4. Random amplitude A ~ U[0.5, 2.0] (before normalization)
+            5. Normalize to ensure ∫|ψ|²dx = 1 (probability conservation)
+            
+        Physics:
+            - Narrow wave packets (small σ) are highly localized but spread quickly
+            - Wide wave packets (large σ) are delocalized but maintain shape longer  
+            - Higher |k₀| gives faster initial motion and higher kinetic energy
+            - All initial conditions are proper quantum states (normalized)
+            
+        Yields:
+            Dict containing complete solution trajectory and physical quantities
+        """
+        while True:
+            # Generate random physical parameters for wave packet diversity
+            # Center position: avoid boundaries to prevent edge effects
+            x0 = np.random.uniform(-self.Lx/4, self.Lx/4)  
+            
+            # Wave packet width: balance between localization and numerical stability
+            sigma = np.random.uniform(0.5, 2.0)
+            
+            # Initial momentum: determines kinetic energy and motion direction
+            k0 = np.random.uniform(-2.0, 2.0)
+            
+            # Initial amplitude: will be normalized, but affects relative scales
+            amplitude = np.random.uniform(0.5, 2.0)
+            
+            # Generate complex Gaussian wave packet: ψ(x) = A*exp[-(x-x₀)²/2σ²]*exp(ik₀x)
+            # This represents a localized particle with definite momentum
+            # Use full grid from Dedalus (includes dealiasing padding) 
+            x_grid = self.x.ravel()  # Get full dealiased grid for initialization
+            psi_init = generate_gaussian_wave_packet(
+                x_grid, x0, sigma, k0, amplitude
+            )
+            
+            # Normalize wavefunction to satisfy quantum probability condition ∫|ψ|²dx = 1
+            # This ensures proper quantum state throughout evolution
+            norm = np.sqrt(np.trapezoid(np.abs(psi_init)**2, x_grid))
+            psi_init /= norm
+            
+            # Solve time-dependent Schrödinger equation and return full solution data
+            # Pass the complex initial condition (splitting happens in solve method)
+            yield self.solve(psi_init)
+
+    def solve(self, initial_condition):
+        """
+        Solve the time-dependent Schrödinger equation using spectral methods.
+        
+        Integrates the coupled PDE system forward in time using high-order
+        Runge-Kutta methods, storing snapshots of the solution and computing
+        physical quantities like energy for validation.
+        
+        Numerical Method:
+            - Spectral differentiation for spatial derivatives (machine precision)
+            - High-order Runge-Kutta time stepping (4th order RK443)
+            - Adaptive time step control via Dedalus CFL condition
+            - Energy monitoring for conservation verification
+            
+        Args:
+            initial_condition: Complex initial wavefunction ψ(x,0) = ψᵣ + iψᵢ
+
+        Returns:
+            Dictionary containing:
+                - Solution trajectories: ψᵣ(x,t), ψᵢ(x,t), |ψ(x,t)|²
+                - Coordinate arrays: spatial grid x, time points t
+                - ML-ready state vector: concatenated [ψᵣ, ψᵢ]  
+                - Physical quantities: total energy, potential V(x)
+                - System parameters: ℏ, m, ω for reproducibility
+                
+        Note:
+            Energy should be conserved to within numerical precision.
+            Large energy drift indicates time step is too large or
+            simulation time exceeds numerical stability limits.
+        """
+        # Setup PDE fields for real and imaginary parts of wavefunction
+        # These will store ψᵣ(x,t) and ψᵢ(x,t) at each time step
+        psi_r = self.dist.Field(name="psi_r", bases=self.xbasis)  # Real part ψᵣ
+        psi_i = self.dist.Field(name="psi_i", bases=self.xbasis)  # Imaginary part ψᵢ
+        
+        # Define spatial derivative operator for kinetic energy term
+        # d/dx operator using spectral differentiation (exact for polynomials)
+        dx = lambda A: d3.Differentiate(A, self.xcoord)
+        
+        # Create harmonic oscillator potential V(x) = ½mω²x²
+        # This confines the quantum particle to oscillate around x=0
+        V = self.dist.Field(name="V", bases=self.xbasis)
+        V['g'] = 0.5 * self.mass * (self.omega * self.x)**2  # Set grid values
+        
+        # Setup coupled PDE system for real and imaginary parts
+        # 
+        # Starting from the Schrödinger equation: iℏ ∂ψ/∂t = Ĥψ
+        # where Ĥ = -ℏ²/2m ∇² + V(x) and ψ = ψᵣ + iψᵢ
+        #
+        # Substituting ψ = ψᵣ + iψᵢ and separating real/imaginary parts:
+        # Real part:      ∂ψᵣ/∂t = (ℏ/2m)∇²ψᵢ - V(x)ψᵢ/ℏ
+        # Imaginary part: ∂ψᵢ/∂t = -(ℏ/2m)∇²ψᵣ + V(x)ψᵣ/ℏ
+        #
+        # These equations are coupled: ψᵣ evolution depends on ψᵢ and vice versa
+        # This preserves the unitary evolution and probability conservation
+        
+        # Create namespace with all variables for Dedalus equation parser
+        hbar = self.hbar
+        mass = self.mass
+        namespace = locals()  # Include all local variables (hbar, mass, dx, etc.)
+        
+        # Define the initial value problem with two coupled fields
+        problem = d3.IVP([psi_r, psi_i], namespace=namespace)
+        
+        # Add the coupled evolution equations
+        # Note: dx(dx(field)) computes the second derivative ∇²field
+        problem.add_equation("dt(psi_r) - (hbar/(2*mass))*dx(dx(psi_i)) = - V*psi_i/hbar")
+        problem.add_equation("dt(psi_i) + (hbar/(2*mass))*dx(dx(psi_r)) = V*psi_r/hbar")
+        
+        # Split complex initial condition into real and imaginary parts
+        # This converts ψ = ψᵣ + iψᵢ to two real-valued fields for the PDE solver
+        psi_r_init = np.real(initial_condition)  # Real component ψᵣ(x,0)
+        psi_i_init = np.imag(initial_condition)  # Imaginary component ψᵢ(x,0)
+        
+        # Set initial conditions in Dedalus fields
+        # ['g'] accessor sets grid point values directly
+        psi_r['g'] = psi_r_init  # Initialize real part ψᵣ(x,0)
+        psi_i['g'] = psi_i_init  # Initialize imaginary part ψᵢ(x,0)
+        
+        # Build time integrator from the PDE system
+        # This compiles the equations and sets up the Runge-Kutta stepper
+        solver = problem.build_solver(self.timestepper)
+        solver.stop_sim_time = self.stop_sim_time  # Set maximum evolution time
+        
+        # Initialize storage arrays for solution snapshots
+        # ['g', 1] gets grid values in proper layout for post-processing
+        psi_r_list = [psi_r['g', 1].copy()]  # Store ψᵣ(x,t) snapshots
+        psi_i_list = [psi_i['g', 1].copy()]  # Store ψᵢ(x,t) snapshots
+        t_list = [solver.sim_time]                # Store corresponding time values
+        energy_list = []                          # Store energy for conservation check
+        
+        # Calculate initial total energy E = ⟨ψ|Ĥ|ψ⟩
+        # This should be conserved throughout the evolution (Hamiltonian is Hermitian)
+        x_1d = self.x.ravel()                    # Get full grid for energy calculation
+        dx = x_1d[1] - x_1d[0]                   # Uniform grid spacing for integration
+        energy_initial = self._compute_energy(psi_r_init, psi_i_init, V, dx)
+        energy_list.append(energy_initial)
+        
+        # Main time evolution loop
+        # Save snapshots periodically to avoid memory issues while capturing dynamics
+        save_frequency = max(1, int(0.05 / self.timestep))  # Save every ~0.05 time units
+        
+        while solver.proceed:  # Continue until stop_sim_time reached
+            # Advance solution by one time step using Runge-Kutta
+            solver.step(self.timestep)
+            
+            # Periodically store snapshots for analysis/visualization
+            if solver.iteration % save_frequency == 0:
+                # Extract current wavefunction components from Dedalus fields
+                psi_r_current = psi_r['g', 1].copy()  # Current real part
+                psi_i_current = psi_i['g', 1].copy()  # Current imaginary part
+                
+                # Store snapshot data
+                psi_r_list.append(psi_r_current)
+                psi_i_list.append(psi_i_current)
+                t_list.append(solver.sim_time)
+                
+                # Monitor energy conservation (should remain constant)
+                energy = self._compute_energy(psi_r_current, psi_i_current, V, dx)
+                energy_list.append(energy)
+        
+        # Convert to numpy arrays
+        psi_r_trajectory = np.array(psi_r_list)
+        psi_i_trajectory = np.array(psi_i_list)
+        time_coordinates = np.array(t_list)
+        energy_trajectory = np.array(energy_list)
+
+        # Compute probability density |ψ|²
+        prob_density = psi_r_trajectory**2 + psi_i_trajectory**2
+        
+        # Create combined state vector (concatenate real and imaginary parts)
+        state_trajectory = np.concatenate([psi_r_trajectory, psi_i_trajectory], axis=1)
+        
+        # Compute potential energy at grid points  
+        V_values = V['g', 1].copy()
+        
+        return {
+            # Coordinates
+            "spatial_coordinates": self.x.ravel(),
+            "time_coordinates": time_coordinates,
+            
+            # Initial conditions
+            "psi_r_initial": psi_r_init,
+            "psi_i_initial": psi_i_init,
+            
+            # Solution trajectories
+            "psi_r_trajectory": psi_r_trajectory,
+            "psi_i_trajectory": psi_i_trajectory,
+            "state_trajectory": state_trajectory,        # Combined (2*Nx,) for ML
+            "probability_density": prob_density,         # |ψ|²
+            
+            # Physical quantities
+            "potential": V_values,                       # Harmonic oscillator potential
+            "total_energy": energy_trajectory,           # Energy conservation check
+            
+            # Physical parameters
+            "hbar": self.hbar,
+            "mass": self.mass,
+            "omega": self.omega,
+        }
+    
+    def _compute_energy(self, psi_r, psi_i, V_field, dx):
+        """
+        Compute total energy of the quantum system using wavefunction components.
+        
+        Calculates the expectation value of the Hamiltonian: E = ⟨ψ|Ĥ|ψ⟩
+        where Ĥ = -ℏ²/2m ∇² + V(x) is the quantum harmonic oscillator Hamiltonian.
+        
+        The energy should be conserved during unitary evolution, making this
+        a crucial diagnostic for numerical accuracy and stability.
+        
+        Mathematical Details:
+            Total Energy: E = T + V
+            Kinetic Energy: T = -ℏ²/2m ∫ ψ*(x) ∇²ψ(x) dx
+            Potential Energy: V = ∫ |ψ(x)|² V(x) dx
+            
+        For split wavefunction ψ = ψᵣ + iψᵢ:
+            T = -ℏ²/2m ∫ [ψᵣ ∇²ψᵣ + ψᵢ ∇²ψᵢ] dx
+            V = ∫ [ψᵣ² + ψᵢ²] V(x) dx
+            
+        Args:
+            psi_r: Real part of wavefunction at current time
+            psi_i: Imaginary part of wavefunction at current time
+            V_field: Potential field from Dedalus
+            dx: Spatial grid spacing for numerical integration
+            
+        Returns:
+            Total energy (float): Should be conserved throughout evolution
+            
+        Note:
+            Uses finite differences for spatial derivatives. For high accuracy,
+            the Dedalus spectral derivatives could be used instead, but this
+            simple approach is sufficient for energy monitoring.
+        """
+        # Compute kinetic energy: T = -ℏ²/2m ⟨ψ|∇²ψ⟩
+        # For complex ψ = ψᵣ + iψᵢ: T = -ℏ²/2m ∫[ψᵣ∇²ψᵣ + ψᵢ∇²ψᵢ] dx
+        # Use second-order finite differences for ∇² approximation
+        psi_r_xx = np.gradient(np.gradient(psi_r, dx), dx)  # ∂²ψᵣ/∂x²
+        psi_i_xx = np.gradient(np.gradient(psi_i, dx), dx)  # ∂²ψᵢ/∂x²
+        
+        # Integrate kinetic energy density over space
+        kinetic = -(self.hbar**2)/(2*self.mass) * np.trapezoid(
+            psi_r * psi_r_xx + psi_i * psi_i_xx, dx=dx
+        )
+        
+        # Compute potential energy: V = ⟨ψ|V|ψ⟩ = ∫ |ψ(x)|² V(x) dx
+        # Probability density |ψ|² = ψᵣ² + ψᵢ² weighted by potential
+        V_values = V_field['g', 1]  # Extract potential values from Dedalus field
+        potential = np.trapezoid((psi_r**2 + psi_i**2) * V_values, dx=dx)
+        
+        # Total energy = kinetic + potential (should be conserved)
+        return kinetic + potential

generate_data.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+Generate Schrödinger equation dataset and save to parquet files in chunks.
+
+Creates samples of 1D time-dependent Schrödinger equation solutions
+with harmonic oscillator potential and random Gaussian wave packet
+initial conditions.
+"""
+
+import os
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+from dataset import SchrodingerDataset
+
+
+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.
+    
+    INSTRUCTIONS FOR CLAUDE:
+    - This function should work as-is for any dataset following the template
+    - Only modify the dataset instantiation below if you need custom parameters
+    """
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Create Schrödinger dataset with appropriate parameters
+    dataset = SchrodingerDataset(
+        Lx=20.0,                # Domain length
+        Nx=256,                 # Grid points (reduced for faster generation)
+        hbar=1.0,               # Physical parameters
+        mass=1.0,
+        omega=1.0,
+        stop_sim_time=2.0,      # Shorter simulation time for dataset generation
+        timestep=1e-3,
+    )
+    
+    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 data to PyArrow-compatible format
+            table_data = {}
+            for key, values in chunk_data.items():
+                # Handle both arrays and scalars
+                converted_values = []
+                for value in values:
+                    if hasattr(value, 'tolist'):
+                        converted_values.append(value.tolist())
+                    else:
+                        converted_values.append(value)
+                table_data[key] = converted_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=1000, chunk_size=100)
+
+    # Generate test split
+    generate_dataset_split("test", num_samples=200, chunk_size=100)

plot_animation.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""
+Generate an animation GIF of a single Schrödinger equation sample time evolution.
+
+Animates quantum wave packet dynamics including:
+- Real and imaginary parts of wavefunction
+- Probability density |ψ|²
+- Wave packet motion in harmonic potential
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from dataset import SchrodingerDataset
+
+
+def create_schrodinger_animation(sample, save_path="sample_animation.gif", fps=15):
+    """Create an animation GIF from a Schrödinger sample"""
+    # Extract data
+    x = sample['spatial_coordinates']
+    t = sample['time_coordinates']
+    psi_r = sample['psi_r_trajectory']
+    psi_i = sample['psi_i_trajectory']
+    prob = sample['probability_density']
+    V = sample['potential']
+    energy = sample['total_energy']
+    
+    # Set up the figure with subplots
+    fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(12, 10))
+    fig.suptitle(f'Quantum Harmonic Oscillator Evolution\n' + 
+                 f'ℏ={sample["hbar"]}, m={sample["mass"]}, ω={sample["omega"]}', 
+                 fontsize=14, fontweight='bold')
+    
+    # Colors for consistency
+    color_real = '#1f77b4'
+    color_imag = '#ff7f0e'
+    color_prob = '#2ca02c'
+    color_potential = '#d62728'
+    
+    # Subplot 1: Wavefunction components
+    ax1.set_xlim(x[0], x[-1])
+    psi_max = max(np.max(np.abs(psi_r)), np.max(np.abs(psi_i))) * 1.1
+    ax1.set_ylim(-psi_max, psi_max)
+    ax1.set_ylabel('ψ(x,t)')
+    ax1.set_title('Wavefunction Components')
+    ax1.grid(True, alpha=0.3)
+    
+    # Plot potential well (scaled for background)
+    V_scaled = V / np.max(V) * psi_max * 0.2
+    ax1.fill_between(x, -psi_max, V_scaled - psi_max, alpha=0.1, color=color_potential)
+    ax1.plot(x, V_scaled - psi_max, '--', alpha=0.5, color=color_potential, linewidth=1, label='V(x)')
+    
+    real_line, = ax1.plot([], [], color=color_real, linewidth=2, label='ψᵣ(x,t)')
+    imag_line, = ax1.plot([], [], color=color_imag, linewidth=2, label='ψᵢ(x,t)')
+    ax1.legend(loc='upper right')
+    
+    # Subplot 2: Probability density
+    ax2.set_xlim(x[0], x[-1])
+    prob_max = np.max(prob) * 1.1
+    ax2.set_ylim(0, prob_max)
+    ax2.set_ylabel('|ψ(x,t)|²')
+    ax2.set_title('Probability Density')
+    ax2.grid(True, alpha=0.3)
+    
+    # Plot potential well (scaled for background)
+    V_scaled_prob = V / np.max(V) * prob_max * 0.3
+    ax2.fill_between(x, V_scaled_prob, alpha=0.2, color=color_potential)
+    
+    prob_line, = ax2.plot([], [], color=color_prob, linewidth=2, label='|ψ|²')
+    ax2.legend(loc='upper right')
+    
+    # Subplot 3: Energy over time
+    ax3.set_xlim(t[0], t[-1])
+    E_mean = np.mean(energy)
+    E_range = np.max(energy) - np.min(energy)
+    if E_range > 0:
+        ax3.set_ylim(np.min(energy) - 0.1*E_range, np.max(energy) + 0.1*E_range)
+    else:
+        ax3.set_ylim(E_mean - 0.1*abs(E_mean), E_mean + 0.1*abs(E_mean))
+        
+    ax3.set_xlabel('Time t')
+    ax3.set_ylabel('Total Energy')
+    ax3.set_title('Energy Conservation')
+    ax3.grid(True, alpha=0.3)
+    
+    # Plot full energy trace as background
+    ax3.plot(t, energy, 'k-', alpha=0.3, linewidth=1)
+    ax3.axhline(E_mean, color='red', linestyle='--', alpha=0.7, linewidth=1)
+    
+    # Current energy point
+    energy_point, = ax3.plot([], [], 'o', color='darkgreen', markersize=8)
+    energy_line, = ax3.plot([], [], color='darkgreen', linewidth=2)
+    
+    # Time text
+    time_text = fig.text(0.02, 0.02, '', fontsize=12, fontweight='bold',
+                        bbox=dict(boxstyle="round,pad=0.3", facecolor='yellow', alpha=0.7))
+    
+    # Store fill object
+    prob_fill = None
+    
+    def animate(frame):
+        """Animation function"""
+        nonlocal prob_fill
+        
+        # Update wavefunction components
+        real_line.set_data(x, psi_r[frame])
+        imag_line.set_data(x, psi_i[frame])
+        
+        # Update probability density
+        prob_line.set_data(x, prob[frame])
+        
+        # Remove old fill and create new one
+        if prob_fill is not None:
+            prob_fill.remove()
+        prob_fill = ax2.fill_between(x, prob[frame], alpha=0.3, color=color_prob)
+        
+        # Update energy plot
+        current_t = t[:frame+1]
+        current_e = energy[:frame+1]
+        energy_line.set_data(current_t, current_e)
+        energy_point.set_data([t[frame]], [energy[frame]])
+        
+        # Update time display
+        time_text.set_text(f'Time: {t[frame]:.3f} / {t[-1]:.3f}')
+        
+        return real_line, imag_line, prob_line, energy_line, energy_point, time_text
+    
+    # Create animation with more frames for smoother motion
+    print(f"Creating animation with {len(t)} frames...")
+    anim = animation.FuncAnimation(
+        fig, animate, frames=len(t),
+        interval=1000/fps, blit=False, repeat=True  # blit=False due to fill_between
+    )
+    
+    # Save as GIF
+    print(f"Saving animation to {save_path}...")
+    anim.save(save_path, writer='pillow', fps=fps)
+    plt.close()
+    
+    print(f"Animation saved to {save_path}")
+
+
+def create_simple_animation(sample, save_path="simple_animation.gif", fps=15):
+    """Create a simpler single-panel animation focusing on probability density"""
+    # Extract data
+    x = sample['spatial_coordinates']
+    t = sample['time_coordinates']
+    prob = sample['probability_density']
+    V = sample['potential']
+    
+    # Set up single plot
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.set_xlim(x[0], x[-1])
+    prob_max = np.max(prob) * 1.1
+    ax.set_ylim(0, prob_max)
+    ax.set_xlabel('Position x')
+    ax.set_ylabel('Probability Density |ψ|²')
+    ax.set_title(f'Quantum Wave Packet in Harmonic Oscillator\n' +
+                 f'ℏ={sample["hbar"]}, m={sample["mass"]}, ω={sample["omega"]}')
+    ax.grid(True, alpha=0.3)
+    
+    # Plot potential well (scaled)
+    V_scaled = V / np.max(V) * prob_max * 0.3
+    ax.fill_between(x, V_scaled, alpha=0.2, color='red', label='V(x) (scaled)')
+    ax.plot(x, V_scaled, 'r--', alpha=0.7, linewidth=1)
+    
+    # Initialize probability line
+    prob_line, = ax.plot([], [], 'b-', linewidth=3, label='|ψ(x,t)|²')
+    
+    # Time text
+    time_text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=12,
+                       bbox=dict(boxstyle="round", facecolor='white', alpha=0.8))
+    
+    ax.legend()
+    
+    # Store fill object
+    prob_fill = None
+    
+    def animate(frame):
+        """Simple animation function"""
+        nonlocal prob_fill
+        
+        # Update probability line
+        prob_line.set_data(x, prob[frame])
+        
+        # Remove previous fill if it exists
+        if prob_fill is not None:
+            prob_fill.remove()
+        
+        # Create new fill
+        prob_fill = ax.fill_between(x, prob[frame], alpha=0.4, color='blue')
+        
+        # Update time text
+        time_text.set_text(f'Time: {t[frame]:.3f}')
+        return prob_line, time_text
+    
+    # Create animation
+    anim = animation.FuncAnimation(
+        fig, animate, frames=len(t),
+        interval=1000/fps, blit=False, repeat=True
+    )
+    
+    # Save as GIF
+    anim.save(save_path, writer='pillow', fps=fps)
+    plt.close()
+    
+    print(f"Simple animation saved to {save_path}")
+
+
+if __name__ == "__main__":
+    # Set random seed for reproducibility
+    np.random.seed(42)
+    
+    # Create dataset
+    dataset = SchrodingerDataset(
+        Lx=20.0,
+        Nx=128,  # Lower resolution for faster animation generation
+        stop_sim_time=3.0,
+        timestep=2e-3  # Slightly larger timestep for fewer frames
+    )
+    
+    # Generate a single sample
+    sample = next(iter(dataset))
+    
+    print("Creating animations...")
+    print(f"Time steps: {len(sample['time_coordinates'])}")
+    print(f"Spatial points: {len(sample['spatial_coordinates'])}")
+    
+    # Create both animations
+    create_simple_animation(sample, "simple_animation.gif", fps=12)
+    create_schrodinger_animation(sample, "sample_animation.gif", fps=10)

plot_sample.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+Plot a single sample from the Schrödinger equation dataset.
+
+Visualizes quantum wave packet evolution including:
+- Real and imaginary parts
+- Probability density |ψ|²
+- Potential well
+- Energy conservation
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from dataset import SchrodingerDataset
+
+
+def plot_schrodinger_sample(sample, save_path="sample_plot.png"):
+    """Plot a single sample from the Schrödinger dataset"""
+    fig = plt.figure(figsize=(16, 12))
+
+    # Create subplot layout
+    gs = fig.add_gridspec(3, 2, height_ratios=[1, 1, 0.8], hspace=0.3, wspace=0.3)
+
+    # Extract data
+    x = sample["spatial_coordinates"]
+    t = sample["time_coordinates"]
+    psi_r = sample["psi_r_trajectory"]
+    psi_i = sample["psi_i_trajectory"]
+    prob = sample["probability_density"]
+    V = sample["potential"]
+    energy = sample["total_energy"]
+
+    # Colors for consistency
+    color_real = "#1f77b4"
+    color_imag = "#ff7f0e"
+    color_prob = "#2ca02c"
+    color_potential = "#d62728"
+
+    # Plot 1: Initial and final wavefunction components
+    ax1 = fig.add_subplot(gs[0, 0])
+    ax1.plot(x, psi_r[0], color=color_real, linewidth=2, label="ψᵣ(x,t=0)")
+    ax1.plot(x, psi_i[0], color=color_imag, linewidth=2, label="ψᵢ(x,t=0)")
+    ax1.plot(
+        x,
+        psi_r[-1],
+        "--",
+        color=color_real,
+        alpha=0.7,
+        linewidth=2,
+        label=f"ψᵣ(x,t={t[-1]:.1f})",
+    )
+    ax1.plot(
+        x,
+        psi_i[-1],
+        "--",
+        color=color_imag,
+        alpha=0.7,
+        linewidth=2,
+        label=f"ψᵢ(x,t={t[-1]:.1f})",
+    )
+    ax1.set_xlabel("Position x")
+    ax1.set_ylabel("ψ(x)")
+    ax1.set_title("Wavefunction Components")
+    ax1.grid(True, alpha=0.3)
+    ax1.legend()
+
+    # Plot 2: Probability density evolution
+    ax2 = fig.add_subplot(gs[0, 1])
+    ax2.plot(x, prob[0], color=color_prob, linewidth=2, label="|ψ(x,t=0)|²")
+    ax2.plot(
+        x,
+        prob[-1],
+        "--",
+        color=color_prob,
+        alpha=0.7,
+        linewidth=2,
+        label=f"|ψ(x,t={t[-1]:.1f})|²",
+    )
+
+    # Add potential well (scaled for visibility)
+    V_scaled = V / np.max(V) * np.max(prob[0]) * 0.3
+    ax2.fill_between(
+        x, V_scaled, alpha=0.2, color=color_potential, label="V(x) (scaled)"
+    )
+
+    ax2.set_xlabel("Position x")
+    ax2.set_ylabel("Probability Density")
+    ax2.set_title("Quantum Probability |ψ|²")
+    ax2.grid(True, alpha=0.3)
+    ax2.legend()
+
+    # Plot 3: Real part space-time evolution
+    ax3 = fig.add_subplot(gs[1, 0])
+    vmax = np.max(np.abs(psi_r))
+    im1 = ax3.pcolormesh(
+        x, t, psi_r, cmap="RdBu", vmin=-vmax, vmax=vmax, shading="gouraud"
+    )
+    ax3.set_xlabel("Position x")
+    ax3.set_ylabel("Time t")
+    ax3.set_title("Real Part Evolution ψᵣ(x,t)")
+    plt.colorbar(im1, ax=ax3, label="ψᵣ")
+
+    # Plot 4: Imaginary part space-time evolution
+    ax4 = fig.add_subplot(gs[1, 1])
+    vmax = np.max(np.abs(psi_i))
+    im2 = ax4.pcolormesh(
+        x, t, psi_i, cmap="RdBu", vmin=-vmax, vmax=vmax, shading="gouraud"
+    )
+    ax4.set_xlabel("Position x")
+    ax4.set_ylabel("Time t")
+    ax4.set_title("Imaginary Part Evolution ψᵢ(x,t)")
+    plt.colorbar(im2, ax=ax4, label="ψᵢ")
+
+    # Plot 5: Bottom spanning plots - Probability density heatmap and energy
+    ax5 = fig.add_subplot(gs[2, 0])
+    im3 = ax5.pcolormesh(x, t, prob, cmap="viridis", shading="gouraud")
+    ax5.set_xlabel("Position x")
+    ax5.set_ylabel("Time t")
+    ax5.set_title("Probability Density Evolution |ψ(x,t)|²")
+    plt.colorbar(im3, ax=ax5, label="|ψ|²")
+
+    # Plot 6: Energy conservation
+    ax6 = fig.add_subplot(gs[2, 1])
+    ax6.plot(t, energy, "o-", color="darkgreen", linewidth=2, markersize=4)
+    ax6.set_xlabel("Time t")
+    ax6.set_ylabel("Total Energy")
+    ax6.set_title("Energy Conservation")
+    ax6.grid(True, alpha=0.3)
+
+    # Add energy statistics
+    E_mean = np.mean(energy)
+    E_std = np.std(energy)
+    ax6.axhline(
+        E_mean, color="red", linestyle="--", alpha=0.7, label=f"Mean: {E_mean:.3f}"
+    )
+    ax6.text(
+        0.02,
+        0.95,
+        f"σ/⟨E⟩ = {E_std/E_mean:.2e}",
+        transform=ax6.transAxes,
+        bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
+        verticalalignment="top",
+    )
+    ax6.legend()
+
+    # Add main title with physical parameters
+    hbar = sample["hbar"]
+    mass = sample["mass"]
+    omega = sample["omega"]
+    fig.suptitle(
+        f"Quantum Harmonic Oscillator (ℏ={hbar}, m={mass}, ω={omega})",
+        fontsize=16,
+        fontweight="bold",
+    )
+
+    plt.savefig(save_path, dpi=200, bbox_inches="tight")
+    plt.close()
+
+    print(f"Schrödinger sample visualization saved to {save_path}")
+
+
+if __name__ == "__main__":
+    # Set random seed for reproducibility
+    np.random.seed(42)
+
+    # Create dataset with reasonable parameters for visualization
+    dataset = SchrodingerDataset(Lx=20.0, Nx=256, stop_sim_time=2.0, timestep=1e-3)
+
+    # Generate a single sample
+    dataset_iter = iter(dataset)
+    sample = next(dataset_iter)
+    sample = next(dataset_iter)
+
+    print("Sample keys:", list(sample.keys()))
+    for key, value in sample.items():
+        if hasattr(value, "shape"):
+            print(f"{key}: shape {value.shape}")
+        else:
+            print(f"{key}: {type(value)} - {value}")
+
+    # Plot the sample
+    plot_schrodinger_sample(sample)

requirements.txt

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