File size: 4,955 Bytes
8fbf69f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 | """
Dyadic Shell Model Solver with Dual-Scale Regularization (Katz-Pavlović Model).
"""
from typing import Tuple, Dict, Any, Optional
import numpy as np
from dualscale_solver.numeric.rk4_integrator import solve_ivp_rk4
class DyadicShellSolver:
"""
Simulates the Katz-Pavlović dyadic shell model of turbulence:
du_n/dt = k_n ( u_{n-1}^2 - lambda * u_n * u_{n+1} ) - D(n) * u_n + f_n
where:
- Standard dissipation: D(n) = nu * k_n^2
- Dual-Scale regularized dissipation: D(n) = nu * k_n^2 * max(1.0, alpha_prime * k_n^2)
"""
def __init__(
self,
n_shells: int = 24,
k0: float = 1.0,
inter_shell_ratio: float = 2.0,
nu: float = 1e-4,
alpha_prime: Optional[float] = None,
forcing_shell: int = 0,
forcing_amp: float = 0.0,
):
self.n_shells = n_shells
self.k0 = k0
self.inter_shell_ratio = inter_shell_ratio
self.nu = nu
self.alpha_prime = alpha_prime
self.forcing_shell = forcing_shell
self.forcing_amp = forcing_amp
# Shell wavenumbers k_n = k0 * lambda^n
self.k = self.k0 * (self.inter_shell_ratio ** np.arange(self.n_shells))
def non_linear_rhs(self, t: float, u: np.ndarray) -> np.ndarray:
"""Compute non-linear advection and forcing: N(u) + f."""
nu_term = np.zeros_like(u)
for n in range(self.n_shells):
u_prev = u[n - 1] if n > 0 else 0.0
u_curr = u[n]
u_next = u[n + 1] if n < self.n_shells - 1 else 0.0
nu_term[n] = self.k[n] * (u_prev**2 - self.inter_shell_ratio * u_curr * u_next)
if self.forcing_amp > 0 and 0 <= self.forcing_shell < self.n_shells:
nu_term[self.forcing_shell] += self.forcing_amp
return nu_term
def dissipation_rates(self) -> np.ndarray:
"""Compute linear damping coefficients D_n >= 0 for all shells."""
if self.alpha_prime is not None and self.alpha_prime > 0:
return self.nu * (self.k ** 2) * np.maximum(1.0, self.alpha_prime * (self.k ** 2))
return self.nu * (self.k ** 2)
def energy(self, u: np.ndarray) -> float:
"""Total kinetic energy: E = 0.5 * sum_n u_n^2."""
return 0.5 * float(np.sum(u**2))
def enstrophy(self, u: np.ndarray) -> float:
"""Total enstrophy: Omega = 0.5 * sum_n k_n^2 * u_n^2."""
return 0.5 * float(np.sum((self.k**2) * (u**2)))
def solve(
self,
t_span: Tuple[float, float],
u0: np.ndarray,
dt: float,
) -> Dict[str, Any]:
"""
Integrate dyadic shell model over t_span using an integrating factor RK4 scheme,
which handles stiff linear dissipation exactly and unconditionally stably.
"""
t_start, t_end = t_span
n_steps = max(1, int(np.ceil((t_end - t_start) / dt)))
actual_dt = (t_end - t_start) / n_steps
times = np.linspace(t_start, t_end, n_steps + 1)
traj = [u0.copy()]
curr_u = u0.copy()
D = self.dissipation_rates()
E_half = np.exp(-0.5 * D * actual_dt)
E_full = np.exp(-D * actual_dt)
for i in range(n_steps):
t = times[i]
# Integrating factor RK4 step
k1 = self.non_linear_rhs(t, curr_u)
u2 = E_half * curr_u + 0.5 * actual_dt * E_half * k1
k2 = self.non_linear_rhs(t + 0.5 * actual_dt, u2)
u3 = E_half * curr_u + 0.5 * actual_dt * E_half * k2 # W1 Fix: E_half on k2 (Cox-Matthews ETD-RK4)
k3 = self.non_linear_rhs(t + 0.5 * actual_dt, u3)
u4 = E_full * curr_u + actual_dt * E_half * k3
k4 = self.non_linear_rhs(t + actual_dt, u4)
curr_u = E_full * curr_u + (actual_dt / 6.0) * (
E_full * k1 + 2.0 * E_half * k2 + 2.0 * E_half * k3 + k4
)
traj.append(curr_u.copy())
energies = np.array([self.energy(state) for state in traj])
enstrophies = np.array([self.enstrophy(state) for state in traj])
return {
"times": times,
"trajectory": np.array(traj),
"energy": energies,
"enstrophy": enstrophies,
"k": self.k,
"alpha_prime": self.alpha_prime,
"nu": self.nu,
}
def compute_triadic_frustration_index(
solver: DyadicShellSolver,
u_state: np.ndarray,
t: float = 0.0,
) -> float:
"""
Compute Triadic Frustration Index: D(M) = sum(|T_n|) / |sum(T_n)|.
Measures phase cancellation and asymptotic frustration across triadic transfers.
"""
T = solver.non_linear_rhs(t, u_state)
numerator = float(np.sum(np.abs(T)))
denominator = float(abs(np.sum(T)))
if denominator < 1e-15:
return 1000.0 # Perfect cancellation
return float(numerator / denominator)
|