def demo(u, s0, N, as_points, ends): core.u = u # Simulation length K = 10**5 // N # Computations simulator = modelling.with_recursion(core.step, prog="Simulating") # Initial ensemble E0 = core.x0 + s0 * np.random.randn(N, 2) # Simulate EE = simulator(E0, K, 0, 1) # Plot fig, ax = plt.subplots() fig.suptitle('Phase space' + f"\nu={core.u}, N={N}, $σ_0$={s0}") ax.set(xlabel="x", ylabel="y") # Re-order axes for plotting tail_length = 0 # 0 => infinite ET = EE[-tail_length:].transpose((2, 0, 1)) if as_points: ax.plot(*ET, "b.", ms=1.0, alpha=1.0) else: ax.plot(*ET, "b-", lw=.02, alpha=0.1) if ends: ax.plot(*EE[0].T, '*g', ms=7) ax.plot(*EE[-1].T, '*r', ms=7)
def gen_ensemble_sample(model, nSamples, nEnsemble, SpinUp, Spacing): simulator = modelling.with_recursion(model.step, prog="Simulating") K = SpinUp + nSamples * Spacing Nx = np.prod(shape) # total state length init = np.random.normal(loc=0.0, scale=0.1, size=[nEnsemble, Nx]) sample = simulator(init, K, 0.0, model.prms["dtout"]) return sample[SpinUp::Spacing, :, :]
"""Demonstrate the Lotka-Volterra model.""" import numpy as np from matplotlib import pyplot as plt import dapper.mods as modelling from dapper.mods.LotkaVolterra import step, x0 simulator = modelling.with_recursion(step, prog="Simulating") dt = 0.7 K = int(1 * 10**3 / dt) xx = simulator(x0, K, t0=0, dt=dt) fig, ax = plt.subplots(figsize=(9, 6)) ax.plot(np.linspace(0, K * dt, K + 1), xx) plt.show()
"""Demonstrate the Double-Pendulum model.""" # https://en.wikipedia.org/wiki/Double_pendulum import numpy as np from matplotlib import pyplot as plt from matplotlib.animation import FuncAnimation from numpy import cos, sin import dapper.mods as modelling from dapper.mods.DoublePendulum import L1, L2, step, x0 E0 = x0 + 0.01 * np.random.randn(3, 4) simulator = modelling.with_recursion(step) dt = 0.01 EE = simulator(E0, k=10**4, t0=0, dt=dt) # Energy evolution. Should be constant, but for numerical errors: # plt.plot(energy(EE).T) fig = plt.figure() ax = fig.add_subplot(111, autoscale_on=False, xlim=(-2, 2), ylim=(-2, 2)) lines = [] for _ in E0: lines += [ax.plot([], [], 'o-', lw=2)[0]] # Need to hide text handle among "lines" time_template = 'time = %.1fs' lines += [ax.text(0.05, 0.9, '', transform=ax.transAxes)]
from matplotlib import pyplot as plt import dapper.mods as modelling from dapper.mods.LorenzUV.lorenz96 import LUV # Setup sd0 = modelling.set_seed(4) # from dapper.mods.LorenzUV.wilks05 import LUV nU, J = LUV.nU, LUV.J dt = 0.005 t0 = np.nan K = int(10/dt) step_1 = modelling.with_rk4(LUV.dxdt, autonom=True) step_K = modelling.with_recursion(step_1, prog=1) x0 = 0.01*np.random.randn(LUV.M) x0 = step_K(x0, int(2/dt), t0, dt)[-1] # BurnIn xx = step_K(x0, K, t0, dt) # Grab parts of state vector ii = np.arange(nU+1) jj = np.arange(nU*J+1) circU = np.mod(ii, nU) circV = np.mod(jj, nU*J) + nU iU = np.hstack([0, 0.5+np.arange(nU), nU]) def Ui(xx): interp = (xx[0]+xx[-1])/2 return np.hstack([interp, xx, interp])
ii = np.random.choice(np.arange(Nx), 100, False) T = 1000.0 dt = model.prms['dtout'] x0 = np.load(sample_filename)['sample'][-1] eps = 0.01 # ensemble rescaling N = 300 ######################## # Reference trajectory ######################## # NB: Arbitrary, coz models are autonom. But dont use nan coz QG doesn't like it. t0 = 0.0 K = int(round(T/dt)) # Num of time steps. tt = np.linspace(dt, T, K) # Time seq. x = with_recursion(step, prog="BurnIn")(x0, int(10/dt), t0, dt)[-1] xx = with_recursion(step, prog="Reference")(x, K, t0, dt) ######################## # ACF ######################## # NB: Won't work with QG (too big, and BCs==0). fig, ax = freshfig(4) if "ii" not in locals(): ii = np.arange(min(100, Nx)) if "nlags" not in locals(): nlags = min(100, K-1) ax.plot(tt[:nlags], np.nanmean( series.auto_cov(xx[:nlags, ii], nlags=nlags-1, corr=1), axis=1))
if PRMS == 'Wilks': from dapper.mods.LorenzUV.wilks05 import LUV else: from dapper.mods.LorenzUV.lorenz96 import LUV nU = LUV.nU K = 400 dt = 0.005 t0 = np.nan modelling.set_seed(30) # 3 5 7 13 15 30 x0 = np.random.randn(LUV.M) true_step = with_rk4(LUV.dxdt, autonom=True) model_step = with_rk4(LUV.dxdt_trunc, autonom=True) true_K = with_recursion(true_step, prog=1) ########################### # Compute truth trajectory ########################### x0 = true_K(x0, int(2 / dt), t0, dt)[-1] # BurnIn xx = true_K(x0, K, t0, dt) ########################### # Compute unresovled scales ########################### gg = np.zeros((K, nU)) # "Unresolved tendency" for k, x in enumerate(xx[:-1]): X = x[:nU] Z = model_step(X, t0, dt) D = Z - xx[k + 1, :nU]
def gen_sample(model, nSamples, SpinUp, Spacing): simulator = modelling.with_recursion(model.step, prog="Simulating") K = SpinUp + nSamples*Spacing Nx = np.prod(shape) # total state length sample = simulator(np.zeros(Nx), K, 0.0, model.prms["dtout"]) return sample[SpinUp::Spacing]
import numpy as np from matplotlib import pyplot as plt import dapper.mods as modelling from dapper.mods.LorenzUV.lorenz96 import LUV from dapper.tools.progressbar import progbar from dapper.tools.viz import setup_wrapping nU, J = LUV.nU, LUV.J dt = 0.005 K = int(4 / dt) step_1 = modelling.with_rk4(LUV.dxdt, autonom=True) step_K = modelling.with_recursion(step_1, prog='Simulating') xx = step_K(LUV.x0, K, np.nan, dt) # Grab parts of state vector ii, wrapU = setup_wrapping(nU) jj, wrapV = setup_wrapping(nU * J) # Animate linear plt.figure() lhU = plt.plot(ii, wrapU(xx[-1, :nU]), 'b', lw=3)[0] lhV = plt.plot(jj / J, wrapV(xx[-1, nU:]), 'g', lw=2)[0] for k in progbar(range(K), 'Plotting'): lhU.set_ydata(wrapU(xx[k, :nU])) lhV.set_ydata(wrapV(xx[k, nU:])) plt.pause(0.001)