def tlm_adj_setup_initial_conditions(self, cell_model, Scheme): mesh = UnitIntervalMesh(3) Model = cell_model.__class__ # Initiate solver, with model and Scheme params = Model.default_parameters() model = Model(params=params) solver = self._setup_solver(model, Scheme, mesh) ics = project(model.initial_conditions(), solver.VS).copy(deepcopy=True, name="ics") info_green("Running forward %s with %s (setup)" % (model, Scheme)) self._run(solver, ics) # Define functional (vs_, vs) = solver.solution_fields() form = lambda w: inner(w, w)*dx J = Functional(form(vs)*dt[FINISH_TIME]) # Compute value of functional with current ics Jics = assemble(form(vs)) # Set-up runner def Jhat(ics): self._run(solver, ics) (vs_, vs) = solver.solution_fields() return assemble(form(vs)) # Stop annotating parameters["adjoint"]["stop_annotating"] = True m = Control(vs) return J, Jhat, m, Jics
def test_compute_gradient(self): "Test that we can compute the gradient for some given functional" set_dolfin_parameters() model = Model() params = BasicSingleCellSolver.default_parameters() params["theta"] = theta time = Constant(0.0) solver = BasicSingleCellSolver(model, time, params=params) # Get initial conditions (Projection of expressions # don't get annotated, which is fine, because there is # no need.) ics = project(model.initial_conditions(), solver.VS) # Run forward model info_green("Running forward %s with theta %g" % (model, theta)) self._run(solver, model, ics) # Define functional (vs_, vs) = solver.solution_fields() J = Functional(inner(vs, vs) * dx * dt[FINISH_TIME]) # Compute gradient with respect to vs_. Highly unclear # why with respect to ics and vs fail. info_green("Computing gradient") dJdics = compute_gradient(J, Control(vs_)) assert (dJdics is not None), "Gradient is None (#fail)." print(dJdics.vector().array())
def test_adjoint_cell_model_parameter(self, cell_model, Scheme): """ Test that the gradient computed with the adjoint model is correct. """ if isinstance(cell_model, fails_with_RK4) and Scheme == "RK4": pytest.xfail( "RK4 is unstable for some models with this timestep (0.01)") if isinstance(cell_model, fails_with_forward_euler) and Scheme == "ForwardEuler": pytest.xfail( "ForwardEuler is unstable for some models with this timestep (0.01)" ) J, Jhat, m, Jics = self.tlm_adj_setup_cellmodel_parameters( cell_model, Scheme) # Seed for taylor test seed = seed_collection_adm.get(cell_model.__class__) # Compute gradient with respect to vs. info_green("Computing gradient") dJdics = compute_gradient(J, m, forget=False) assert (dJdics is not None), "Gradient is None (#fail)." conv_rate = taylor_test(Jhat, m, Jics, dJdics, seed=seed) # Check that minimal rate is greater than some given number assert_greater(conv_rate, 1.9)
def test_compute_adjoint(self): "Test that we can compute the adjoint for some given functional" set_dolfin_parameters() model = Model() params = BasicSingleCellSolver.default_parameters() params["theta"] = theta time = Constant(0.0) solver = BasicSingleCellSolver(model, time, params=params) # Get initial conditions (Projection of expressions # don't get annotated, which is fine, because there is # no need.) ics = project(model.initial_conditions(), solver.VS) # Run forward model info_green("Running forward %s with theta %g" % (model, theta)) self._run(solver, model, ics) (vs_, vs) = solver.solution_fields() # Define functional and compute gradient etc J = Functional(inner(vs_, vs_) * dx * dt[FINISH_TIME]) # Compute adjoint info_green("Computing adjoint") z = compute_adjoint(J) # Check that no vs_ adjoint is None (== 0.0!) for (value, var) in z: if var.name == "vs_": msg = "Adjoint solution for vs_ is None (#fail)." assert (value is not None), msg
def test_tlm_cell_model_parameter(self, cell_model, Scheme): if Scheme == "ForwardEuler": pytest.xfail( "Forward Euler is unstable for some models with this timestep (0.01)" ) if isinstance(cell_model, fails_with_RK4) and Scheme == "RK4": pytest.xfail( "RK4 is unstable for some models with this timestep (0.01)") J, Jhat, m, Jics = self.tlm_adj_setup_cellmodel_parameters( cell_model, Scheme) # Seed for taylor test seed = seed_collection_tlm.get(cell_model.__class__) # Stop annotating parameters["adjoint"]["stop_annotating"] = True # Check TLM correctness info_green("Computing gradient") dJdics = compute_gradient_tlm(J, m, forget=False) assert (dJdics is not None), "Gradient is None (#fail)." conv_rate_tlm = taylor_test(Jhat, m, Jics, dJdics, seed=seed) assert_greater(conv_rate_tlm, 1.8)
def test_tlm_initial(self, cell_model, Scheme): "Test that we can compute the gradient for some given functional" if Scheme == "ForwardEuler": pytest.xfail( "Forward Euler is unstable for some models with this timestep (0.01)" ) if isinstance(cell_model, fails_with_RK4) and Scheme == "RK4": pytest.xfail( "RK4 is unstable for some models with this timestep (0.01)") J, Jhat, m, Jics = self.tlm_adj_setup_initial_conditions( cell_model, Scheme) # Seed for taylor test seed = seed_collection_tlm.get(cell_model.__class__) # Check TLM correctness info_green("Computing gradient") dJdics = compute_gradient_tlm(J, m, forget=False) assert (dJdics is not None), "Gradient is None (#fail)." conv_rate_tlm = taylor_test(Jhat, m, Jics, dJdics, seed=seed) assert_greater(conv_rate_tlm, 1.8) return
def test_replay(self, Solver, solver_type, tol): "Test that replay of basic bidomain solver reports success." self._setup_solver(Solver, solver_type) self._solve() # Check replay info_green("Running replay basic (%s)" % solver_type) success = replay_dolfin(stop=True, tol=tol) assert_equal(success, True)
def test_adjoint(self, Solver, solver_type): """Test that adjoint model of basic bidomain solver converges at 2nd order.""" info_green("Running adjoint basic (%s)" % solver_type) J, Jhat, m, Jics = self.tlm_adj_setup(Solver, solver_type) # Check adjoint correctness dJdics = compute_gradient(J, m, forget=False) assert (dJdics is not None), "Gradient is None (#fail)." conv_rate = taylor_test(Jhat, m, Jics, dJdics, seed=1e-3) # Check that minimal convergence rate is greater than some given number assert_greater(conv_rate, 1.9)
def test_taylor_remainder(self): "Run Taylor remainder tests for selection of models and solvers." set_dolfin_parameters() model = Model() params = BasicSingleCellSolver.default_parameters() params["theta"] = theta time = Constant(0.0) solver = BasicSingleCellSolver(model, time, params=params) # Get initial conditions (Projection of expressions # don't get annotated, which is fine, because there is # no need.) ics = project(model.initial_conditions(), solver.VS) # Run forward model info_green("Running forward %s with theta %g" % (model, theta)) self._run(solver, model, ics) # Define functional (vs_, vs) = solver.solution_fields() form = lambda w: inner(w, w)*dx J = Functional(form(vs)*dt[FINISH_TIME]) # Compute value of functional with current ics Jics = assemble(form(vs)) # Compute gradient with respect to vs_ (ics?) dJdics = compute_gradient(J, Control(vs_), forget=False) # Stop annotating parameters["adjoint"]["stop_annotating"] = True # Set-up runner def Jhat(ics): self._run(solver, model, ics) (vs_, vs) = solver.solution_fields() return assemble(form(vs)) # Run taylor test if isinstance(model, Tentusscher_2004_mcell): seed=1.e-5 else: seed=None conv_rate = taylor_test(Jhat, Control(vs_), Jics, dJdics, seed=seed) # Check that minimal rate is greater than some given number assert_greater(conv_rate, 1.8)
def test_replay(self): "Test that replay reports success for basic single cell solver" set_dolfin_parameters() model = Model() # Initialize solver params = BasicSingleCellSolver.default_parameters() params["theta"] = theta time = Constant(0.0) solver = BasicSingleCellSolver(model, time, params=params) info_green("Running %s with theta %g" % (model, theta)) ics = project(model.initial_conditions(), solver.VS).copy(deepcopy=True, name="ics") self._run(solver, model, ics) info_green("Replaying") success = replay_dolfin(tol=0.0, stop=True) assert_true(success)
def tlm_adj_setup_cellmodel_parameters(self, cell_model, Scheme): mesh = UnitIntervalMesh(3) Model = cell_model.__class__ # Initiate solver, with model and Scheme cell_params = Model.default_parameters() param_name = cellmodel_parameters_seeds[Model][0] cell_params[param_name] = Constant(cell_params[param_name], name=param_name) model = Model(params=cell_params) solver = self._setup_solver(model, Scheme, mesh) info_green("Running forward %s with %s (setup)" % (model, Scheme)) ics = Function(project(model.initial_conditions(), solver.VS), name="ics") self._run(solver, ics) # Define functional (vs_, vs) = solver.solution_fields() form = lambda w: inner(w, w) * dx J = Functional(form(vs) * dt[FINISH_TIME]) # Compute value of functional with current ics Jics = assemble(form(vs)) # Set-up runner def Jhat(val): cell_params[param_name].assign(val) ics = Function(project(model.initial_conditions(), solver.VS), name="ics") self._run(solver, ics) (vs_, vs) = solver.solution_fields() return assemble(form(vs)) # Stop annotating solver.parameters["enable_adjoint"] = False m = ConstantControl(cell_params[param_name]) return J, Jhat, m, Jics
def test_replay(self, cell_model, Scheme): mesh = UnitIntervalMesh(3) Model = cell_model.__class__ if isinstance(cell_model, fails_with_RK4) and Scheme == "RK4": pytest.xfail("RK4 is unstable for some models with this timestep (0.01)") # Initiate solver, with model and Scheme params = Model.default_parameters() model = Model(params=params) solver = self._setup_solver(model, Scheme, mesh) ics = project(model.initial_conditions(), solver.VS) info_green("Running forward %s with %s (replay)" % (model, Scheme)) self._run(solver, ics) print solver.solution_fields()[0].vector().array() info_green("Replaying") success = replay_dolfin(tol=0, stop=True) assert_true(success)