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 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 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))
def test_fitzhugh(): parameters["reorder_dofs_serial"] = False parameters["form_compiler"]["cpp_optimize"] = True parameters["form_compiler"]["optimize"] = True # Set-up cardiac model heart = setup_model() # Set-up solver ps = BasicSplittingSolver.default_parameters() ps["BasicBidomainSolver"]["linear_variational_solver"][ "linear_solver"] = "direct" ps["BasicBidomainSolver"]["theta"] = 1.0 ps["theta"] = 1.0 ps["BasicCardiacODESolver"]["S_polynomial_family"] = "CG" ps["BasicCardiacODESolver"]["S_polynomial_degree"] = 1 ps["BasicCardiacODESolver"]["V_polynomial_family"] = "CG" ps["BasicCardiacODESolver"]["V_polynomial_degree"] = 1 solver = BasicSplittingSolver(heart, ps) # Define end-time and (constant) timesteps dt = 0.25 # mS T = 1.0 # + 1.e-6 # mS # Define initial condition(s) ic = InitialCondition(degree=1) # Should use degree=0 here for # correctness, but to match # reference, using 1 vs0 = project(ic, solver.VS) (vs_, vs, u) = solver.solution_fields() vs_.assign(vs0) # Solve solutions = solver.solve((0, T), dt) for (timestep, (vs_, vs, vur)) in solutions: continue u = project(vur[1], vur.function_space().sub(1).collapse()) norm_u = norm(u) reference = 10.3756526773 print(("norm_u = ", norm_u)) print(("reference = ", reference)) assert_almost_equal(reference, norm_u, 1.e-4)
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)