class TestModel(unittest.TestCase): def setUp(self): # test data self.circle_solver = SystemSolver(CircleSystem()) def testSomething(self): res = self.circle_solver.run([0, 7], [0, 1])['results'] self.assertTrue(res.success) for i, t in enumerate(res.t): x, y = res.y[:, i] x_exp, y_exp = np.array([-np.sin(t), np.cos(t)]) self.assertAlmostEqual(x, x_exp, places=2) self.assertAlmostEqual(y, y_exp, places=2) def testCircleBox(self): t_span = [0, 300] res = self.circle_solver.run(t_span, [0, 1]) fig = self.circle_solver.plot2d(res, None) ax = fig.get_axes()[0] t_dense = np.arange(*t_span, t_span[1]/1000) box = np.array([np.cos(t_dense), -np.sin(t_dense)]) ax.plot(*box, '-') newbox = np.sqrt(res['results'].y[0, -1]**2 + res['results'].y[1, -1]**2)*box ax.plot(*newbox, '-') plt.show(False)
class TestModel(unittest.TestCase): def setUp(self): # test data self.pendulum_system = DoublePendulumSystem() self.pendulum_solver = SystemSolver(self.pendulum_system) self.run_dp_render = False def testDoublePendulum(self): clearFigs() run = self.pendulum_solver.run([0, 2], [.2, 1, 0, 0]) run2 = self.pendulum_solver.run([0, 2], [.2, 1.1, 0, 0]) fig = self.pendulum_solver.plotnd(run) self.pendulum_solver.plotnd(run2, fig) # plt.show(True) clearFigs() if self.run_dp_render: system = DoublePendulumSystem() fig = system.render_path(run, dot_size=2) system.render_path(run2, fig=fig, dot_size=2) plt.show(True) def testDoublePendulumFade(self): clearFigs() run = self.pendulum_solver.run([0, 5], [.2, 1, 0, 0]) system = DoublePendulumSystem() if self.run_dp_render: fig = system.render_fade_trail(run) plt.show(False) step = .02 for t in np.arange(.5, 5, step)[1:]: plt.pause(.001) plt.clf() fig = system.render_fade_trail(run, fig=fig, time=t) def testDoublePendulumTrail(self): clearFigs() run = self.pendulum_solver.run([0, 10], [.2, 1, 0, 0]) system = DoublePendulumSystem() if self.run_dp_render: fig = system.render_trail(run, time=.5) plt.show(False) step = .05 for t in np.arange(.5, 10, step): plt.pause(.00001) plt.clf() fig = system.render_trail(run, fig=fig, time=t) def testDoublePendulumTrailFast(self): clearFigs() run = self.pendulum_solver.run([0, 10], [.2, 1, 0, 3]) system = DoublePendulumSystem() if self.run_dp_render: fig = system.render_trail(run, time=.5) plt.show(False) step = .05 for t in np.arange(.5, 10, step): plt.pause(.00001) plt.clf() fig = system.render_trail(run, fig=fig, time=t)
def testWeirdLenSys(self): sys = DoublePendulumSystem(1, 2, .5, 1.5) slv = SystemSolver(sys) tf = 3 run1 = slv.run([0, tf], [pi, 1, 1, 0]) run2 = slv.run([0, tf], [pi, 1.001, 1, 0]) if self.render: self.runRender([run1, run2], 'odd_pend')
def testOrbit(self): Ms = 1.98847 * 10**30 # kg # M_earth = 5.9722 * 10**24 # kg Mj = 1.899 * 10**27 # kg Rj = 778.3 * 10**9 # m Tj = 3.743 * 10**8 # s # V_earth = 30 * 10**3 # m/s # r = 149.6 * 10**9 # m vel = 2 * pi * Rj / Tj sun_x = np.zeros(3) sun_v = np.zeros(3) jup_x = np.zeros(3) jup_v = np.zeros(3) jup_x[0] = Rj jup_v[1] = vel m = [Ms, Mj] v = np.concatenate((sun_x, jup_x, sun_v, jup_v)).reshape(-1) sys = NBodySystem(m) solver = SystemSolver(sys) res = solver.run([0, Tj * 1.5], v) solver.plotnd(res)
def testTwoPoints(self): # using IC from TODO sys = NBodySystem(body_masses=[1, 1], G=1) solver = SystemSolver(sys) max_t = 52 tspan = [0, max_t] y0 = np.zeros(2 * sys.body_dim * len(sys.body_masses), dtype=np.float64) y0[0:3] = [1, 0, 0] y0[3:6] = [-1, 0, 0] y0[6:9] = [0, .1, 0] y0[9:12] = [0, -.1, 0] run = solver.run(tspan, y0) # print() # print(*y0) # print(*run['results'].y[:, -1]) # clearFigs() # fig = solver.plotnd(run) # for axes in fig.axes: # axes.plot(np.zeros_like(run['results'].y[0])) t = run['results'].t y = run['results'].y # print(t.shape, y.shape) # print(t[-1], max_t) y0 = y[0] y1 = y[3] clearFigs() plt.figure() plt.plot(t, y0) plt.plot(t, y1)
def testFig8(self): # using IC from TODO sys = NBodySystem(body_masses=[1, 1, 1], G=1) solver = SystemSolver(sys) tspan = [0, 10] y0 = np.zeros(2 * sys.body_dim * len(sys.body_masses), dtype=np.float64) x1 = np.array([0.97000436, -0.24308753, 0]) x3p = np.array([-0.93240737, -0.86473146, 0]) y0[0:3] = x1 y0[3:6] = -x1 y0[6:9] = 0 y0[9:12] = -x3p / 2 y0[12:15] = -x3p / 2 y0[15:18] = x3p # print(sys.fun(np.zeros_like(y0), y0).reshape(6, -1)) run = solver.run(tspan, y0) clearFigs() solver.plotnd(run) # print(run['results'].y[:, -1].reshape(6, -1)) y_act = run['results'].y[:9] run['results'].y = y_act[:3] fig = solver.plot3d(run) run['results'].y = y_act[3:6] fig = solver.plot3d(run, fig=fig) run['results'].y = y_act[6:9] fig = solver.plot3d(run, fig=fig)
def testRandomInit(self): sys = NBodySystem(body_masses=[1, 1, 1], G=1) solver = SystemSolver(sys) tspan = [0, 100] expand = 10 y0 = np.random.rand(2 * sys.body_dim * len(sys.body_masses)) * expand y0[9:] /= expand / 2 total_mass = np.sum(sys.body_masses) vcm = np.zeros(3) for m, v in zip(sys.body_masses, y0[9:].reshape(3, -1)): vcm += m * v vcm /= total_mass yps = y0[9:].reshape(3, -1) yps -= vcm[None, :] run = solver.run(tspan, y0) clearFigs() solver.plotnd(run) # print(run['results'].y[:, -1].reshape(6, -1)) y_act = run['results'].y[:9] run['results'].y = y_act[:3] fig = solver.plot3d(run) run['results'].y = y_act[3:6] fig = solver.plot3d(run, fig=fig) run['results'].y = y_act[6:9] fig = solver.plot3d(run, fig=fig) plt.show(True)
def testExample(self): sys = RestrictedCircular3Body() slv = SystemSolver(sys) lce, lce_run = slv.get_lce() slv.calc_lce # print(lce) init = [1, -1, 1, -1] run = slv.run([0, 5], init) run['results'].y = run['results'].y[:2, :] slv.plot2d(run)
class TestModel(unittest.TestCase): def setUp(self): # test data self.circle_solver = SystemSolver(CircleSystem()) self.lorenz_solver = SystemSolver(LorenzSystem()) def test3dGraph(self): res = self.lorenz_solver.run([0, 10], [1, 1, 1]) fig = self.lorenz_solver.plotnd(res) self.lorenz_solver.plot3d(res) self.assertEqual(4, len(fig.get_axes())) def test2dGraph(self): res = self.circle_solver.run([0, 10], [1, 1]) fig = self.circle_solver.plotnd(res) self.circle_solver.plot2d(res) self.assertEqual(3, len(fig.get_axes())) def testMultiGraph(self): run1 = self.lorenz_solver.run([0, 20], [1, 1, 1]) run2 = self.lorenz_solver.run([0, 20], [1, 1, 1]) run3 = self.lorenz_solver.run([0, 20], [1, 1, 1 + 10**-9]) fig = self.lorenz_solver.plot3d(run1) fig = self.lorenz_solver.plot3d(run2, fig) self.lorenz_solver.plot3d(run3, fig) # You should see that orange (2nd graph) covers blue (1st graph) while # adding a billionth to green (3rd graph) causes it to diverge. def testMulti2dGraph(self): run1 = self.circle_solver.run([0, 20], [0, 2]) run2 = self.circle_solver.run([0, 20], [0, 1]) fig = self.circle_solver.plot2d(run1) self.circle_solver.plot2d(run2, fig) def testMultiNdGraph(self): run1 = self.lorenz_solver.run([0, 20], [1, 1, 1]) run2 = self.lorenz_solver.run([0, 20], [1, 1, 1.001]) fig = self.lorenz_solver.plotnd(run1) self.lorenz_solver.plotnd(run2, fig)
self.k[i] *= self.e[i-1] * self.k[i-1] self.levels = levels def fun(self, t, v): r = self.r k = self.k e = self.e trans = r * v*v/k y = np.zeros_like(v) y[0] += r * v[0] y[1:] += e*trans[:-1] y -= trans return y if __name__ == '__main__': biome1 = {'rate': 1, 'capacity': 1000, 'efficiency': [.1, .12], 'levels':3} biome2 = {'rate': .1, 'capacity': 100, 'efficiency': [.1, .9], 'levels':3} biome3 = {'rate': .01, 'capacity': 5000, 'efficiency': [.1, .2], 'levels':3} problem = EcoSystem([biome1, biome2, biome3]) solver = SystemSolver(problem) y0 = np.zeros(problem.dim) y0[0] = 1 y0[3] = 1 y0[4] = 1000 y0[6] = 1 solver.run([0, 200], y0) solver.plotnd() plt.show(True)
import os import numpy as np import matplotlib.pyplot as plt from echonn.sys import LorenzSystem, SystemSolver if __name__ == "__main__": lorenz_3d_plot = os.path.join('..', 'images', 'lorenz_3d_plot.png') lorenz_nd_plot = os.path.join('..', 'images', 'lorenz_nd_plot.png') slv = SystemSolver(LorenzSystem()) res = slv.run([0, 50], [10, 20, 30]) slv.plotnd(res, dims=['x', 'y', 'z']) plt.savefig(lorenz_nd_plot) slv.plot3d(res) plt.savefig(lorenz_3d_plot) plt.show(True)
y0 = np.zeros(2 * sys.body_dim * len(sys.body_masses), dtype=np.float64) x1 = np.array([0.97000436, -0.24308753, 0]) x3p = np.array([-0.93240737, -0.86473146, 0]) y0[0:3] = x1 y0[3:6] = -x1 y0[6:9] = 0 y0[9:12] = -x3p / 2 y0[12:15] = -x3p / 2 y0[15:18] = x3p tspan = [0, 100] # print(sys.fun(np.zeros_like(y0), y0).reshape(6, -1)) run = solver.run(tspan, y0) # solver.plotnd(run) # print(run['results'].y[:, -1].reshape(6, -1)) y_act = run['results'].y[:9] run['results'].y = y_act[:3] fig = solver.plot3d(run) run['results'].y = y_act[3:6] fig = solver.plot3d(run, fig=fig) run['results'].y = y_act[6:9] fig = solver.plot3d(run, fig=fig) plt.title('Long Run of 3 Body Figure 8') plt.tight_layout() plt.savefig(os.path.join(dir_pre, 'fig8_long.png')) tspan = [0, 10] # print(sys.fun(np.zeros_like(y0), y0).reshape(6, -1))
class TestDoubPenAnim(unittest.TestCase): def setUp(self): # test data self.pendulum_system = DoublePendulumSystem() self.pendulum_solver = SystemSolver(self.pendulum_system) # run render test self.render_til = 10 self.render_long = False # slows test a lot self.render = False # slows test def testWeirdLenSys(self): sys = DoublePendulumSystem(1, 2, .5, 1.5) slv = SystemSolver(sys) tf = 3 run1 = slv.run([0, tf], [pi, 1, 1, 0]) run2 = slv.run([0, tf], [pi, 1.001, 1, 0]) if self.render: self.runRender([run1, run2], 'odd_pend') def testLongRun(self): tf = 50 run1 = self.pendulum_solver.run([0, tf], [pi, 1, 1, 0]) run2 = self.pendulum_solver.run([0, tf], [pi, 1.001, 1, 0]) if self.render_long: self.runRender([run1, run2], 'long_run', mult=.75) def testRender(self): run1 = self.pendulum_solver.run([0, self.render_til], [.2, 1, 1, 0]) run2 = self.pendulum_solver.run([0, self.render_til], [.2, 1.1, 1, 0]) if self.render: self.runRender(run1, 'run1') self.runRender([run1], 'run1_mult', mult=2) self.runRender([run1, run2], 'run2', mult=.5) def runRender(self, runs, fname, mult=1): animator = DoublePendulumAnimator(runs, speed=mult) animator.render() fname = os.path.join('src', 'test', 'test_data', fname) # http://thesmithfam.org/blog/2012/10/25/temporarily-suppress-console-output-in-python/ @contextmanager def suppress_stdout(): with open(os.devnull, "w") as devnull: old_stdout = sys.stdout old_stderr = sys.stderr sys.stdout = devnull sys.stderr = devnull try: yield finally: sys.stdout = old_stdout sys.stderr = old_stderr try: os.remove(fname + '.gif') except: pass # we don't care self.assertFalse(os.path.isfile(fname + '.gif')) with suppress_stdout(): animator.save(fname) self.assertTrue(os.path.isfile(fname + '.gif'))
Arctic = 2000 Arid = 7000 def __init__(self, flight_rate=50, fire_rate=80, biome=None): super().__init__(dim=2) if biome is None: biome = XwaModel.Grass self.flight_rate = flight_rate self.fire_rate = fire_rate self.biome_carry_capacity = biome self.biome_growth_rate = 10 def fun(self, t, v): w, r = v x = r * w a = self.flight_rate + self.fire_rate dw = (x - w * a) / 10**4 dr = -x + self.biome_growth_rate * r - self.biome_growth_rate * r**2 / self.biome_carry_capacity if t < 100: dw = 0 return dw, dr if __name__ == '__main__': problem = XwaModel() solver = SystemSolver(problem) y0 = np.array([8, 5000]) solver.run([0, 250], y0) solver.plotnd() plt.show(True)