def demo(u, s0, N, as_points, ends): core.u = u # Simulation length K = 10**5 // N # Computations simulator = dpr.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)
"""Demonstrate the Lorenz-96 model.""" # For a deeper introduction, see # "DA-tutorials/T4 - Dynamical systems, chaos, Lorenz.ipynb" from matplotlib import pyplot as plt from numpy import eye import dapper as dpr from dapper.mods.Lorenz96 import step, x0 from dapper.tools.viz import amplitude_animation simulator = dpr.with_recursion(step, prog="Simulating") x0 = x0(40) E0 = x0 + 1e-3*eye(len(x0))[:3] dt = 0.05 xx = simulator(E0, k=500, t=0, dt=dt) ani = amplitude_animation(xx, dt=dt, interval=70) plt.show()
def gen_sample(model, nSamples, SpinUp, Spacing): simulator = dpr.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 as dpr from dapper.mods.LorenzUV.lorenz96 import LUV from dapper.tools.utils import progbar from dapper.tools.viz import setup_wrapping nU, J = LUV.nU, LUV.J dt = 0.005 K = int(4/dt) step_1 = dpr.with_rk4(LUV.dxdt, autonom=True) step_K = dpr.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)
import dapper as dpr from dapper.mods.LorenzUV.lorenz96 import LUV from dapper.tools.math import ccat # Setup sd0 = dpr.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 = dpr.with_rk4(LUV.dxdt, autonom=True) step_K = dpr.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
"""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 as dpr from dapper.mods.DoublePendulum import L1, L2, step, x0 E0 = x0 + 0.01 * np.random.randn(3, 4) simulator = dpr.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 x 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)]
print('--> use noisy/sparse observations') #List of values for the used paramters (should in a list) lparam = {k: params.get(k, [default_param[k]]) for k in used_paramter} #Sequence of all the combination of the parameters seq_param = ParameterGrid(lparam) #Load the model dt = model['dt'] model_module = __import__(model['model_module']) if model['type'] == 'physical': HMM_trunc = getattr(model_module, model['model_name']) trunc_model = with_recursion(HMM_trunc.Dyn.model) else: raise NotImplementedError("Only physical is available as model type") nn = len(seq_param) for i, dparam in enumerate(seq_param): print('Experiment {}/{}:'.format(i + 1, nn), dparam) #Load True simulation data_truth = np.load(file_truth.format(**dparam)) xx = data_truth['xx'] dt_full = data_truth['dt'] T = data_truth['T'] dtObs = dparam['dtObs'] #Modify chrono