scicomp3 0.2.0__tar.gz

scicomp3-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  smoke-a1_1p1:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install package with test dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Smoke test (quick import check)
+        run: python -c "from scicomp3 import solve_ivp, wave1d_rhs; print('Import OK')"
+
+      - name: Run pytest
+        run: pytest tests/ -v

scicomp3-0.2.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__
+*.png
+*.gif
+!images/**/*.gif
+*.pyc
+dist/
+build/
+*.egg-info/
+uv.lock
+data/
+.pkl

scicomp3-0.2.0/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+  "files.trimTrailingWhitespace": true,
+  "editor.formatOnSave": true,
+  "[python]": {
+    "editor.defaultFormatter": "ms-python.black-formatter"
+  }
+}

scicomp3-0.2.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: scicomp3
+Version: 0.2.0
+Requires-Python: >=3.10
+Requires-Dist: joblib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Provides-Extra: dev
+Requires-Dist: joblib; extra == 'dev'
+Requires-Dist: matplotlib; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: scienceplots; extra == 'dev'
+Provides-Extra: plot
+Requires-Dist: matplotlib; extra == 'plot'
+Requires-Dist: scienceplots; extra == 'plot'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'

scicomp3-0.2.0/README.md

@@ -0,0 +1,316 @@
+# scicomp3 — Scientific Computing Assignment Package
+
+Numerical solvers for the 1D wave equation, 2D diffusion equation, and steady-state Laplace equation, built for the Scientific Computing course (Assignment Set 1).
+
+## Quick Start
+
+```bash
+# Clone and enter the project
+cd assigment-submission
+
+# Create/activate venv and install (editable mode with dev deps)
+uv pip install -e ".[dev]"
+
+# Run tests
+pytest tests/ -v
+
+# Run a script
+python scripts/a1_1_smoke_test.py
+```
+
+## Project Structure
+
+```
+.
+├── src/scicomp3/              # Main package
+│   ├── core/
+│   │   ├── grid.py            # Grid1D, Grid2D — spatial discretization
+│   │   └── result.py          # ODEResult, BVPResult — solver output containers
+│   ├── ode/
+│   │   ├── methods.py         # Time-stepping: Euler, symplectic Euler
+│   │   └── solver.py          # solve_ivp() — IVP solver entry point
+│   ├── pde/
+│   │   ├── wave.py            # wave1d_rhs, initial conditions (cases i–iii), analytical solution
+│   │   └── diffusion.py       # diffusion2d_rhs, BCs, stable dt, analytical solution
+│   ├── bvp/
+│   │   ├── methods.py         # Iterative methods: Jacobi, Gauss-Seidel, SOR
+│   │   ├── solver.py          # solve_bvp() — BVP solver entry point
+│   │   └── omega.py           # Optimal omega computation and search for SOR
+│   ├── objects/
+│   │   ├── shapes.py          # Geometric coordinate generation (rectangles)
+│   │   ├── sink.py            # Sink region utilities
+│   │   └── insulator.py       # Insulator region utilities
+│   └── validation/
+│       └── validation.py      # Boundary condition validation utilities
+│
+├── tests/                     # Pytest test suite
+│   ├── test_boundary_conditions.py  # Wave BC enforcement (3 cases)
+│   ├── test_diffusion.py           # Diffusion solver + analytical comparison
+│   ├── test_jacobi.py              # Jacobi iteration convergence + steady state
+│   ├── test_gauss_seidel.py        # Gauss-Seidel iteration convergence
+│   ├── test_sor.py                 # SOR iteration with omega = 1.9
+│   ├── test_scripts.py             # Smoke tests for all scripts
+│   └── test_solver_comparison.py   # Legacy vs scicomp3 solver parity
+│
+├── scripts/                   # Runnable plotting/animation scripts
+│   ├── a1_1_smoke_test.py                # Quick wave equation smoke test
+│   ├── a1_1_cases_plot.py                # Wave plots for all 3 initial conditions
+│   ├── a1_1_cases_animation.py           # Wave animated GIFs
+│   ├── a1_1_cases_compared_to_analytical.py  # Numerical vs analytical error
+│   ├── a1_2_diffusion.py                # 2D diffusion snapshots
+│   ├── a1_2_diffusion_animation.py       # Diffusion animated GIF
+│   ├── a1_2_diffusion_verification.py    # Diffusion vs analytical verification
+│   ├── a1_6_iterative_methods.py         # Compare Jacobi/GS/SOR profiles + deviations
+│   ├── a1_6_iterative_convergence.py     # Convergence rate comparison
+│   ├── a1_6_iterative_jacobi.py          # Jacobi standalone
+│   ├── a1_6_iterative_gauss_seidel.py    # Gauss-Seidel standalone
+│   ├── a1_6_iterative_sor.py             # SOR standalone
+│   ├── a1_6_objects_k_impact.py          # Object impact on iteration count
+│   ├── a1_6_seeking_optimal_omega.py     # Optimal omega search with objects
+│   ├── a1_6_omega_values.py              # Omega parameter exploration
+│   ├── a1_6_omega_for_various_N_sim.py   # Omega vs grid size simulation
+│   ├── a1_6_omega_for_various_N_plot.py  # Omega vs grid size plotting
+│   ├── a1_6_sinks_jacobi.py             # Sink object with Jacobi
+│   ├── a1_6_sinks_gauss_seidel.py       # Sink object with Gauss-Seidel
+│   ├── a1_6_sinks_sor.py                # Sink object with SOR
+│   ├── a1_6_sinks_sor_animation.py      # Sink SOR animation
+│   ├── a1_6_sinks_k_impact.py           # Sink impact on convergence
+│   ├── a1_6_sinks_and_insulators_sor.py  # Combined sink + insulator
+│   ├── a1_6_insulators_jacobi.py         # Insulator with Jacobi
+│   ├── a1_6_insulators_gauss_seidel.py   # Insulator with Gauss-Seidel
+│   ├── a1_6_insulators_sor.py            # Insulator with SOR
+│   ├── a1_6_insulators_sor_animation.py  # Insulator SOR animation
+│   └── a1_6_insulators_k_impact.py       # Insulator impact on convergence
+│
+├── assignment01.py            # Legacy wave solver (kept for comparison tests)
+├── run_assignment01_*.py      # Legacy plotting scripts using assignment01.py
+├── data/                      # Cached simulation data (e.g. n_vs_omega.pkl)
+├── pyproject.toml             # Build config (hatchling), deps, pytest settings
+└── images/                    # Generated figures and GIFs
+```
+
+## How It Works
+
+### Solving a PDE (Initial Value Problem)
+
+The package separates concerns into three layers:
+
+1. **PDE right-hand side** (`pde/`) — defines the physics (spatial derivatives)
+2. **ODE solver** (`ode/`) — advances the solution in time
+3. **Post-step callback** — enforces boundary conditions after each step
+
+Example: solving the wave equation end-to-end:
+
+```python
+import numpy as np
+from scicomp3 import Grid1D, solve_ivp, wave1d_rhs
+from scicomp3.pde.wave import initial_condition_case_ii
+
+# 1. Grid and parameters
+grid = Grid1D(N=90, L=1.0)
+c, dt, T_sim = 1.0, 1e-3, 2.0
+
+# 2. Initial condition: Ψ(x,0) = sin(5πx), Ψ_t(x,0) = 0
+psi0 = initial_condition_case_ii(grid.x)
+psi0[0] = psi0[-1] = 0          # enforce BCs on IC
+v0 = np.zeros(grid.N)
+y0 = np.column_stack([psi0, v0]) # state = [Ψ, v], shape (N, 2)
+
+# 3. Boundary condition callback
+def fixed_ends(t, y):
+    y[0, 0] = y[-1, 0] = 0
+    return y
+
+# 4. Solve
+result = solve_ivp(
+    wave1d_rhs,
+    t_span=(0, T_sim),
+    y0=y0,
+    method="symplectic_euler",    # energy-preserving for wave eq
+    dt=dt,
+    args=(c, grid.L, grid.N),
+    post_step=fixed_ends,
+)
+
+# 5. Extract results
+amplitudes = result.y[:, :, 0]   # Ψ at each saved time step
+times = result.t
+```
+
+Example: 2D diffusion equation:
+
+```python
+import numpy as np
+from scicomp3.core.grid import Grid2D
+from scicomp3.ode.solver import solve_ivp
+from scicomp3.pde.diffusion import (
+    diffusion2d_rhs, apply_diffusion_bc, diffusion_stable_dt, analytical_solution,
+)
+
+grid = Grid2D(N=50, L=1.0)
+D = 1.0
+dt = diffusion_stable_dt(D, grid.dx)  # auto-compute safe dt
+
+c0 = np.zeros((grid.N + 1, grid.N + 1))
+apply_diffusion_bc(c0)                # set top=1, bottom=0
+
+result = solve_ivp(
+    diffusion2d_rhs,
+    t_span=(0, 1.0),
+    y0=c0,
+    method="forward_euler",
+    dt=dt,
+    args=(D, grid.dx),
+    post_step=lambda t, y: (apply_diffusion_bc(y), y)[1],
+    save_interval=100,
+)
+```
+
+### Solving a BVP (Steady-State)
+
+For steady-state problems (Laplace equation), iterative solvers are available:
+
+```python
+from scicomp3.bvp.solver import solve_bvp
+from scicomp3.bvp.omega import get_optimal_omega
+
+result = solve_bvp(c0, method="sor", post_step=fixed_bc, tol=1e-5,
+                   omega=get_optimal_omega(N))
+# result.y       — converged solution
+# result.n_iter  — iterations to convergence
+# result.delta_history — convergence measure per iteration
+```
+
+### Available Time-Stepping Methods
+
+| Name | Aliases | Order | Properties |
+|------|---------|-------|------------|
+| `"symplectic_euler"` | `"euler_cromer"`, `"semi_implicit_euler"` | 1st | Symplectic (energy-preserving). Default. Use for wave equation. |
+| `"forward_euler"` | `"euler"` | 1st | Explicit. Use for diffusion equation. |
+
+### Available Iterative Methods (BVP)
+
+| Name | Description |
+|------|-------------|
+| `"jacobi"` | Jacobi iteration — vectorized with `np.roll` |
+| `"gauss_seidel"` | Gauss-Seidel — sequential updates using latest values |
+| `"sor"` | Successive Over-Relaxation — accelerated Gauss-Seidel with relaxation parameter omega |
+
+Methods are registered in `scicomp3.ode.methods.METHODS` (IVP) and `scicomp3.bvp.methods` (BVP), looked up by name in `solve_ivp()` and `solve_bvp()`.
+
+### Key Design Decisions
+
+**Post-step callback for boundary conditions.** The PDE RHS functions use `np.roll` for the spatial stencil, which wraps boundary values incorrectly. The `post_step` callback in `solve_ivp` corrects this after every time step. This separates the physics from the constraints cleanly.
+
+**Symplectic Euler for wave equation.** Forward Euler is dissipative — it loses energy over time. The symplectic Euler method preserves the phase-space structure of Hamiltonian systems, keeping energy bounded over long simulations. This is the default method.
+
+**Explicit scheme for diffusion.** The FTCS (Forward Time, Centered Space) scheme is simple but conditionally stable. Use `diffusion_stable_dt()` to compute a safe time step (90% of the theoretical maximum δx² / 4D).
+
+**Sink and insulator objects.** The BVP solvers support sink (Dirichlet, c=0) and insulator (Neumann, zero-flux) objects via coordinate arrays passed to `solve_bvp()`.
+
+## Running Tests
+
+```bash
+# All tests
+pytest tests/ -v
+
+# Specific test file
+pytest tests/test_diffusion.py -v
+
+# With print output
+pytest tests/ -v -s
+```
+
+The test suite covers:
+- **test_boundary_conditions.py** — Wave equation BCs hold for all 3 initial conditions; documents np.roll boundary pollution without post_step.
+- **test_diffusion.py** — Diffusion BCs (top=1, bottom=0), convergence to steady state c=y, match against analytical erfc series solution, stability check.
+- **test_jacobi.py** — Jacobi iteration convergence, steady-state profile, boundary checks, monotonicity.
+- **test_gauss_seidel.py** — Gauss-Seidel convergence, fewer iterations than Jacobi.
+- **test_sor.py** — SOR iteration with omega=1.9.
+- **test_scripts.py** — Smoke tests that every script under `scripts/` runs without error.
+- **test_solver_comparison.py** — Legacy `assignment01.py` and `scicomp3` solvers produce identical interior-point results.
+
+## Running Scripts
+
+Scripts live in `scripts/` and produce plots or animations. They require `matplotlib` and `scienceplots`:
+
+```bash
+# Quick smoke test (interactive plot)
+python scripts/a1_1_smoke_test.py
+
+# Generate static plots for all wave cases → images/figures/
+python scripts/a1_1_cases_plot.py
+
+# Generate animated GIFs for all wave cases → images/gifs/
+python scripts/a1_1_cases_animation.py
+
+# Numerical vs analytical comparison → images/figures/
+python scripts/a1_1_cases_compared_to_analytical.py
+
+# 2D diffusion: concentration fields → images/figures/
+python scripts/a1_2_diffusion.py
+
+# 2D diffusion vs analytical verification → images/figures/
+python scripts/a1_2_diffusion_verification.py
+
+# Compare iterative methods (Jacobi, GS, SOR) → images/figures/
+python scripts/a1_6_iterative_methods.py
+
+# Convergence rate comparison → images/figures/
+python scripts/a1_6_iterative_convergence.py
+
+# Object impact on iteration count → images/figures/
+python scripts/a1_6_objects_k_impact.py
+
+# Optimal omega search with objects → images/figures/
+python scripts/a1_6_seeking_optimal_omega.py
+```
+
+## Adding a New Time-Stepping Method
+
+1. Define a step function in `src/scicomp3/ode/methods.py`:
+
+```python
+def my_step(fun, t, y, dt, args=()):
+    """One step of my method. Returns (y_new, n_function_evals)."""
+    dydt = fun(t, y, *args)
+    y_new = ...  # your update rule
+    return y_new, 1
+```
+
+2. Register it in `METHODS`:
+
+```python
+METHODS["my_method"] = my_step
+```
+
+3. Use it:
+
+```python
+result = solve_ivp(..., method="my_method")
+```
+
+## Adding a New PDE
+
+1. Create a RHS function in `src/scicomp3/pde/`:
+
+```python
+def my_pde_rhs(t, y, *params):
+    """Compute dy/dt for my PDE. Returns array same shape as y."""
+    ...
+```
+
+2. Write a post_step if boundary conditions need enforcement.
+3. Call `solve_ivp(my_pde_rhs, ...)` with appropriate method and parameters.
+
+## Legacy Code
+
+`assignment01.py` at the project root is the original wave equation implementation. It uses a different API (`integrate_euler` with `**kwargs`) and has known boundary pollution from `np.roll` without post-step correction. It is kept for backward compatibility and tested against `scicomp3` in `test_solver_comparison.py`.
+
+## Dependencies
+
+- **Required**: `numpy`, `scipy`, `joblib`
+- **Plotting**: `matplotlib`, `scienceplots` (optional, needed for scripts)
+- **Testing**: `pytest` (optional)
+
+Python >= 3.10.

scicomp3-0.2.0/assignment01.py

@@ -0,0 +1,118 @@
+import numpy as np
+import matplotlib
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation, PillowWriter
+
+
+def wave_eq_deriv(state, t, dt=1e-3, c=1, L=1, N=100):
+    """
+    Compute the derivatives for the 1D wave equation, to use for a forward Euler integration scheme.
+    Takes as arguments:
+     - current state vector [Ψ, Ψ_t];
+     - current time t;
+     - wave speed c;
+     - string length L;
+     - number of spatial points N.
+    Returns the derivatives [dΨ/dt, d^2 Ψ/dt^2] as a numpy array.
+    """
+    # psi, psi_t = state # unpack the state vector [Ψ, Ψ_t]
+    psi = state[:, 0]
+    psi_t = state[:, 1]
+    psi[0] = 0  # boundary condition at x=0
+    psi[-1] = 0  # boundary condition at x=L
+
+    dx = L / N  # spatial step size
+    d2psi_dx2 = (
+        np.roll(psi, -1) - 2 * psi + np.roll(psi, 1)
+    ) / dx**2  # second deriv in space
+    dpsi_t_dt = c**2 * d2psi_dx2  # second deriv in time to update first deriv
+
+    dpsi_dt = psi_t + dt * dpsi_t_dt  # first deriv in time to update Ψ
+
+    # Check that the boundary conditions remain satisfied
+    assert psi[0] == 0, f"Expected 0 at the boundary, got {d2psi_dx2[0]}"
+    assert psi[-1] == 0, f"Expected 0 at the boundary, got {d2psi_dx2[-1]}"
+
+    return np.array([dpsi_dt, dpsi_t_dt])
+
+
+def integrate_euler(deriv_func, state0, dt=1e-3, T_sim=10, **kwargs):
+    """
+    Integrate a system of ODEs using the forward Euler method.
+    Takes as arguments:
+     - deriv_func: function that computes the derivatives in time;
+     - state0: initial state vector at time t=0;
+     - dt: time step size;
+     - T_sim: total simulation time;
+     - kwargs: additional arguments to pass to deriv_func.
+    Returns an array of states at each time step.
+    """
+    # Create the time array based on simulation time and time step size
+    time = np.arange(0, T_sim, dt)
+    # Create an array to hold the states at each time step
+    states = np.zeros((len(time),) + state0.shape)
+    # Fill it with the initial state
+    states[0] = state0
+    print(np.shape(states), np.shape(state0))
+
+    # Perform the forward Euler integration
+    for i in range(1, len(time)):
+        derivs = deriv_func(states[i - 1], time[i - 1], dt, **kwargs)
+        # Update according to: new_state = old_state + dt * derivs
+        state = states[i - 1] + dt * np.transpose(derivs)
+        # Save the updated state
+        states[i] = state
+
+    return time, states
+
+
+def animate_wave(amplitudes: list, dpi=100, case="i", dt=1e-3, T_sim=10, **kwargs):
+    """Create and save an animated GIF showing the temporal evolution of CA grids."""
+
+    c, L, N = kwargs["c"], kwargs["L"], kwargs["N"]
+    dx = L / N
+
+    # Set up the figure
+    fig, ax = plt.subplots(figsize=(6, 4))
+    ax.plot(np.arange(N) * dx, amplitudes[0], color="ForestGreen")
+
+    ax.set_xlabel("Position along string (x)")
+    ax.set_ylabel("String amplitude (Ψ)")
+    ax.set_title("Vibrating string over at time 0", fontsize=14)
+    ylim = np.max(np.abs(amplitudes)) * 1.5
+    ax.set_ylim(-ylim, ylim)
+
+    # Define animation function
+    def animate(frame):
+        # i, grid = frame
+        i, plot = frame
+        ax.clear()
+        ax.plot(np.arange(N) * dx, plot, color="ForestGreen")
+        ax.set_ylim(-ylim, ylim)
+        ax.set_xlabel("Position along string (x)")
+        ax.set_ylabel("String amplitude (Ψ)")
+        ax.set_title(f"Vibrating string at time {i*10*dt:.2f}", fontsize=14)
+        return []
+
+    # Set up helper function to display progress
+    def progress_callback(current_frame, total_frames):
+        """Shows saving progress"""
+        if current_frame % 10 == 0:
+            print(f"Saving frame {current_frame}/{total_frames} ...")
+
+    amplitudes_to_animate = list(
+        enumerate(amplitudes[::10])
+    )  # Sample every 10th frame for animation
+
+    # Create animation
+    anim = FuncAnimation(fig, animate, amplitudes_to_animate, interval=10)
+    print("Saving animation ... (This can take a while depending on the dpi.)")
+
+    filename = f"../images/gifs/vibrating_string_case={case}_dt={dt}_Tsim={T_sim}_c={c}_L={L}_N={N}.gif"
+    anim.save(
+        filename,
+        writer=PillowWriter(fps=20),
+        dpi=dpi,
+        progress_callback=progress_callback,
+    )
+    print(f"Saved successfully as '{filename}'")

scicomp3-0.2.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "scicomp3"
+version = "0.2.0"
+requires-python = ">=3.10"
+dependencies = ["numpy", "scipy", "joblib"]
+
+[project.optional-dependencies]
+plot = ["matplotlib", "scienceplots"]
+test = ["pytest"]
+dev = ["matplotlib", "scienceplots", "pytest", "joblib"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/scicomp3"]
+
+[tool.pytest.ini_options]
+addopts = ["--import-mode=importlib"]
+testpaths = ["tests"]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+]

scicomp3-0.2.0/run_assignment01_01_smoke_plot.py

@@ -0,0 +1,26 @@
+from assignment01 import *
+
+c=1; L=1; N=90
+dx = L/N
+dt = 1e-3
+T_sim = 10
+
+# Use N+1 points to include both boundaries at x=0 and x=L
+x = np.linspace(0, L, N+1)  # [0, dx, 2dx, ..., L]
+psi0 = np.sin(5*np.pi*x) # initial amplitudes Ψ
+psi0[0] = 0   # enforce boundary condition at x=0
+psi0[-1] = 0  # enforce boundary condition at x=L
+psi_t0 = np.zeros(N+1) # initial velocities Ψ_t are set to 0
+state0 = np.transpose([psi0, psi_t0]) # initial state vector [Ψ, Ψ_t]
+
+time, states = integrate_euler(wave_eq_deriv, state0=state0, dt=dt, T_sim=T_sim, c=c, L=L, N=N+1)
+amplitudes = states[:, :, 0]  # Extract the amplitudes Ψ over time
+fig, ax = plt.subplots(figsize=(6, 4))
+for i in range(0, len(time), len(time)//11):
+    ax.plot(x, amplitudes[i], color=plt.cm.cividis(i/len(time)))
+ax.set_xlabel('Position along string (x)')
+ax.set_ylabel('String amplitude (Ψ)')
+ax.set_title('Vibrating string over time')
+cbar = fig.colorbar(plt.cm.ScalarMappable(cmap='cividis'), ax=ax, label='Time', ticks=np.linspace(0, 1, 3))
+cbar.ax.set_yticklabels([f"{t:.1f}" for t in np.linspace(0, T_sim, 3)])  # Set colorbar ticks to actual time values
+plt.show()

scicomp3-0.2.0/run_assignment01_02_cases_plot.py

@@ -0,0 +1,34 @@
+from assignment01 import *
+
+c=1; L=1; N=90
+dx = L/N
+dt = 1e-3
+T_sim = 10
+
+psi0_i = np.sin(2*np.pi*np.arange(N)*dx) # initial amplitudes of case i
+psi0_ii = np.sin(5*np.pi*np.arange(N)*dx) # initial amplitudes of case ii
+psi0_iii = np.sin(5*np.pi*np.arange(N)*dx) 
+psi0_iii = np.where((np.arange(N)*dx < 1/5) | (np.arange(N)*dx > 2/5), 0, psi0_iii) # initial amplitudes of case iii
+initial_conditions = [psi0_i, psi0_ii, psi0_iii]
+
+psi_t0 = np.zeros(N) # initial velocities Ψ_t are set to 0
+
+amplitude_list = []
+
+for i, psi0 in enumerate(initial_conditions):
+    state0 = np.transpose([psi0, psi_t0]) # initial state vector [Ψ, Ψ_t]
+    time, states = integrate_euler(wave_eq_deriv, state0=state0, dt=dt, T_sim=T_sim, c=c, L=L, N=N)
+    amplitude_list.append(states[:, :, 0])  # Extract the amplitudes Ψ over time for each case
+
+for i, amplitudes in enumerate(amplitude_list):
+    fig, ax = plt.subplots(figsize=(6, 4))
+    for j in range(0, len(time), len(time)//51):
+        ax.plot(np.arange(N)*dx, amplitudes[j], color=plt.cm.cividis(j/len(time)))
+    ax.set_xlabel('Position along string (x)')
+    ax.set_ylabel('String amplitude (Ψ)')
+    ax.set_title(f'Vibrating string over time - Case {i+1}')
+    cbar = fig.colorbar(plt.cm.ScalarMappable(cmap='cividis'), ax=ax, label='Time', ticks=np.linspace(0, 1, 3))
+    cbar.ax.set_yticklabels([f"{t:.1f}" for t in np.linspace(0, T_sim, 3)])  # Set colorbar ticks to actual time values
+    plt.savefig(f"../images/figures/vibrating_string_over_time_case={i}_dt={dt}_Tsim={T_sim}_c={c}_L={L}_N={N}.png", dpi=300)
+    plt.show()
+

scicomp3-0.2.0/run_assignment01_03_cases_animation.py

@@ -0,0 +1,4 @@
+from run_assignment01_02_cases_plot import *
+
+for i, amplitudes in enumerate(amplitude_list):
+    animate_wave(amplitudes, case=i+1, dt=dt, T_sim=T_sim, c=c, L=L, N=N)