def test_continuous_initial_condition_1d_pde(): diff_eq = DiffusionEquation(1) mesh = Mesh([(0., 20.)], [.1]) bcs = [(DirichletBoundaryCondition(lambda x, t: np.zeros((len(x), 1)), is_static=True), DirichletBoundaryCondition(lambda x, t: np.full((len(x), 1), 1.5), is_static=True))] cp = ConstrainedProblem(diff_eq, mesh, bcs) initial_condition = ContinuousInitialCondition( cp, lambda x: np.exp(-np.square(np.array(x) - 10.) / (2 * 5**2))) assert np.isclose(initial_condition.y_0(np.full((1, 1), 10.)), 1.) assert np.isclose( initial_condition.y_0(np.full((1, 1), np.sqrt(50) + 10.)), np.e**-1) assert np.allclose(initial_condition.y_0(np.full((5, 1), 10.)), np.ones((5, 1))) y_0_vertices = initial_condition.discrete_y_0(True) assert y_0_vertices.shape == (201, 1) assert y_0_vertices[0, 0] == 0. assert y_0_vertices[-1, 0] == 1.5 assert y_0_vertices[100, 0] == 1. assert np.all(0. < y_0_vertices[1:100, 0]) \ and np.all(y_0_vertices[1:100, 0] < 1.) assert np.all(0. < y_0_vertices[101:-1, 0]) \ and np.all(y_0_vertices[101:-1, 0] < 1.) y_0_cell_centers = initial_condition.discrete_y_0(False) assert y_0_cell_centers.shape == (200, 1) assert np.all(0. < y_0_cell_centers) and np.all(y_0_cell_centers < 1.)
def test_continuous_initial_condition_pde_with_wrong_shape(): diff_eq = WaveEquation(1) mesh = Mesh([(0., 10.)], [1.]) bcs = [(DirichletBoundaryCondition(lambda x: np.zeros((len(x), 2))), ) * 2] cp = ConstrainedProblem(diff_eq, mesh, bcs) with pytest.raises(ValueError): ContinuousInitialCondition(cp, lambda x: np.zeros((3, 2)))
def test_solution_ode(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([5., 10.])) ivp = InitialValueProblem(cp, (0., 10.), ic) t_coordinates = np.array([5., 10.]) discrete_y = np.arange(4).reshape((2, 2)) solution = Solution(ivp, t_coordinates, discrete_y) assert solution.initial_value_problem == ivp assert np.array_equal(solution.t_coordinates, t_coordinates) assert np.isclose(solution.d_t, 5.) assert solution.vertex_oriented is None assert np.allclose(solution.y(), [[0., 1.], [2., 3.]]) assert np.allclose(solution.discrete_y(), [[0., 1.], [2., 3.]]) other_solutions = [ Solution(ivp, np.linspace(2.5, 10., 4), np.arange(8).reshape((4, 2))), Solution(ivp, np.linspace(1.25, 10., 8), np.arange(16).reshape((8, 2))) ] expected_differences = [ [[2., 2.], [4., 4.]], [[6., 6.], [12., 12.]], ] diff = solution.diff(other_solutions) assert np.allclose(diff.matching_time_points, [5., 10.]) assert np.allclose(diff.differences, expected_differences)
def test_pidon_operator_on_spherical_pde(): set_random_seed(0) diff_eq = DiffusionEquation(3) mesh = Mesh( [(1., 11.), (0., 2 * np.pi), (.25 * np.pi, .75 * np.pi)], [2., np.pi / 5., np.pi / 4], CoordinateSystem.SPHERICAL) bcs = [ (DirichletBoundaryCondition( lambda x, t: np.ones((len(x), 1)), is_static=True), DirichletBoundaryCondition( lambda x, t: np.full((len(x), 1), 1. / 11.), is_static=True)), (NeumannBoundaryCondition( lambda x, t: np.zeros((len(x), 1)), is_static=True), NeumannBoundaryCondition( lambda x, t: np.zeros((len(x), 1)), is_static=True)), (NeumannBoundaryCondition( lambda x, t: np.zeros((len(x), 1)), is_static=True), NeumannBoundaryCondition( lambda x, t: np.zeros((len(x), 1)), is_static=True)) ] cp = ConstrainedProblem(diff_eq, mesh, bcs) ic = ContinuousInitialCondition(cp, lambda x: 1. / x[:, :1]) t_interval = (0., .5) ivp = InitialValueProblem(cp, t_interval, ic) sampler = UniformRandomCollocationPointSampler() pidon = PIDONOperator(sampler, .001, True) training_loss_history, test_loss_history = pidon.train( cp, t_interval, training_data_args=DataArgs( y_0_functions=[ic.y_0], n_domain_points=20, n_boundary_points=10, n_batches=1 ), model_args=ModelArgs( latent_output_size=20, branch_hidden_layer_sizes=[30, 30], trunk_hidden_layer_sizes=[30, 30], ), optimization_args=OptimizationArgs( optimizer=optimizers.Adam(learning_rate=2e-5), epochs=3, verbose=False ) ) assert len(training_loss_history) == 3 for i in range(2): assert np.all( training_loss_history[i + 1].weighted_total_loss.numpy() < training_loss_history[i].weighted_total_loss.numpy()) solution = pidon.solve(ivp) assert solution.d_t == .001 assert solution.discrete_y().shape == (500, 6, 11, 3, 1)
def test_initial_value_problem_with_invalid_time_interval(): diff_eq = PopulationGrowthEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([0.])) with pytest.raises(ValueError): InitialValueProblem(cp, (3., 2.), ic)
def test_pidon_operator_in_ar_mode_training_with_invalid_t_interval(): diff_eq = PopulationGrowthEquation() cp = ConstrainedProblem(diff_eq) t_interval = (0., 1.) ic = ContinuousInitialCondition(cp, lambda _: np.array([1.])) sampler = UniformRandomCollocationPointSampler() pidon = PIDONOperator(sampler, .25, True, auto_regression_mode=True) with pytest.raises(ValueError): pidon.train( cp, t_interval, training_data_args=DataArgs( y_0_functions=[ic.y_0], n_domain_points=50, n_batches=1 ), model_args=ModelArgs( latent_output_size=1, trunk_hidden_layer_sizes=[50, 50, 50], ), optimization_args=OptimizationArgs( optimizer={'class_name': 'Adam'}, epochs=100, verbose=False ) )
def test_fdm_operator_on_2d_pde(): diff_eq = NavierStokesEquation(5000.) mesh = Mesh([(0., 10.), (0., 10.)], [1., 1.]) bcs = [(DirichletBoundaryCondition( vectorize_bc_function(lambda x, t: (1., .1, None, None)), is_static=True), DirichletBoundaryCondition( vectorize_bc_function(lambda x, t: (0., 0., None, None)), is_static=True)), (DirichletBoundaryCondition( vectorize_bc_function(lambda x, t: (0., 0., None, None)), is_static=True), DirichletBoundaryCondition( vectorize_bc_function(lambda x, t: (0., 0., None, None)), is_static=True))] cp = ConstrainedProblem(diff_eq, mesh, bcs) ic = ContinuousInitialCondition(cp, lambda x: np.zeros((len(x), 4))) ivp = InitialValueProblem(cp, (0., 10.), ic) op = FDMOperator(RK4(), ThreePointCentralDifferenceMethod(), .25) solution = op.solve(ivp) assert solution.vertex_oriented assert solution.d_t == .25 assert solution.discrete_y().shape == (40, 11, 11, 4) assert solution.discrete_y(False).shape == (40, 10, 10, 4)
def test_auto_regression_operator_on_ode_with_isolated_perturbations(): set_random_seed(0) diff_eq = LotkaVolterraEquation(2., 1., .8, 1.) cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([1., 2.])) ivp = InitialValueProblem(cp, (0., 10.), ic) oracle = ODEOperator('DOP853', .001) ref_solution = oracle.solve(ivp) ml_op = AutoRegressionOperator(2.5, True) ml_op.train(ivp, oracle, RandomForestRegressor(), 25, lambda t, y: y + np.random.normal(0., .01, size=y.shape), isolate_perturbations=True) ml_solution = ml_op.solve(ivp) assert ml_solution.vertex_oriented assert ml_solution.d_t == 2.5 assert ml_solution.discrete_y().shape == (4, 2) diff = ref_solution.diff([ml_solution]) assert np.all(diff.matching_time_points == np.linspace(2.5, 10., 4)) assert np.max(np.abs(diff.differences[0])) < .01
def test_fdm_operator_on_pde_with_t_and_x_dependent_rhs(): class TestDiffEq(DifferentialEquation): def __init__(self): super(TestDiffEq, self).__init__(2, 1) @property def symbolic_equation_system(self) -> SymbolicEquationSystem: return SymbolicEquationSystem([ self.symbols.t / 100. * (self.symbols.x[0] + self.symbols.x[1])**2 ]) diff_eq = TestDiffEq() mesh = Mesh([(-5., 5.), (0., 3.)], [2., 1.]) bcs = [(NeumannBoundaryCondition(lambda x, t: np.zeros((len(x), 1))), NeumannBoundaryCondition(lambda x, t: np.zeros((len(x), 1))))] * 2 cp = ConstrainedProblem(diff_eq, mesh, bcs) ic = ContinuousInitialCondition(cp, lambda x: np.zeros((len(x), 1))) ivp = InitialValueProblem(cp, (0., 5.), ic) op = FDMOperator(RK4(), ThreePointCentralDifferenceMethod(), .25) solution = op.solve(ivp) y = solution.discrete_y() assert solution.vertex_oriented assert solution.d_t == .25 assert y.shape == (20, 6, 4, 1)
def test_solution_with_invalid_t_coordinate_dimensions(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([5., 10.])) ivp = InitialValueProblem(cp, (0., 10.), ic) discrete_y = np.zeros((2, 2)) with pytest.raises(ValueError): Solution(ivp, np.array([[5., 10.]]), discrete_y)
def test_continuous_initial_condition_ode(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) initial_condition = ContinuousInitialCondition( cp, lambda _: np.array([10., 100.])) assert np.all(initial_condition.y_0(None) == [10., 100.]) assert np.all(initial_condition.discrete_y_0() == [10., 100.])
def test_solution_with_mismatched_discrete_y_shape(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([5., 10.])) ivp = InitialValueProblem(cp, (0., 10.), ic) discrete_y = np.zeros((2, 3)) with pytest.raises(ValueError): Solution(ivp, np.array([5., 10.]), discrete_y)
def test_pidon_operator_on_ode_with_analytic_solution(): set_random_seed(0) r = 4. y_0 = 1. diff_eq = PopulationGrowthEquation(r) cp = ConstrainedProblem(diff_eq) t_interval = (0., .25) ic = ContinuousInitialCondition(cp, lambda _: np.array([y_0])) sampler = UniformRandomCollocationPointSampler() pidon = PIDONOperator(sampler, .001, True) training_loss_history, test_loss_history = pidon.train( cp, t_interval, training_data_args=DataArgs( y_0_functions=[ic.y_0], n_domain_points=25, n_batches=5, n_ic_repeats=5 ), model_args=ModelArgs( latent_output_size=1, trunk_hidden_layer_sizes=[50, 50, 50], ), optimization_args=OptimizationArgs( optimizer=optimizers.SGD(), epochs=100, verbose=False ), secondary_optimization_args=SecondaryOptimizationArgs( max_iterations=100, verbose=False ) ) assert len(training_loss_history) == 101 assert len(test_loss_history) == 0 assert training_loss_history[-1].weighted_total_loss.numpy() < 5e-5 ivp = InitialValueProblem( cp, t_interval, ic, lambda _ivp, t, x: np.array([y_0 * np.e ** (r * t)]) ) solution = pidon.solve(ivp) assert solution.d_t == .001 assert solution.discrete_y().shape == (250, 1) analytic_y = np.array([ivp.exact_y(t) for t in solution.t_coordinates]) assert np.mean(np.abs(analytic_y - solution.discrete_y())) < 1e-3 assert np.max(np.abs(analytic_y - solution.discrete_y())) < 2.5e-3
def test_fdm_operator_on_pde_with_t_and_x_dependent_rhs(): class TestDiffEq(DifferentialEquation): def __init__(self): super(TestDiffEq, self).__init__(2, 1) @property def symbolic_equation_system(self) -> SymbolicEquationSystem: return SymbolicEquationSystem([ self.symbols.t / 100. * (self.symbols.x[0] + self.symbols.x[1]) ** 2 ]) diff_eq = TestDiffEq() mesh = Mesh([(-1., 1.), (0., 2.)], [2., 1.]) bcs = [ (NeumannBoundaryCondition(lambda x, t: np.zeros((len(x), 1))), NeumannBoundaryCondition(lambda x, t: np.zeros((len(x), 1)))) ] * 2 cp = ConstrainedProblem(diff_eq, mesh, bcs) ic = ContinuousInitialCondition(cp, lambda x: np.zeros((len(x), 1))) t_interval = (0., 1.) ivp = InitialValueProblem(cp, t_interval, ic) sampler = UniformRandomCollocationPointSampler() pidon = PIDONOperator(sampler, .05, True) training_loss_history, test_loss_history = pidon.train( cp, t_interval, training_data_args=DataArgs( y_0_functions=[ic.y_0], n_domain_points=20, n_boundary_points=10, n_batches=1 ), model_args=ModelArgs( latent_output_size=20, branch_hidden_layer_sizes=[30, 30], trunk_hidden_layer_sizes=[30, 30], ), optimization_args=OptimizationArgs( optimizer=optimizers.Adam(learning_rate=2e-5), epochs=3, verbose=False ) ) assert len(training_loss_history) == 3 for i in range(2): assert np.all( training_loss_history[i + 1].weighted_total_loss.numpy() < training_loss_history[i].weighted_total_loss.numpy()) solution = pidon.solve(ivp) assert solution.d_t == .05 assert solution.discrete_y().shape == (20, 2, 3, 1)
def test_pidon_operator_on_pde_system(): set_random_seed(0) diff_eq = NavierStokesEquation() mesh = Mesh([(-2.5, 2.5), (0., 4.)], [1., 1.]) ic_function = vectorize_ic_function(lambda x: [ 2. * x[0] - 4., 2. * x[0] ** 2 + 3. * x[1] - x[0] * x[1] ** 2, 4. * x[0] - x[1] ** 2, 2. * x[0] * x[1] - 3. ]) bcs = [ (DirichletBoundaryCondition( lambda x, t: ic_function(x), is_static=True), DirichletBoundaryCondition( lambda x, t: ic_function(x), is_static=True)) ] * 2 cp = ConstrainedProblem(diff_eq, mesh, bcs) ic = ContinuousInitialCondition(cp, ic_function) t_interval = (0., .5) ivp = InitialValueProblem(cp, t_interval, ic) sampler = UniformRandomCollocationPointSampler() pidon = PIDONOperator(sampler, .001, True) training_loss_history, test_loss_history = pidon.train( cp, t_interval, training_data_args=DataArgs( y_0_functions=[ic.y_0], n_domain_points=20, n_boundary_points=10, n_batches=1 ), model_args=ModelArgs( latent_output_size=20, branch_hidden_layer_sizes=[20, 20], trunk_hidden_layer_sizes=[20, 20], ), optimization_args=OptimizationArgs( optimizer=optimizers.Adam(learning_rate=1e-5), epochs=3, verbose=False ) ) assert len(training_loss_history) == 3 for i in range(2): assert np.all( training_loss_history[i + 1].weighted_total_loss.numpy() < training_loss_history[i].weighted_total_loss.numpy()) solution = pidon.solve(ivp) assert solution.d_t == .001 assert solution.discrete_y().shape == (500, 6, 5, 4)
def test_initial_value_problem_without_exact_solution(): diff_eq = PopulationGrowthEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([0.])) ivp = InitialValueProblem(cp, (0., 2.), ic) assert not ivp.has_exact_solution with pytest.raises(RuntimeError): ivp.exact_y(2.)
def test_auto_regression_operator_with_wrong_perturbed_initial_value_shape(): diff_eq = LorenzEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.ones(3)) ivp = InitialValueProblem(cp, (0., 10.), ic) oracle = ODEOperator('DOP853', .001) ml_op = AutoRegressionOperator(2.5, True) with pytest.raises(ValueError): ml_op.train(ivp, oracle, LinearRegression(), 25, lambda t, y: np.array([1.]))
def test_auto_regression_operator_training_with_zero_iterations(): diff_eq = LorenzEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.ones(3)) ivp = InitialValueProblem(cp, (0., 10.), ic) oracle = ODEOperator('DOP853', .001) ml_op = AutoRegressionOperator(2.5, True) with pytest.raises(ValueError): ml_op.train(ivp, oracle, LinearRegression(), 0, lambda t, y: y + np.random.normal(0., .01, size=y.shape))
def test_ode_operator_on_ode(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([100., 15.])) ivp = InitialValueProblem(cp, (0., 10.), ic) op = ODEOperator('DOP853', 1e-3) solution = op.solve(ivp) assert solution.vertex_oriented is None assert solution.d_t == 1e-3 assert solution.discrete_y().shape == (1e4, 2)
def test_fdm_operator_on_ode(): diff_eq = LorenzEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.ones(3)) ivp = InitialValueProblem(cp, (0., 10.), ic) op = FDMOperator(ForwardEulerMethod(), ThreePointCentralDifferenceMethod(), .01) solution = op.solve(ivp) assert solution.vertex_oriented assert solution.d_t == .01 assert solution.discrete_y().shape == (1000, 3)
def test_parareal_operator_with_wrong_g_time_step_size(): diff_eq = PopulationGrowthEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([100.])) ivp = InitialValueProblem(cp, (0., 10.), ic) f = FDMOperator(RK4(), ThreePointCentralDifferenceMethod(), .1) g = FDMOperator(RK4(), ThreePointCentralDifferenceMethod(), .6) p = PararealOperator(f, g, .001) with pytest.raises(ValueError): p.solve(ivp)
def test_initial_value_problem(): y_0 = 100 r = .5 diff_eq = PopulationGrowthEquation(r) cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([y_0])) ivp = InitialValueProblem( cp, (0., 2.), ic, lambda _ivp, t, x: np.array([y_0 * np.e**(r * t)])) assert ivp.has_exact_solution assert ivp.constrained_problem == cp assert ivp.t_interval == (0., 2.) assert ivp.initial_condition == ic assert np.allclose(ivp.exact_y(0.), [y_0])
def test_parareal_operator_on_ode_system(): diff_eq = LorenzEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.ones(3)) ivp = InitialValueProblem(cp, (0., 10.), ic) f = FDMOperator(RK4(), ThreePointCentralDifferenceMethod(), .01) g = FDMOperator(RK4(), ThreePointCentralDifferenceMethod(), .1) p = PararealOperator(f, g, .005) f_solution = f.solve(ivp) p_solution = p.solve(ivp) assert p_solution.vertex_oriented == f_solution.vertex_oriented assert p_solution.d_t == f_solution.d_t assert np.array_equal(p_solution.t_coordinates, f_solution.t_coordinates) assert np.allclose(p_solution.discrete_y(), f_solution.discrete_y())
def test_parareal_operator_in_serial_mode(): diff_eq = PopulationGrowthEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([100.])) ivp = InitialValueProblem(cp, (0., 10.), ic) f = FDMOperator(RK4(), ThreePointCentralDifferenceMethod(), .1) g = FDMOperator(RK4(), ThreePointCentralDifferenceMethod(), .5) p = PararealOperator(f, g, .001) f_solution = f.solve(ivp) p_solution = p.solve(ivp, parallel_enabled=False) assert p_solution.vertex_oriented == f_solution.vertex_oriented assert p_solution.d_t == f_solution.d_t assert np.array_equal(p_solution.t_coordinates, f_solution.t_coordinates) assert np.array_equal(p_solution.discrete_y(), f_solution.discrete_y())
def test_pidon_operator_in_ar_mode_on_ode(): set_random_seed(0) diff_eq = PopulationGrowthEquation() cp = ConstrainedProblem(diff_eq) t_interval = (0., 1.) ic = ContinuousInitialCondition(cp, lambda _: np.array([1.])) ivp = InitialValueProblem(cp, t_interval, ic) sampler = UniformRandomCollocationPointSampler() pidon = PIDONOperator(sampler, .25, True, auto_regression_mode=True) assert pidon.auto_regression_mode pidon.train( cp, (0., .25), training_data_args=DataArgs( y_0_functions=[ lambda _, _y_0=y_0: np.array([_y_0]) for y_0 in np.linspace(.5, 2., 10) ], n_domain_points=50, n_batches=1 ), model_args=ModelArgs( latent_output_size=1, trunk_hidden_layer_sizes=[50, 50, 50], ), optimization_args=OptimizationArgs( optimizer={ 'class_name': 'Adam', 'config': { 'learning_rate': optimizers.schedules.ExponentialDecay( 1e-2, decay_steps=25, decay_rate=.95) } }, epochs=5, verbose=False ) ) sol = pidon.solve(ivp) assert np.allclose(sol.t_coordinates, [.25, .5, .75, 1.]) assert sol.discrete_y().shape == (4, 1)
def test_fdm_operator_on_spherical_pde(): diff_eq = DiffusionEquation(3) mesh = Mesh([(1., 11.), (0., 2. * np.pi), (.1 * np.pi, .9 * np.pi)], [2., np.pi / 5., np.pi / 5], CoordinateSystem.SPHERICAL) bcs = [(NeumannBoundaryCondition(lambda x, t: np.zeros((len(x), 1)), is_static=True), NeumannBoundaryCondition(lambda x, t: np.zeros((len(x), 1)), is_static=True))] * 3 cp = ConstrainedProblem(diff_eq, mesh, bcs) ic = ContinuousInitialCondition(cp, lambda x: 1. / x[:, :1]) ivp = InitialValueProblem(cp, (0., 5.), ic) op = FDMOperator(RK4(), ThreePointCentralDifferenceMethod(), .1) solution = op.solve(ivp) assert solution.vertex_oriented assert solution.d_t == .1 assert solution.discrete_y().shape == (50, 6, 11, 5, 1) assert solution.discrete_y(False).shape == (50, 5, 10, 4, 1)
def test_solution_generate_plots_for_ode_system(): diff_eq = LorenzEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([1., 1., 1.])) ivp = InitialValueProblem(cp, (0., 10.), ic) t_coordinates = np.array([5., 10.]) discrete_y = np.arange(6).reshape((2, 3)) solution = Solution(ivp, t_coordinates, discrete_y) plots = list(solution.generate_plots()) try: assert len(plots) == 2 assert isinstance(plots[0], TimePlot) assert isinstance(plots[1], PhaseSpacePlot) finally: for plot in plots: plot.close()
def test_solution_generate_plots_for_n_body_simulation(): diff_eq = NBodyGravitationalEquation(2, [5., 5.]) cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.ones(diff_eq.y_dimension)) ivp = InitialValueProblem(cp, (0., 10.), ic) t_coordinates = np.array([5., 10.]) discrete_y = \ np.arange(2 * diff_eq.y_dimension).reshape((2, diff_eq.y_dimension)) solution = Solution(ivp, t_coordinates, discrete_y) plots = list(solution.generate_plots()) try: assert len(plots) == 1 assert isinstance(plots[0], NBodyPlot) finally: for plot in plots: plot.close()
def test_ode_operator_on_ode_with_analytic_solution(): r = .02 y_0 = 100. diff_eq = PopulationGrowthEquation(r) cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([y_0])) ivp = InitialValueProblem( cp, (0., 10.), ic, lambda _ivp, t, x: np.array([y_0 * np.e**(r * t)])) op = ODEOperator('DOP853', 1e-4) solution = op.solve(ivp) assert solution.d_t == 1e-4 assert solution.discrete_y().shape == (1e5, 1) analytic_y = np.array([ivp.exact_y(t) for t in solution.t_coordinates]) assert np.allclose(analytic_y, solution.discrete_y())
def test_pidon_operator_in_ar_mode_training_with_diff_eq_containing_t_term(): class TestDiffEq(DifferentialEquation): def __init__(self): super(TestDiffEq, self).__init__(0, 1) @property def symbolic_equation_system(self) -> SymbolicEquationSystem: return SymbolicEquationSystem([self.symbols.t]) diff_eq = TestDiffEq() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([1.])) sampler = UniformRandomCollocationPointSampler() pidon = PIDONOperator(sampler, .25, True, auto_regression_mode=True) with pytest.raises(ValueError): pidon.train( cp, (0., .25), training_data_args=DataArgs( y_0_functions=[ic.y_0], n_domain_points=50, n_batches=1 ), model_args=ModelArgs( latent_output_size=1, trunk_hidden_layer_sizes=[50, 50, 50], ), optimization_args=OptimizationArgs( optimizer={'class_name': 'Adam'}, epochs=100, verbose=False ) )