def setup(self):
self.mesh = UnitCubeMesh(5, 5, 5)
# Create time
self.time = Constant(0.0)
# Create stimulus
self.stimulus = Expression("2.0*t", t=self.time, degree=1)
# Create ac
self.applied_current = Expression("sin(2*pi*x[0])*t",
t=self.time,
degree=3)
# Create conductivity "tensors"
self.M_i = 1.0
self.M_e = 2.0
self.cell_model = FitzHughNagumoManual()
self.cardiac_model = CardiacModel(self.mesh, self.time, self.M_i,
self.M_e, self.cell_model,
self.stimulus, self.applied_current)
dt = 0.1
self.t0 = 0.0
self.dt = [(0.0, dt), (dt * 2, dt / 2), (dt * 4, dt)]
# Test using variable dt interval but using the same dt.
self.T = self.t0 + 5 * dt
self.ics = self.cell_model.initial_conditions()
def setup_model():
"Set-up cardiac model based on a slightly non-standard set of parameters."
# Define cell parameters
k = 0.00004; Vrest = -85.; Vthreshold = -70.; Vpeak = 40.;
v_amp = Vpeak - Vrest
l = 0.63; b = 0.013;
cell_parameters = {"c_1": k*v_amp**2, "c_2": k*v_amp, "c_3": b/l,
"a": (Vthreshold - Vrest)/v_amp, "b": l,
"v_rest":Vrest, "v_peak": Vpeak}
cell = FitzHughNagumoManual(cell_parameters)
# Define conductivities
chi = 2000.0 # cm^{-1}
s_il = 3.0/chi # mS
s_it = 0.3/chi # mS
s_el = 2.0/chi # mS
s_et = 1.3/chi # mS
M_i = as_tensor(((s_il, 0), (0, s_it)))
M_e = as_tensor(((s_el, 0), (0, s_et)))
# Define mesh
domain = UnitSquareMesh(20, 20)
time = Constant(0.0)
heart = CardiacModel(domain, time, M_i, M_e, cell)
return heart
def __init__(self):
self.mesh = UnitCubeMesh(5, 5, 5)
# Create time
self.time = Constant(0.0)
# Create stimulus
self.stimulus = Expression("2.0*t", t=self.time, degree=1)
# Create ac
self.applied_current = Expression("sin(2*pi*x[0])*t",
t=self.time,
degree=3)
# Create conductivity "tensors"
self.M_i = 1.0
self.M_e = 2.0
self.cell_model = FitzHughNagumoManual()
self.cardiac_model = CardiacModel(self.mesh, self.time, self.M_i,
self.M_e, self.cell_model,
self.stimulus,
self.applied_current)
dt = 0.1
self.t0 = 0.0
if Solver == SplittingSolver:
# FIXME: Dolfin-adjoint fails with adaptive timestep and SplittingSolver
self.dt = dt
else:
self.dt = [(0.0, dt), (dt * 2, dt / 2), (dt * 4, dt)]
# Test using variable dt interval but using the same dt.
self.T = self.t0 + 5 * dt
# Create solver object
params = Solver.default_parameters()
if Solver == SplittingSolver:
params.enable_adjoint = enable_adjoint
params.BidomainSolver.linear_solver_type = solver_type
params.BidomainSolver.petsc_krylov_solver.relative_tolerance = 1e-12
else:
params.BasicBidomainSolver.linear_variational_solver.linear_solver = \
"gmres" if solver_type == "iterative" else "lu"
params.BasicBidomainSolver.linear_variational_solver.krylov_solver.relative_tolerance = 1e-12
params.BasicBidomainSolver.linear_variational_solver.preconditioner = 'ilu'
self.solver = Solver(self.cardiac_model, params=params)
(vs_, vs, vur) = self.solver.solution_fields()
if ics is None:
self.ics = self.cell_model.initial_conditions()
vs_.assign(self.ics)
else:
vs_.vector()[:] = ics.vector()
def main(N, dt, T, theta):
if dolfin_adjoint:
adj_reset()
# Create cardiac model
mesh = UnitSquareMesh(N, N)
time = Constant(0.0)
cell_model = NoCellModel()
ac_str = "cos(t)*cos(2*pi*x[0])*cos(2*pi*x[1]) + 4*pow(pi, 2)*cos(2*pi*x[0])*cos(2*pi*x[1])*sin(t)"
stimulus = Expression(ac_str, t=time, degree=3)
heart = CardiacModel(mesh, time, 1.0, 1.0, cell_model, stimulus=stimulus)
# Set-up solver
ps = BasicSplittingSolver.default_parameters()
ps["theta"] = theta
ps["BasicBidomainSolver"]["linear_variational_solver"][
"linear_solver"] = "direct"
solver = BasicSplittingSolver(heart, params=ps)
# Define exact solution (Note: v is returned at end of time
# interval(s), u is computed at somewhere in the time interval
# depending on theta)
v_exact = Expression("cos(2*pi*x[0])*cos(2*pi*x[1])*sin(t)", t=T, degree=3)
u_exact = Expression("-cos(2*pi*x[0])*cos(2*pi*x[1])*sin(t)/2.0",
t=T - (1 - theta) * dt,
degree=3)
# Define initial condition(s)
vs0 = Function(solver.VS)
(vs_, vs, vur) = solver.solution_fields()
vs_.assign(vs0)
# Solve
solutions = solver.solve((0, T), dt)
for (timestep, (vs_, vs, vur)) in solutions:
continue
# Compute errors
(v, s) = vs.split(deepcopy=True)
v_error = errornorm(v_exact, v, "L2", degree_rise=2)
(v, u, r) = vur.split(deepcopy=True)
u_error = errornorm(u_exact, u, "L2", degree_rise=2)
return (v_error, u_error, mesh.hmin(), dt, T)
def test_solver_with_domains():
mesh = UnitCubeMesh(5, 5, 5)
time = Constant(0.0)
stimulus = Expression("2.0*t", t=time, degree=1)
# Create ac
applied_current = Expression("sin(2*pi*x[0])*t", t=time, degree=3)
# Create conductivity "tensors"
M_i = 1.0
M_e = 2.0
cell_model = FitzHughNagumoManual()
cardiac_model = CardiacModel(mesh, time, M_i, M_e, cell_model,
stimulus, applied_current)
dt = 0.1
t0 = 0.0
dt = dt
T = t0 + 5*dt
ics = cell_model.initial_conditions()
# Create basic solver
params = SplittingSolver.default_parameters()
params["ode_solver_choice"] = "BasicCardiacODESolver"
solver = SplittingSolver(cardiac_model, params=params)
(vs_, vs, vur) = solver.solution_fields()
vs_.assign(ics)
# Solve
solutions = solver.solve((t0, T), dt)
for (interval, fields) in solutions:
(vs_, vs, vur) = fields
def setup(self):
self.mesh = UnitCubeMesh(2, 2, 2)
self.cell_model = FitzHughNagumoManual()
self.cardiac_model = CardiacModel(self.mesh, None,
1.0, 2.0,
self.cell_model)