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