def setUp(self): ivp = ode.Res2Bod(t0=0., tmax=0.011) ibm_prior = stsp.IBM(q=2, dim=4) solver = oso.ODESolver(ibm_prior) self.t, mean, stdev = solver.solve(ivp, stepsize=0.0001) self.m1 = oso.get_trajectory(mean, 0, 0) self.m2 = oso.get_trajectory(mean, 1, 0)
def test_uncert_not_scalar(self): """ We test whether the uncertainty (third element of derivative_data) is only accepted as a scalar. """ # Set Model Parameters odeparam = 1. y0, y0_unc = 1.0, 0 t0, tmax = 0.0, 1.25 # Set Method Parameters q = 1 h = 0.1 # Set up and solve ODE ibm = statespace.IBM(q=q, dim=1) solver = linsolve.LinearisedODESolver(ibm) ivp = linode.LinearODE(t0, tmax, odeparam, y0, y0_unc) tsteps, means, __, rhs_parts, should_not_work = solver.solve(ivp, stepsize=h) self.mean = odesolver.get_trajectory(means, 0, 0) # Set up BM and IBM covariance matrices evalpt = np.array(tsteps[[-1]]) with self.assertRaises(TypeError): derdat = (tsteps, rhs_parts, should_not_work) linearisation.compute_linearisation(ssm=ibm, initial_value=y0, derivative_data=derdat, prdct_tsteps=evalpt)
def setUp(self): """ Create a working prior, working filtertype and working evalparam. """ self.working_2d_prior = stsp.IBM(q=1, dim=2) self.working_filtertype = "kalman"
def test_instantiation_impossible(self): """ Test passes if Filter object cannot be instantiated. """ ssm = statespace.IBM(q=2, dim=1) with self.assertRaises(TypeError): filters.Filter(ssm)
def setUp(self): """ Set up linear ODE (i.e. one-dim, one parameter) and one evalpt. """ # Set Model Parameters odeparam = 1. y0, y0_unc = 1.0, 0 t0, tmax = 0.0, 1.25 # Set Method Parameters q = 1 h = 0.1 # Set up and solve ODE ibm = statespace.IBM(q=q, dim=1) solver = linsolve.LinearisedODESolver(ibm) ivp = linode.LinearODE(t0, tmax, odeparam, y0, y0_unc) tsteps, means, __, rhs_parts, uncerts = solver.solve(ivp, stepsize=h) self.mean = odesolver.get_trajectory(means, 0, 0) # Set up BM and IBM covariance matrices evalpt = np.array([tsteps[-1]]) derdat = (tsteps, rhs_parts, 0.) const, jacob = linearisation.compute_linearisation( ssm=ibm, initial_value=y0, derivative_data=derdat, prdct_tsteps=evalpt) # Compute GP Estimation of filter mean at t=tmax self.postmean = const + np.dot(jacob[:, 0], odeparam)
def setUp(self): """ Set up linearised ODESolver and Res2Bod as a non-linearised ODE. """ prior = stsp.IBM(q=1, dim=4) self.solver = linsolver.LinearisedODESolver(prior, filtertype="kalman") self.ode = standard_ode.Res2Bod(t0=0.0, tmax=1.2)
def setUp(self): """ Set up Lotka-Volterra ODE (i.e. two-dim, four parameter) and multiple (two) evalpts. """ # Set Model Parameters odeparam = np.array([0, 1, 1, 2]) y0, y0_unc = np.ones(2), 0 * np.ones(2) t0, tmax = 0.0, 1.25 # Set Method Parameters q = 1 h = 0.1 # Set up and solve ODE ibm = statespace.IBM(q=q, dim=len(y0)) solver = linsolve.LinearisedODESolver(ibm) ivp = linode.LotkaVolterra(t0, tmax, odeparam, y0, y0_unc) tsteps, means, __, rhs_parts, uncerts = solver.solve(ivp, stepsize=h) self.mean = odesolver.get_trajectory_multidim(means, [0, 1], 0) # Set up BM and IBM covariance matrices evalpt = np.array(tsteps[[-1, -10]]) derdat = (tsteps, rhs_parts, 0.) const, jacob = linearisation.compute_linearisation( ssm=ibm, initial_value=y0, derivative_data=derdat, prdct_tsteps=evalpt) # Compute GP Estimation of filter mean at t=tmax postmean = const + np.dot(jacob, odeparam) self.postmean = postmean.reshape((2, 2))
def _setup_ibm_q1(self): """ Set up IBM(1) state space model, i.e. q=1. """ q = 1 bm_amp = 1.0 + np.random.rand() dim = 1 self.ssm = stsp.IBM(q, dim, bm_amp)
def setUp(self): """Setup odesolver and solve a scalar ode""" prior = stsp.IBM(q=1, dim=1) self.solver = oso.ODESolver(prior, filtertype="kalman") self.ode = ode.LinearODE(t0=0.0, tmax=1.2, params=2.0, initval=4.1) self.h = 0.1 self.tsteps, self.means, self.stdevs = self.solver.solve( self.ode, stepsize=self.h)
def _setup_ibm_q2(self): """ Set up IBM(2) state space model. """ q = 2 bm_amp = 1.0 + np.random.rand() dim = 1 self.ssm = stsp.IBM(q, dim, bm_amp)
def setUp(self): pars = [0., 0.2, 0.2, 3.0] y0 = np.array([-1, 1]) ivp = ode.FitzHughNagumo(t0=0., tmax=5., params=pars, initval=y0) ibm_prior = stsp.IBM(q=1, dim=2) solver = oso.ODESolver(ibm_prior) self.t, mean, stdev = solver.solve(ivp, stepsize=0.05) self.m1 = oso.get_trajectory(mean, 0, 0) self.m2 = oso.get_trajectory(mean, 1, 0)
def setUp(self): """ Set up linear ODE and linearised ODESolver. """ prior = stsp.IBM(q=1, dim=1) solver = linsolver.LinearisedODESolver(prior, filtertype="kalman") ode = linode.LinearODE(t0=0.0, tmax=1.2, params=2.0, initval=4.1) h = 0.1 output = solver.solve(ode, h) __, __, __, self.rhs_parts, self.uncert = output
def setUp(self): """ Set up linear ode and solve with stepsize h = 0.1. """ prior = stsp.IBM(q=1, dim=1) self.solver = linsolver.LinearisedODESolver(prior, filtertype="kalman") self.ode = linode.LinearODE(t0=0.0, tmax=1.2, params=2.0, initval=4.1) self.h = 0.1 output = self.solver.solve(self.ode, self.h) self.tsteps, self.means, self.stdevs, __, __ = output
def setUp(self): """ Set up LotkaVolterra ODE and LinearisedODESolver. """ prior = stsp.IBM(q=1, dim=2) solver = linsolver.LinearisedODESolver(prior, filtertype="kalman") params = [0.1, 0.2, 0.3, 0.4] ode = linode.LotkaVolterra(t0=0.0, tmax=1.2, params=params, initval=np.ones(2)) h = 0.1 output = solver.solve(ode, h) __, __, __, self.rhs_parts, self.uncert = output
def test_solution_controlvar(self): """ Controlvariate to the test_solution() test. For q < 2 or stepsize > 0.0001 the precision should not be achieved anymore. """ ivp = ode.Res2Bod(t0=0., tmax=0.011) ibm_prior = stsp.IBM(q=1, dim=4) solver = oso.ODESolver(ibm_prior) self.t, mean, stdev = solver.solve(ivp, stepsize=0.0001) self.m1 = oso.get_trajectory(mean, 0, 0) self.m2 = oso.get_trajectory(mean, 1, 0) x_benchmark = 0.986122388809302 y_benchmark = -0.014199005665214861 thresh = 1e-10 self.assertEqual(traj_passes_pt(self.m1, x_benchmark, thresh), False) self.assertEqual(traj_passes_pt(self.m2, y_benchmark, thresh), False)
Checks whether odesolver works up to high accuracy via solving the restricted two-body problem. This might take 20-30 seconds. If the resulting orbit is periodic, the solution is correct. """ import numpy as np import matplotlib.pyplot as plt from difflikelihoods import ode from difflikelihoods import odesolver from difflikelihoods import statespace # Solve ODE stsp = statespace.IBM(q=2, dim=4) solver = odesolver.ODESolver(ssm=stsp, filtertype="kalman") r2b = ode.Res2Bod(t0=0, tmax=32) t, m, s = solver.solve(r2b, stepsize=0.0001) # Extract relevant trajectories mtraj1 = odesolver.get_trajectory(m, 0, 0) mtraj2 = odesolver.get_trajectory(m, 1, 0) # Plot solution plt.title("Restricted Two-Body Problem") plt.plot(mtraj1, mtraj2, label="Trajectory") plt.plot(mtraj1[0], mtraj2[0], "o", label="Starting point at t=t0") plt.plot(mtraj1[-1], mtraj2[-1], "o", label="Endpoint at t=tmax") plt.legend() plt.show()
np.random.seed(1) # Set Model Parameters initial_value = np.array([20, 20]) initial_time, end_time = 0.0, 5.0 ivpvar = 1e-2 thetatrue = np.array([1.0, 0.1, 0.1, 1.0]) ivp = linode.LotkaVolterra(initial_time, end_time, params=thetatrue, initval=initial_value) # Set Method Parameters h_for_data = (end_time - initial_time) / 10000 h = (end_time - initial_time) / 200 solver = linsolver.LinearisedODESolver(statespace.IBM(q=1, dim=2)) ipdata = create_data(solver, ivp, thetatrue, h_for_data, ivpvar) iplklhd = ip.InvProblemLklhd(ipdata, ivp, solver, h, with_jacob=True) # Sample from posteriors niter = 50 init_theta = np.array([0.8, 0.2, 0.05, 1.1]) samples_ham, probs_ham = hamiltonian(niter, iplklhd, init_theta, stepsize=0.2, nsteps=6) samples_lang, probs_lang = langevin(niter, iplklhd, init_theta, stepsize=1.2)
""" solve_fhn.py Checking the compliance of ode.py, statespace.py and odesolver.py by solving the FitzHugh-Nagumo model. If the output looks 'proper' and a little uncertainty is visible, the test passes. """ import numpy as np from difflikelihoods import ode from difflikelihoods import odesolver from difflikelihoods import statespace import matplotlib.pyplot as plt # Solve ODE stsp = statespace.IBM(q=1, dim=2) solver = odesolver.ODESolver(ssm=stsp, filtertype="kalman") fhn = ode.FitzHughNagumo( t0=0.0, tmax=15.0, params=[0.0, 0.08, 0.07, 1.25], initval=np.array([1.0, 0.0]), initval_unc=1e-24, ) t, m, s = solver.solve(fhn, stepsize=0.01) # Extract relevant trajectories mtraj1 = odesolver.get_trajectory(m, 0, 0) munc1 = odesolver.get_trajectory(s, 0, 0) mtraj2 = odesolver.get_trajectory(m, 1, 0) munc2 = odesolver.get_trajectory(s, 1, 0)
np.random.seed(1) # Set Model Parameters initial_value = 2.0 initial_time = 0.1 end_time = 1.1 ivpnoise = 0.01 thetatrue = 0.25 # Set Method Parameters q = 1 h = 0.2 nsamps = 25 init_theta = 0.99 * np.ones(1) ibm = statespace.IBM(q=q, dim=1) solver = linsolver.LinearisedODESolver(ibm) pwidth = 0.004 # Create Data and Jacobian ivp = linode.LinearODE(initial_time, end_time, params=thetatrue, initval=initial_value, initval_unc=0.0) evalpt, data = create_data(solver, ivp, thetatrue, 1e-04, ivpnoise) tsteps, __, __, __, __ = solver.solve(ivp, stepsize=h) evalpt = np.array(tsteps[[-1]]) kernel_prefactor = linearisation.compute_kernel_prefactor( ibm, 0.0, tsteps, evalpt)