def setup_unloading_parameters():
"""
Parameters for coupled unloading/material parameter
estimation.
For info about the different parameters,
see the unloading module.
"""
params = dolfin.Parameters("Unloading_parameters")
params.add("method", "fixed_point", ["fixed_point", "raghavan"])
# Terminate if difference in reference (unloaded) volume
# is less than tol
params.add("tol", 0.05)
# Maximum number of coupled iterations
params.add("maxiter", 5)
# Apply conitinuation step
params.add("continuation", False)
# Estimate initial guess based on loaded configuration
params.add("estimate_initial_guess", True)
unload_options = dolfin.Parameters("unload_options")
unload_options.add("maxiter", 10)
unload_options.add("tol", 0.01)
unload_options.add("ub", 2.0)
unload_options.add("lb", 0.5)
unload_options.add("regen_fibers", False)
params.add(unload_options)
return params
def default_parameters():
# Include default params for ImplicitODESolvers
# FIXME: Considre adding more?
goss_solver_params = ImplicitODESolver.default_parameters()
solver_params = d.Parameters("solver_params")
for key, value in goss_solver_params.items():
solver_params.add(key, value)
params = d.Parameters("DOLFINODESystemSolver")
params.add("solver", "ImplicitEuler", goss_solvers)
params.add("num_threads", 0, 0, 100)
params.add(solver_params)
params.add("use_cuda", False)
if enable_cuda:
default_cuda_params = goss.cuda.CUDAODESystemSolver.default_parameters()
cuda_params = d.Parameters("cuda_params")
cuda_params.add("block_size", 256, 1, 1024)
cuda_params.add("nvcc_options", "")
cuda_params.add("solver", default_cuda_params["solver"], \
dict.get(default_cuda_params, "solver")._options)
cuda_params.add("float_precision", "double", ["single", "double"])
cuda_params.add("ldt", default_cuda_params["ldt"], -1., 1.e6)
params.add(cuda_params)
return params
def setupParameters(self):
# Create parameter object
self.parameters = d.Parameters("gryphon")
self.parameters.add("verbose", False)
self.parameters.add("drawplot", False)
if (self.u.split() == ()):
self.plotcomponents = []
else:
self.plotcomponents = range(len(self.u.split()))
# Parameter set "output" nested under "gryphon"
self.parameters.add(d.Parameters("output"))
self.parameters["output"].add("plot", False)
self.parameters["output"].add("path", "")
self.parameters["output"].add("imgformat", "png")
self.parameters["output"].set_range("imgformat", {"png", "jpg", "eps"})
self.parameters["output"].add("reuseoutputfolder", False)
self.parameters["output"].add("statistics", False)
try:
self.parameters.add(d.Parameters("timestepping"))
self.parameters["timestepping"].add("dt", self.dt)
if self.supportsAdaptivity:
self.parameters["timestepping"].add("adaptive", True)
self.parameters["timestepping"].add("pessimistic_factor",
self.pfactor)
self.parameters["timestepping"].add("absolute_tolerance", 1e-7)
self.parameters["timestepping"].add("relative_tolerance", 1e-6)
self.parameters["timestepping"].add("convergence_criterion",
"absolute")
self.parameters["timestepping"].add("dtmax", self.dtmax)
self.parameters["timestepping"].add("dtmin", self.dtmin)
# Set range for parameter-object
self.parameters["timestepping"].set_range(
"convergence_criterion", {"relative", "absolute"})
self.parameters["timestepping"].set_range(
"pessimistic_factor", 0.0, 1.0)
# Select default step size selector and populate choices.
self.parameters["timestepping"].add("stepsizeselector",
"gustafsson")
self.parameters["timestepping"].set_range(
"stepsizeselector", {"gustafsson", "standard"})
# Dictionary which contains the step size selectors.
# Needed since the FEniCS parameters system can not store function handles
self.stepsizeselector = {
"gustafsson": self.dtGustafsson,
"standard": self.dtStandard
}
except Exception as E:
raise (E)
def _set_fluid_default_parameters(self):
fluid = df.Parameters(Physics.FLUID.value)
fluid.add("dt", 1e-3)
fluid.add("dummy_parameter", False)
# Add default parameters from both LU and Krylov solvers
fluid.add(LUSolver.default_parameters())
fluid.add(PETScKrylovSolver.default_parameters())
# Add solver parameters
fluid.add(df.Parameters("Solver"))
fluid["Solver"].add("dummy_parameter", False)
self.add(fluid)
def _set_porous_default_parameters(self):
porous = df.Parameters(Physics.POROUS.value)
porous.add("dt", 1e-3)
porous.add("dummy_parameter", False)
# Add default parameters from both LU and Krylov solvers
porous.add(LUSolver.default_parameters())
porous.add(PETScKrylovSolver.default_parameters())
# Add solver parameters
porous.add(df.Parameters("Solver"))
porous["Solver"].add("dummy_parameter", False)
self.add(porous)
def default_parameters() -> df.Parameters:
"""
Initialize and return a set of default parameters for the splitting solver.
*Returns*
A set of parameters (:py:class:`dolfin.Parameters`)
To inspect all the default parameters, do::
info(BasicSplittingSolver.default_parameters(), True)
"""
parameters = df.Parameters("BasicSplittingSolver")
parameters.add("theta", 0.5, 0., 1.)
parameters.add("apply_stimulus_current_to_pde", False)
parameters.add("pde_solver", "bidomain")
# Add default parameters from ODE solver, but update for V space
ode_solver_parameters = BasicCardiacODESolver.default_parameters()
parameters.add(ode_solver_parameters)
pde_solver_parameters = BasicBidomainSolver.default_parameters()
pde_solver_parameters["polynomial_degree"] = 1
parameters.add(pde_solver_parameters)
pde_solver_parameters = BasicMonodomainSolver.default_parameters()
pde_solver_parameters["polynomial_degree"] = 1
parameters.add(pde_solver_parameters)
return parameters
def default_parameters() -> df.Parameters:
"""Initialize and return a set of default parameters
*Returns*
A set of parameters (:py:class:`dolfin.Parameters`)
To inspect all the default parameters, do::
info(BidomainSolver.default_parameters(), True)
"""
parameters = df.Parameters("BidomainSolver")
parameters.add("theta", 0.5)
parameters.add("polynomial_degree", 1)
# Physical parameters
parameters.add("Chi", -1.0) # Membrane to volume ratio
parameters.add("Cm", -1.0) # Membrane capacitance
# Set default solver type to be iterative
parameters.add("linear_solver_type", "iterative")
parameters.add("use_avg_u_constraint", True)
# Set default iterative solver choices (used if iterative solver is invoked)
parameters.add("algorithm", "gmres")
parameters.add("preconditioner", "petsc_amg")
return parameters
def default_parameters() -> df.Parameters:
"""Initialize and return a set of default parameters
*Returns*
A set of parameters (:py:class:`dolfin.Parameters`)
To inspect all the default parameters, do::
info(MonodomainSolver.default_parameters(), True)
"""
parameters = df.Parameters("MonodomainSolver")
parameters.add("theta", 0.5)
parameters.add("polynomial_degree", 1)
parameters.add("default_timestep", 1.0)
# Set default solver type to be iterative
parameters.add("linear_solver_type", "direct")
parameters.add("lu_type", "default")
# Set default iterative solver choices (used if iterative solver is invoked)
parameters.add("algorithm", "cg")
parameters.add("preconditioner", "petsc_amg")
parameters.add("use_custom_preconditioner", False)
parameters.add("Chi", 1.0) # Membrane to volume ratio
parameters.add("Cm", 1.0) # Membrane capacitance
parameters.add("lambda", 1.0)
return parameters
def setup_fiber_parameters():
fiber_params = dolfin.Parameters("Fibers")
fiber_params.add("fiber_space", "Quadrature_4")
fiber_params.add("include_sheets", False)
fiber_params.add("fiber_angle_epi", -60)
fiber_params.add("fiber_angle_endo", 60)
fiber_params.add("sheet_angle_epi", 0)
fiber_params.add("sheet_angle_endo", 0)
return fiber_params
def __init__(self, *args, **kwargs):
adjlinalg.Matrix.__init__(self, *args, **kwargs)
self.__x = x
self.__x_fn = x_fn
self.__eq = eq
self.__bcs = bcs
self.__linear_solver_parameters = linear_solver_parameters
self.__adjoint_solver_parameters = adjoint_solver_parameters
self.parameters = dolfin.Parameters(
**dolfin.parameters["timestepping"]["pre_assembly"])
return
def default_parameters() -> df.Parameters:
"""Initialize and return a set of default parameters."""
parameters = df.Parameters("BasicCardiacODESolver")
parameters.add("theta", 0.5)
# Use iterative solver as default.
parameters.add(df.NonlinearVariationalSolver.default_parameters())
parameters["nonlinear_variational_solver"]["newton_solver"][
"linear_solver"] = "gmres"
parameters["nonlinear_variational_solver"]["newton_solver"][
"preconditioner"] = "jacobi"
return parameters
def nest_parameters(parameters, key):
"""
Create a new Parameters object at the specified key in parameters, if one
does not already exist.
"""
if key in parameters:
if not isinstance(parameters[key], dolfin.Parameters):
raise ParameterException("Inconsistent parameter type")
else:
p = dolfin.Parameters(key)
parameters.add(p)
return
def _set_solid_default_parameters(self):
solid = df.Parameters(Physics.SOLID.value)
solid.add("dt", 1e-3)
solid.add("dummy_parameter", False)
# Add boundary condtion parameters
solid.add(df.Parameters("BoundaryConditions"))
solid["BoundaryConditions"].add("base_bc", "fixed")
solid["BoundaryConditions"].add("lv_pressure", 10.0)
solid["BoundaryConditions"].add("rv_pressure", 0.0)
solid["BoundaryConditions"].add("pericardium_spring", 0.0)
solid["BoundaryConditions"].add("base_spring", 0.0)
# Add default parameters from both LU and Krylov solvers
solid.add(NonlinearVariationalSolver.default_parameters())
solid.add(LUSolver.default_parameters())
solid.add(PETScKrylovSolver.default_parameters())
# Add solver parameters
solid.add(df.Parameters("Solver"))
solid["Solver"].add("dummy_parameter", False)
self.add(solid)
def _set_electro_default_parameters(self):
electro = df.Parameters(Physics.ELECTRO.value)
# Set default parameters
electro.add("dt", 1e-3)
electro.add("theta", 0.5)
electro.add("polynomial_degree", 1)
electro.add("use_average_u_constraint", False)
electro.add("M_i", 1.0)
electro.add("M_e", 2.0)
electro.add("I_a", 0.0)
electro.add(df.Parameters("I_s"))
electro["I_s"].add("period", 0)
electro["I_s"].add("amplitude", 0)
electro["I_s"].add("duration", 5)
electro.add("cell_model", "Tentusscher_panfilov_2006_M_cell")
electro.add("pde_model", "bidomain")
electro.add(df.Parameters("ODESolver"))
electro["ODESolver"].add("scheme", "RL1")
electro.add(df.LinearVariationalSolver.default_parameters())
self.add(electro)
def get_circ_field(mesh):
fiber_params = dolfin.Parameters("Fibers")
# fiber_params.add("fiber_space", "Quadrature_4")
fiber_params.add("fiber_space", "Lagrange_1")
fiber_params.add("include_sheets", False)
# Parameter set from Bayer et al.
fiber_params.add("fiber_angle_epi", 0)
fiber_params.add("fiber_angle_endo", 0)
fiber_params.add("sheet_angle_epi", 0)
fiber_params.add("sheet_angle_endo", 0)
f0 = generate_fibers(mesh, fiber_params)[0]
f0.rename("circumferential", "local_basis_function")
return f0
def setup_material_parameters(material_model):
"""
Choose parameters based on
Hadjicharalambous, Myrianthi, et al. "Analysis of passive
cardiac constitutive laws for parameter estimation using 3D
tagged MRI." Biomechanics and modeling in mechanobiology 14.4
(2015): 807-828.
"""
material_parameters = df.Parameters("Material_parameters")
if material_model == "guccione":
material_parameters.add("C", 0.3)
# material_parameters.add("C", 0.18)
material_parameters.add("bf", 27.75)
material_parameters.add("bt", 5.37)
material_parameters.add("bfs", 2.445)
elif material_model == "neo_hookean":
material_parameters.add("mu", 5.6)
# material_parameters.add("mu", 10.0)
else:
# material_model == "holzapfel_ogden":
material_parameters.add("a", 0.80)
# material_parameters.add("a", 4.0)
material_parameters.add("a_f", 1.4)
# material_parameters.add("a_f", 10.0)
material_parameters.add("b", 5.0)
material_parameters.add("b_f", 5.0)
return material_parameters
def default_parameters() -> df.Parameters:
"""
Initialize and return a set of default parameters for the splitting solver.
*Returns*
The set of default parameters (:py:class:`dolfin.Parameters`)
*Example of usage*::
info(SplittingSolver.default_parameters(), True)
"""
parameters = df.Parameters("SplittingSolver")
parameters.add("theta", 0.5, 0, 1)
parameters.add("apply_stimulus_current_to_pde", False)
# parameters.add("pde_solver", "bidomain", {"bidomain", "monodomain"})
parameters.add("pde_solver", "bidomain")
parameters.add("ode_solver_choice", "CardiacODESolver")
# Add default parameters from ODE solver
ode_solver_parameters = CardiacODESolver.default_parameters()
ode_solver_parameters["scheme"] = "RK4"
parameters.add(ode_solver_parameters)
# Add default parameters from ODE solver
basic_ode_solver_parameters = BasicCardiacODESolver.default_parameters(
)
parameters.add(basic_ode_solver_parameters)
pde_solver_parameters = BidomainSolver.default_parameters()
pde_solver_parameters["polynomial_degree"] = 1
parameters.add(pde_solver_parameters)
pde_solver_parameters = MonodomainSolver.default_parameters()
pde_solver_parameters["polynomial_degree"] = 1
parameters.add(pde_solver_parameters)
return parameters
def default_parameters() -> df.Parameters:
"""
Initialize and return a set of default parameters for the splitting solver.
*Returns*
The set of default parameters (:py:class:`dolfin.Parameters`)
*Example of usage*::
info(SplittingSolver.default_parameters(), True)
"""
parameters = df.Parameters("SplittingSolver")
parameters.add("theta", 0.5, 0, 1)
parameters.add("apply_stimulus_current_to_pde", False)
parameters.add("pde_solver", "bidomain", {"bidomain", "monodomain"})
# Add default parameters from ODE solver
multicell_ode_solver_parameters = MultiCellSolver.default_parameters()
parameters.add(multicell_ode_solver_parameters)
pde_solver_parameters = BidomainSolver.default_parameters()
pde_solver_parameters["polynomial_degree"] = 1
parameters.add(pde_solver_parameters)
return parameters
.. code::
mpirun -n 4 python demo_lv.py
"""
import dolfin as df
import pulse
import ldrb
# comm = ldrb.utils.mpi_comm_world()
# Here we just create a lv mesh. Here you can use yor own mesh instead.
geometry = ldrb.create_lv_mesh()
# Make fiber field
fiber_params = df.Parameters("Fibers")
fiber_params.add("fiber_space", "CG_1")
# fiber_params.add("fiber_space", "Quadrature_4")
fiber_params.add("include_sheets", False)
fiber_params.add("fiber_angle_epi", -60)
fiber_params.add("fiber_angle_endo", 60)
pulse.geometry_utils.generate_fibers(geometry.mesh, fiber_params)
# The mesh
mesh = geometry.mesh
# The facet function (function with marking for the boundaries)
# ffun = geometry.ffun
# A dictionary with keys and values for the markers
# markers = geometry.markers
def default_parameters():
parameters = df.Parameters("MultiCellSolver")
parameters.add("reload_extension_modules", False)
parameters.add("theta", 0.5)
return parameters
import dolfin as df
import numpy as np
from aeon import Timer
from finmag.field import Field
from finmag.util import helpers
import finmag.util.solver_benchmark as bench
# Define default parameters for the fembem solvers
default_parameters = df.Parameters("demag_options")
poisson = df.Parameters("poisson_solver")
poisson.add("method", "default")
poisson.add("preconditioner", "default")
laplace = df.Parameters("laplace_solver")
laplace.add("method", "default")
laplace.add("preconditioner", "default")
default_parameters.add(poisson)
default_parameters.add(laplace)
demag_timer = Timer()
class FemBemDeMagSolver(object):
"""
Base Class for FEM/BEM Demag Solvers containing shared methods. For a top
level demag solver interface see class Demag in finmag/energies/demag.
*Arguments*
m
the finmag object representing the (unit) magnetisation field.
Ms
the saturation magnetisation
#!/usr/bin/env python
import dolfin
import logging
parameters = dolfin.Parameters("Pulse_parameters")
parameters.add("log_level", dolfin.get_log_level())
def setup_general_parameters():
"""
Parameters to speed up the compiler
"""
# Parameter for the compiler
flags = ["-O3", "-ffast-math", "-march=native"]
dolfin.parameters["form_compiler"]["quadrature_degree"] = 4
dolfin.parameters["form_compiler"]["representation"] = "uflacs"
dolfin.parameters["form_compiler"]["cpp_optimize"] = True
dolfin.parameters["form_compiler"]["cpp_optimize_flags"] = " ".join(flags)
# dolfin.set_log_active(False)
dolfin.set_log_level(logging.INFO)
def setup_unloading_parameters():
"""
Parameters for coupled unloading/material parameter
estimation.
For info about the different parameters,
see the unloading module.
# Type of boundary formulation (e.g. "DN"=Dirichlet-Neumann)
BOUNDARY_FORMULATION = "NN"
# Two basic types of implementations
METHODS = ['EHC', 'TTM']
# Degree of finite element spaces:
DEGREE = 1
# Starting and ending radius of simulation
R_START = 0.2
R_END = 0.8
# Nonlinear solver parameters
NEWTON_PARAMS = dolfin.Parameters("newton_solver")
NEWTON_PARAMS.add("linear_solver", "bicgstab")
NEWTON_PARAMS.add("absolute_tolerance", 1e-5)
NEWTON_PARAMS.add("maximum_iterations", 25)
# Specify data output
SAVE_DAT = False
TEMP_TXT_DAT = True
SAVE_FRONT_POS_TXT = True
# Types of simulation
CONVERGENCE = False
STABILITY = False
# Temporal discretization scheme for EHC model (THETA = 0.5 is Crank-Nicholson, THETA=1 is fully implicit)
THETA = 0.5
def closed_loop(parameters, advanced_parameters, CL_parameters):
####################
### Gernal setup ###
####################
setup_general_parameters()
df.PETScOptions.set('ksp_type', 'preonly')
df.PETScOptions.set('pc_factor_mat_solver_package', 'mumps')
df.PETScOptions.set("mat_mumps_icntl_7", 6)
############
### MESH ###
############
patient = parameters['patient']
meshname = parameters['mesh_name']
mesh = parameters['mesh']
mesh = patient.mesh
X = df.SpatialCoordinate(mesh)
N = df.FacetNormal(mesh)
# Cycle lenght
BCL = CL_parameters['BCL']
t = CL_parameters['t']
# Time increment
dt = CL_parameters['dt']
# End-Diastolic volume
ED_vol = CL_parameters['ED_vol']
#####################################
# Parameters for Windkessel model ###
#####################################
# Aorta compliance (reduce)
Cao = CL_parameters['Cao']
# Venous compliace
Cven = CL_parameters['Cven']
# Dead volume
Vart0 = CL_parameters['Vart0']
Vven0 = CL_parameters['Vven0']
# Aortic resistance
Rao = CL_parameters['Rao']
Rven = CL_parameters['Rven']
# Peripheral resistance (increase)
Rper = CL_parameters['Rper']
V_ven = CL_parameters['V_ven']
V_art = CL_parameters['V_art']
# scale geometry to match hemodynamics parameters
mesh.coordinates()[:] *= CL_parameters['mesh_scaler']
######################
### Material model ###
######################
material_model = advanced_parameters['material_model']
####################
### Active model ###
####################
active_model = advanced_parameters['active_model']
T_ref = advanced_parameters['T_ref']
# These can be used to adjust the contractility
gamma_base = parameters['gamma']['gamma_base']
gamma_mid = parameters['gamma']['gamma_mid']
gamma_apical = parameters['gamma']['gamma_apical']
gamma_apex = parameters['gamma']['gamma_apex']
gamma_arr = np.array(gamma_base + gamma_mid + gamma_apical + gamma_apex)
# gamma_arr = np.ones(17)
##############
### OUTPUT ###
##############
dir_results = "results"
if not os.path.exists(dir_results):
os.makedirs(dir_results)
disp_file = df.XDMFFile(df.mpi_comm_world(), "{}/displacement.xdmf".format(dir_results))
pv_data = {"pressure":[], "volume":[]}
output = "/".join([dir_results, "output_{}_ed{}.h5".format(meshname, ED_vol)])
G = RegionalParameter(patient.sfun)
G.vector()[:] = gamma_arr
G_ = df.project(G.get_function(), G.get_ind_space())
f_gamma = df.XDMFFile(df.mpi_comm_world(), "{}/activation.xdmf".format(dir_results))
f_gamma.write(G_)
########################
### Setup Parameters ###
########################
params = setup_application_parameters(material_model)
params.remove("Material_parameters")
matparams = df.Parameters("Material_parameters")
for k, v in advanced_parameters['mat_params'].iteritems():
matparams.add(k,v)
params.add(matparams)
params["base_bc"] = parameters['BC_type']
params["base_spring_k"] = advanced_parameters['spring_constant']
# params["base_bc"] = "fixed"
params["active_model"] = active_model
params["T_ref"] = T_ref
params["gamma_space"] = "regional"
######################
### Initialization ###
######################
# Solver paramters
check_patient_attributes(patient)
solver_parameters, _, _ = make_solver_params(params, patient)
# Cavity volume
V0 = df.Expression("vol",vol = 0, name = "Vtarget", degree=1)
solver_parameters["volume"] = V0
# Solver
solver = LVSolver3Field(solver_parameters, use_snes=True)
df.set_log_active(True)
solver.parameters["solve"]["snes_solver"]["report"] =True
solver.parameters["solve"]["snes_solver"]['maximum_iterations'] = 50
# Surface measure
ds = df.Measure("exterior_facet", domain = solver.parameters["mesh"],
subdomain_data = solver.parameters["facet_function"])
dsendo = ds(solver.parameters["markers"]["ENDO"][0])
# Set cavity volume
V0.vol = df.assemble(solver._V_u*dsendo)
print V0.vol
# Initial solve
solver.solve()
# Save initial state
w = solver.get_state()
u, p, pinn = w.split(deepcopy=True)
U_save = df.Function(u.function_space(), name = "displacement")
U_save.assign(u)
disp_file.write(U_save)
file_format = "a" if os.path.isfile('pv_data_plot.txt') else "w"
pv_data_plot = open('pv_data_plot.txt', file_format)
pv_data_plot.write('{},'.format(float(pinn)/1000.0))
pv_data_plot.write('{}\n'.format(V0.vol))
pv_data["pressure"].append(float(pinn)/1000.0)
pv_data["volume"].append(V0.vol)
# Active contraction
from force import ca_transient
V_real = df.FunctionSpace(mesh, "R", 0)
gamma = solver.parameters["material"].get_gamma()
# times = np.linspace(0,200,200)
# target_gamma = ca_transient(times)
# plt.plot(target_gamma)
# plt.show()
# exit()g
#######################
### Inflation Phase ###
#######################
inflate = True
# Check if inflation allready exist
if os.path.isfile(output):
with df.HDF5File(df.mpi_comm_world(), output, "r") as h5file:
if h5file.has_dataset("inflation"):
h5file.read(solver.get_state(), "inflation")
print ("\nInflation phase fetched from output file.")
inflate = False
if inflate:
print ("\nInflate geometry to volume : {}\n".format(ED_vol))
initial_step = int((ED_vol - V0.vol) / 10.0) +1
control_values, prev_states = iterate("expression", solver, V0, "vol",
ED_vol, continuation=False,
initial_number_of_steps=initial_step,
log_level=10)
# Store outout
for i, wi in enumerate(prev_states):
ui, pi, pinni = wi.split(deepcopy=True)
U_save.assign(ui)
disp_file.write(U_save)
print ("V = {}".format(control_values[i]))
print ("P = {}".format(float(pinni)/1000.0))
pv_data_plot.write('{},'.format(float(pinni)/1000.0))
pv_data_plot.write('{}\n'.format(control_values[i]))
pv_data["pressure"].append(float(pinni)/1000.0)
pv_data["volume"].append(control_values[i])
with df.HDF5File(df.mpi_comm_world(), output, "w") as h5file:
h5file.write(solver.get_state(), "inflation")
# Store ED solution
w = solver.get_state()
u, p, pinn = w.split(deepcopy=True)
U_save.assign(u)
disp_file.write(U_save)
pv_data_plot.write('{},'.format(float(pinn)/1000.0))
pv_data_plot.write('{}\n'.format(ED_vol))
pv_data["pressure"].append(float(pinn)/1000.0)
pv_data["volume"].append(ED_vol)
print ("\nInflation succeded! Current pressure: {} kPa\n\n".format(float(pinn)/1000.0))
pv_data_plot.close()
#########################
### Closed loop cycle ###
#########################
while (t < BCL):
w = solver.get_state()
u, p, pinn = w.split(deepcopy=True)
p_cav = float(pinn)
V_cav = df.assemble(solver._V_u*dsendo)
if t + dt > BCL:
dt = BCL - t
t = t + dt
target_gamma = ca_transient(t)
# Update windkessel model
Part = 1.0/Cao*(V_art - Vart0);
Pven = 1.0/Cven*(V_ven - Vven0);
PLV = float(p_cav);
print ("PLV = {}".format(PLV))
print ("Part = {}".format(Part))
# Flux trough aortic valve
if(PLV <= Part):
Qao = 0.0;
else:
Qao = 1.0/Rao*(PLV - Part);
# Flux trough mitral valve
if(PLV >= Pven):
Qmv = 0.0;
else:
Qmv = 1.0/Rven*(Pven - PLV);
Qper = 1.0/Rper*(Part - Pven);
V_cav = V_cav + dt*(Qmv - Qao);
V_art = V_art + dt*(Qao - Qper);
V_ven = V_ven + dt*(Qper - Qmv);
# Update cavity volume
V0.vol = V_cav
# Iterate active contraction
if t <= 150:
target_gamma_ = target_gamma * gamma_arr
_, states = iterate("gamma", solver, target_gamma_, gamma, initial_number_of_steps = 1)
else:
solver.solve()
# Adapt time step
if len(states) == 1:
dt *= 1.7
else:
dt *= 0.5
dt = min(dt, 10)
# Store data
ui, pi, pinni = solver.get_state().split(deepcopy=True)
U_save.assign(ui)
disp_file.write(U_save)
Pcav = float(pinni)/1000.0
pv_data_plot = open('pv_data_plot.txt', 'a')
pv_data_plot.write('{},'.format(Pcav))
pv_data_plot.write('{}\n'.format(V_cav))
pv_data_plot.close()
pv_data["pressure"].append(Pcav)
pv_data["volume"].append(V_cav)
msg = ("\n\nTime:\t{}".format(t) + \
"\ndt:\t{}".format(dt) +\
"\ngamma:\t{}".format(target_gamma) +\
"\nV_cav:\t{}".format(V_cav) + \
"\nV_art:\t{}".format(V_art) + \
"\nV_ven:\t{}".format(V_ven) + \
"\nPart:\t{}".format(Part) + \
"\nPven:\t{}".format(Pven) + \
"\nPLV:\t{}".format(Pcav) + \
"\nQper:\t{}".format(Qper) + \
"\nQao:\t{}".format(Qao) + \
"\nQmv:\t{}\n\n".format(Qmv))
print ((msg))
#==============================================================================
# fig = plt.figure()
# ax = fig.gca()
# ax.plot(pv_data["volume"], pv_data["pressure"])
# ax.set_ylabel("Pressure (kPa)")
# ax.set_xlabel("Volume (ml)")
#
#
# fig.savefig("/".join([dir_results, "pv_loop.png"]))
# plt.show()
#==============================================================================
return
#import threading
#thread1 = threading.Thread(target = closed_loop)
#thread1.start()
def default_parameters() -> df.Parameters:
"""Initialize and return a set of default parameters."""
parameters = df.Parameters("CardiacODESolver")
parameters.add("scheme", "RK4")
return parameters
def default_parameters():
parameters = df.Parameters("Projecter")
parameters.add("linear_solver_type", "cg")
return parameters
