def box_mesh_with_hole(point1=Point(0, 0, 0), point2=Point(2, 1, 1), cyl_cent1=Point(1, -10, 0.5), cyl_cent2=Point(1, 10, 0.5), cyl_rad=0.25, numpts=15): """ generates a 3D box mesh with tetrahedral elements with a cylindrical hole in it input ------ point1: Point coordinates in 3D corner_min of box point2: Point coordinates in 3D corner_max of box cyl_cent1: Point coordinates in 3D of center1 of Cylinder cyl_cent2: Point coordinates in 3D of center1 of Cylinder cyl_rad: Radius of cylinder npts: Number of discretization points output: ------ mesh: 3D FEniCS mesh with a cylindrical hole """ Router = mshr.Box(point1, point2) Rinner = mshr.Cylinder(cyl_cent1, cyl_cent2, cyl_rad, cyl_rad) domain = Router - Rinner mesh = mshr.generate_mesh(domain, numpts) print_mesh_stats(mesh) return mesh
def fenics_space(self, my_d): """ @description: Define the fenics solver space @param: None @Returns: Fenics Box structure @Modify: 2021/08/31 """ if "plugin3D" in self.det_model: self.sensor_range_confirm(my_d) m_sensor = mshr.Box(fenics.Point(self.sx_l, self.sy_l, 0), fenics.Point(self.sx_r, self.sy_r, self.fl_z)) for i in range(len(my_d.e_tr)): e_t_i = my_d.e_tr[i] elec_n = mshr.Cylinder( fenics.Point(e_t_i[0], e_t_i[1], e_t_i[3]), fenics.Point(e_t_i[0], e_t_i[1], e_t_i[4]), e_t_i[2], e_t_i[2]) m_sensor = m_sensor - elec_n elif "planar3D" in self.det_model: m_sensor = mshr.Box(fenics.Point(0, 0, 0), fenics.Point(self.fl_x, self.fl_y, self.fl_z)) else: print("sensor model is wrong") sys.exit() return m_sensor
def __init__(self, model_name="cylinder_demo3d"): pyurdme.URDMEModel.__init__(self, model_name) # System constants D_const = 0.1 # Define Species A = pyurdme.Species(name="A", diffusion_constant=D_const) B = pyurdme.Species(name="B", diffusion_constant=D_const) self.add_species([A, B]) # Define Geometry pt1 = dolfin.Point(MAX_X_DIM, 0, 0) pt2 = dolfin.Point(MIN_X_DIM, 0, 0) cylinder = mshr.Cylinder(pt1, pt2, 1.0, 1.0) self.mesh = pyurdme.URDMEMesh(mesh=mshr.generate_mesh(cylinder, 32)) # Define Subdomains self.add_subdomain(Edge1(), 2) self.add_subdomain(Edge2(), 3) data = self.get_solver_datastructure() vol = data['vol'] sd = data['sd'] left = numpy.sum(vol[sd == 2]) right = numpy.sum(vol[sd == 3]) k_react = pyurdme.Parameter(name="k_react", expression=1.0) k_creat1 = pyurdme.Parameter(name="k_creat1", expression=100 / right) k_creat2 = pyurdme.Parameter(name="k_creat2", expression=100 / left) self.add_parameter([k_react, k_creat1, k_creat2]) # Define Reactions R1 = pyurdme.Reaction(name="R1", reactants=None, products={A: 1}, rate=k_creat1, restrict_to=2) R2 = pyurdme.Reaction(name="R2", reactants=None, products={B: 1}, rate=k_creat2, restrict_to=3) R3 = pyurdme.Reaction(name="R3", reactants={ A: 1, B: 1 }, products=None, rate=k_react) self.add_reaction([R1, R2, R3]) # Define simulation timespan self.timespan(range(200))
def create_toy_mesh(): box = mshr.Box(dolfin.Point(-3, -1, -0.5), dolfin.Point(3, 1, 0.5)) c1 = mshr.Cylinder(dolfin.Point(0, 0, -2), dolfin.Point(0, 0, 2), 0.6, 0.6) b1 = mshr.Box(dolfin.Point(-2.5, -0.5, -2), dolfin.Point(-1.5, 0.5, 2)) # "triangle" t1 = mshr.Polygon([ dolfin.Point(2.5, -0.5, 0), dolfin.Point(2.5, 0.5, 0), dolfin.Point(1.5, -0.5, 0), ]) g3d = mshr.Extrude2D(t1, -2) g3d = mshr.CSGTranslation(g3d, dolfin.Point(0, 0, 1)) m = mshr.generate_mesh(box - c1 - b1 - g3d, 40, "cgal") return m.coordinates(), m.cells()
def create_cylindrical_columns(self): B = [] square_jump = 1/self.n_squares r = square_jump * self.square_fraction short_jump = np.array([square_jump/2, 0, 0]) long_jump = np.array([square_jump, 0, 0]) reference_point = np.array([square_jump/2, square_jump/2, 0]) y_jump = np.array([0, square_jump/2, 0]) state = 2 while(self.point_is_inside(reference_point)): p = reference_point + 0 if state % 2 != 0: p_jump = short_jump else: p_jump = long_jump if state % 4 != 0: p += p_jump state += 1 inner_state = 0 while(self.point_is_inside(p)): if np.array_equal(p_jump, short_jump): break if inner_state % 2 == 0: B.append(p+0) p += p_jump inner_state += 1 reference_point += y_jump B = np.array(B) geo = None counter = 0 n_seeds = len(B) chosen_columns = [] np.random.seed(123) while counter < self.n_columns: if counter == 0: '''Necessary for initial and boundary conditions''' rand_int = 0 else: rand_int = np.random.randint(0, n_seeds) if rand_int in chosen_columns: continue p = B[rand_int] chosen_columns.append(rand_int) counter += 1 top = p + 0 top[-1] = 1 bottom = p + 0 bottom[-1] = 0 cylinder = mesher.Cylinder(fe.Point(top), fe.Point(bottom), r, r) if geo is None: geo = cylinder else: geo += cylinder print('Finished creating', counter, 'columns') return geo
def create_base_net(self): square_jump = 1/self.n_squares r = square_jump * self.square_fraction y_square_jump = np.array([0, square_jump, 0]) x_square_jump = np.array([square_jump, 0, 0]) geo = None '''Lower left corner''' p = np.zeros(3) + 0. top = p + 2*y_square_jump bottom = p + 2*x_square_jump while (self.point_is_inside(p + 2*y_square_jump)): cylinder = mesher.Cylinder(fe.Point(top), fe.Point(bottom), r, r) if geo is None: geo = cylinder else: geo += cylinder p += 2*y_square_jump top += 2*y_square_jump bottom += 2*x_square_jump '''Upper right corner''' p = self.L * np.ones(3) p[-1] = 0. top = p - 2*y_square_jump bottom = p - 2*x_square_jump while (self.point_is_inside(p - 2*y_square_jump)): cylinder = mesher.Cylinder(fe.Point(top), fe.Point(bottom), r, r) geo += cylinder p -= 2*y_square_jump top -= 2*y_square_jump bottom -= 2*x_square_jump '''Lower Right corner''' p = np.zeros(3) p[0] = self.L top = p + 2*y_square_jump bottom = p - 2*x_square_jump while (self.point_is_inside(p + 2*y_square_jump)): cylinder = mesher.Cylinder(fe.Point(top), fe.Point(bottom), r, r) geo += cylinder p += 2*y_square_jump top += 2*y_square_jump bottom -= 2*x_square_jump '''Upper left corner''' p = np.zeros(3) p[1] = self.L top = p - 2*y_square_jump bottom = p + 2*x_square_jump while (self.point_is_inside(p - 2*y_square_jump)): cylinder = mesher.Cylinder(fe.Point(top), fe.Point(bottom), r, r) geo += cylinder p -= 2*y_square_jump top -= 2*y_square_jump bottom += 2*x_square_jump print('Finished creating base net') return geo
def fenics(sim_params, file_inputs, output_params, passive_params, hs_params, cell_ion_params, monodomain_params, windkessel_params): global i global j output_path = output_params["output_path"][0] displacementfile = File(output_path + "u_disp.pvd") filament_compliance_factor = hs_params["myofilament_parameters"][ "filament_compliance_factor"][0] # filament_compliance_factor = 0.5 no_of_states = hs_params["myofilament_parameters"]["num_states"][0] #no_of_states = 3 #no_of_attached_states = 1 #no_of_detached_states = 2 no_of_attached_states = hs_params["myofilament_parameters"][ "num_attached_states"][0] no_of_detached_states = no_of_states - no_of_attached_states no_of_transitions = hs_params["myofilament_parameters"]["num_transitions"][ 0] state_attached = hs_params["myofilament_parameters"]["state_attached"][0] cb_extensions = hs_params["myofilament_parameters"]["cb_extensions"][0] k_cb_multiplier = hs_params["myofilament_parameters"]["k_cb_multiplier"][0] k_cb_pos = hs_params["myofilament_parameters"]["k_cb_pos"][0] k_cb_neg = hs_params["myofilament_parameters"]["k_cb_neg"][0] cb_number_density = hs_params["cb_number_density"][0] alpha_value = hs_params["myofilament_parameters"]["alpha"][0] x_bin_min = hs_params["myofilament_parameters"]["bin_min"][0] x_bin_max = hs_params["myofilament_parameters"]["bin_max"][0] x_bin_increment = hs_params["myofilament_parameters"]["bin_width"][0] #no_of_transitions = 4 #state_attached = [0, 0, 1] #cb_extensions = [ 0, 0, 4.75642] #k_cb_multiplier = [ 1.0, 1.0, 1.0] #k_cb_pos = 0.001 #k_cb_neg = 0.001 #cb_number_density = 7.67e16 #alpha_value = 1.0 #x_bin_min = -12 #x_bin_max = +12 #x_bin_increment = 0.5 xx = np.arange(x_bin_min, x_bin_max + x_bin_increment, x_bin_increment) no_of_x_bins = np.shape(xx)[0] n_array_length = no_of_attached_states * no_of_x_bins + no_of_detached_states + 2 n_vector_indices = [[0, 0], [1, 1], [2, 2 + no_of_x_bins - 1]] #hsl0 = 1000 hsl0 = hs_params["initial_hs_length"][0] #time_steps = 401 #time_steps = 2 #step_size = 0.5 step_size = sim_params["sim_timestep"][0] sim_duration = sim_params["sim_duration"][0] time_steps = int(sim_duration / step_size + 1) Ca_flag = 4 constant_pCa = 6.5 fdataCa = open(output_path + "calcium_.txt", "w", 0) #prev_ca = np.load("calcium_10.npy") #prev_ca = prev_ca[:,0] #xml_struct = ut.parse('pm_test10.xml') #hs_params = xml_struct.single_circulation_simulation.half_sarcomere hs = half_sarcomere.half_sarcomere(hs_params, 1) cell_ion = cell_ion_driver.cell_ion_driver(cell_ion_params) calcium = np.zeros(time_steps) calcium[0] = cell_ion.model_class.calculate_concentrations(0, 0) parameters["form_compiler"]["quadrature_degree"] = 2 parameters["form_compiler"]["representation"] = "quadrature" # #os.system("rm *.pvd") #os.system("rm *.vtu") # defining parts of the model where the boundary condition should be applied later # where x[0] = 0 class Left(SubDomain): def inside(self, x, on_boundary): tol = 1E-14 return on_boundary and abs(x[0]) < tol # where x[0] = 10 class Right(SubDomain): def inside(self, x, on_boundary): tol = 1E-14 return on_boundary and abs(x[0] - 10.) < tol # where x[2] = 0 class FixY(SubDomain): def inside(self, x, on_boundary): tol = 1e-1 return near(x[0], 0., tol) and near(x[1], 0., tol) class FixZ(SubDomain): def inside(self, x, on_boundary): tol = 1e-1 return near(x[0], 0., tol) and near(x[2], 0., tol) class FixY_right(SubDomain): def inside(self, x, on_boundary): tol = 1e-1 return near(x[0], 10., tol) and near(x[1], 0., tol) class FixZ_right(SubDomain): def inside(self, x, on_boundary): tol = 1e-1 return near(x[0], 10., tol) and near(x[2], 0., tol) # # x = 10.0 y = 0.0 z = 0.0 cyl_top = Point(x, y, z) cyl_bottom = Point(0, 0, 0) top_radius = 1.0 bottom_radius = 1.0 segments = 20 geometry = mshr.Cylinder(cyl_top, cyl_bottom, top_radius, bottom_radius, segments) mesh = mshr.generate_mesh(geometry, 30) no_of_int_points = 4 * np.shape(mesh.cells())[0] #plot(mesh) #plt.show() VQuadelem = VectorElement("Quadrature", mesh.ufl_cell(), degree=2, quad_scheme="default") fiberFS = FunctionSpace(mesh, VQuadelem) f0 = Function(fiberFS) s0 = Function(fiberFS) n0 = Function(fiberFS) counter = 0 """for m in np.arange(np.shape(f0.vector().array())[0]/3): m = int(m) #f0.vector()[m*3] = np.random.normal(1.,.3) f0.vector()[m*3] = np.random.normal(1.,0.0) #s0.vector()[m*3] = f0.vector().array()[m*3] - 1. #sheet vector in plane with fiber vector s0.vector()[m*3] = 0.0 #f0.vector()[m*3+1] = np.random.normal(0.,.3) f0.vector()[m*3+1] = np.random.normal(0.,0.0) f0.vector()[m*3+2] = 0.0 #s0.vector()[m*3+1] = f0.vector().array()[m*3+1] s0.vector()[m*3+1] = 1.0 s0.vector()[m*3+2] = 0.0 n0.vector()[m*3] = 0.0 n0.vector()[m*3+1] = 0.0 n0.vector()[m*3+2] = 1.0 # z component would look like # f0.vector()[m*3+2] = something # s0.vector()[m*3+2] = f0.vector().array()[int(m)*3+2] #n0_holder = np.cross(f0.vector().array()[m*3:m*3+3],s0.vector().array()[m*3:m*3+3]) #n0_holder /= sqrt(np.inner(n0_holder,n0_holder)) #for n in range(3): # n0.vector()[m*3+n] = n0_holder[n] #s0_holder = np.cross(f0.vector().array()[m*3:m*3+3],n0.vector().array()[m*3:m*3+3]) #s0_holder /= sqrt(np.inner(s0_holder,s0_holder)) #for n in range(3): # s0.vector()[m*3+n] = s0_holder[n] #f0_holder = f0.vector().array()[m*3:m*3+3] #f0_holder /= sqrt(np.inner(f0_holder,f0_holder)) #for n in range(3): # f0.vector()[m*3+n] = f0_holder[n]""" f0 = Constant([1.0, 0.0, 0.0]) s0 = Constant([0.0, 1.0, 0.0]) n0 = Constant([0.0, 0.0, 1.0]) File(output_path + "sheet_normal.pvd") << project( n0, VectorFunctionSpace(mesh, "DG", 0)) File(output_path + "fiber.pvd") << project( f0, VectorFunctionSpace(mesh, "CG", 1)) File(output_path + "sheet.pvd") << project( s0, VectorFunctionSpace(mesh, "DG", 0)) facetboundaries = MeshFunction( 'size_t', mesh, mesh.topology().dim() - 1) # fcn that can be evaluated at the mesh entities of 'mesh' facetboundaries.set_all(0) #sets all values in facetboundaries to 0 left = Left() right = Right() fixy = FixY() fixyright = FixY_right() fixzright = FixZ_right() fixz = FixZ() # left.mark(facetboundaries, 1) right.mark(facetboundaries, 2) fixy.mark(facetboundaries, 3) fixz.mark(facetboundaries, 4) # ds = dolfin.ds(subdomain_data=facetboundaries) # ############################################################################### # # isincomp = True #False N = FacetNormal(mesh) #Cparam = Constant(1.0e2) #?? TF = TensorFunctionSpace(mesh, 'DG', 1) Velem = VectorElement("Lagrange", tetrahedron, 2, quad_scheme="default") Velem._quad_scheme = 'default' Qelem = FiniteElement("Lagrange", tetrahedron, 1, quad_scheme="default") Qelem._quad_scheme = 'default' Quadelem = FiniteElement("Quadrature", tetrahedron, degree=2, quad_scheme="default") Quadelem._quad_scheme = 'default' W = FunctionSpace(mesh, MixedElement([Velem, Qelem])) Quad = FunctionSpace(mesh, Quadelem) Quad_vectorized_Fspace = FunctionSpace( mesh, MixedElement(n_array_length * [Quadelem])) # assigning BCs u_D = Expression(("u_D"), u_D=0.0, degree=2) # BCs specified for subdomain by index bcleft = DirichletBC(W.sub(0), Constant((0, 0, 0)), facetboundaries, 1) # u1 = 0 on left face bcright = DirichletBC(W.sub(0), Constant((0, 0, 0)), facetboundaries, 2) bcfixy = DirichletBC(W.sub(0).sub(1), Constant((0.)), fixy, method="pointwise") bcfixz = DirichletBC(W.sub(0).sub(2), Constant((0.)), fixz, method="pointwise") bcfixyright = DirichletBC(W.sub(0).sub(1), Constant((0.)), fixyright, method="pointwise") bcfixzright = DirichletBC(W.sub(0).sub(2), Constant((0.)), fixzright, method="pointwise") bcs = [bcleft, bcright] du, dp = TrialFunctions(W) w = Function(W) dw = TrialFunction(W) (u, p) = split(w) (v, q) = TestFunctions(W) wtest = TestFunction(W) params = { "mesh": mesh, "facetboundaries": facetboundaries, "facet_normal": N, "mixedfunctionspace": W, "mixedfunction": w, "displacement_variable": u, "pressure_variable": p, "fiber": f0, "sheet": s0, "sheet-normal": n0, #"C_param": Cparam, "incompressible": isincomp, "Kappa": Constant(1e5) } params.update(passive_params) uflforms = Forms(params) Fmat = uflforms.Fmat() Cmat = (Fmat.T * Fmat) Emat = uflforms.Emat() J = uflforms.J() n = J * inv(Fmat.T) * N dx = dolfin.dx(mesh, metadata={"integration_order": 2}) #Ematrix = project(Emat, TF) Wp = uflforms.PassiveMatSEF() #Active force calculation------------------------------------------------------ y_vec = Function(Quad_vectorized_Fspace) hsl = sqrt(dot(f0, Cmat * f0)) * hsl0 hsl_old = Function(Quad) #hsl_old = hsl delta_hsl = hsl - hsl_old #delta_hsl = 0.0 #f_holder = Constant(0.0) cb_force = Constant(0.0) y_vec_split = split(y_vec) for jj in range(no_of_states): f_holder = Constant(0.0) temp_holder = Constant(0.0) if state_attached[jj] == 1: cb_ext = cb_extensions[jj] for kk in range(no_of_x_bins): dxx = xx[kk] + delta_hsl * filament_compliance_factor n_pop = y_vec_split[n_vector_indices[jj][0] + kk] temp_holder = n_pop * k_cb_multiplier[jj] * ( dxx + cb_ext) * conditional(gt(dxx + cb_ext, 0.0), k_cb_pos, k_cb_neg) #temp_holder = temp_holder*conditional(gt(abs(dxx),x_bin_max),0.0,1.0) #f_holder = f_holder + conditional(gt(temp_holder,0.0),temp_holder,0.0) f_holder = f_holder + temp_holder f_holder = f_holder * cb_number_density * 1e-9 f_holder = f_holder * alpha_value cb_force = cb_force + f_holder Pactive = cb_force * as_tensor(f0[i] * f0[j], (i, j)) Press = Expression(("P"), P=0.0, degree=0) # Automatic differentiation ##################################################################################################### F1 = derivative(Wp, w, wtest) * dx F2 = inner(Fmat * Pactive, grad(v)) * dx F3 = inner(Press * N, v) * ds(2, domain=mesh) Ftotal = F1 + F2 - F3 Jac1 = derivative(F1, w, dw) Jac2 = derivative(F2, w, dw) Jac3 = derivative(F3, w, dw) Jac = Jac1 + Jac2 - Jac3 ################################################################################################################################## # Contraction phase '''header_file = open("./C++/hs.h","r") code = header_file.read() header_file.close() ext_module = compile_extension_module(code=code, source_directory="C++", sources=["hs.cpp", "mf.cpp", "Ca.cpp", "base_parameters.cpp"], additional_system_headers=["petscvec.h"], include_dirs=[".", os.path.abspath("C++"),"/usr/include", "./C++"], library_dirs = ['/usr/lib/x86_64-linux-gnu'], libraries = ['libgsl.a']) Myosim = ext_module.hs() _FE_params = {"step_size": step_size}; Myosim.FE_params.update(_FE_params) _Ca_params = {"Ca_flag": Ca_flag}; Myosim.Ca_params.update(_Ca_params) _Ca_params = {"constant_pCa": constant_pCa}; Myosim.Ca_params.update(_Ca_params)''' darray = [] tarray = [] hslarray = [] calarray = [] strarray = [] pstrarray = [] overlaparray = np.zeros((time_steps + 1, no_of_int_points)) y_vec_array = y_vec.vector().get_local()[:] hsl_array = project(hsl, Quad).vector().get_local()[:] #hsl_array = np.ones(no_of_int_points)*hsl0 delta_hsl_array = np.zeros(no_of_int_points) for counter in range(0, n_array_length * no_of_int_points, n_array_length): #y_vec_array[counter] = 1 # Starting all in on state for Debugging y_vec_array[counter] = 1 y_vec_array[counter - 2] = 1 Pg, Pff, alpha = uflforms.stress() temp_DG = project(Pff, FunctionSpace(mesh, "DG", 1), form_compiler_parameters={"representation": "uflacs"}) p_f = interpolate(temp_DG, Quad) p_f_array = p_f.vector().get_local()[:] temp_DG_1 = project(alpha, FunctionSpace(mesh, "DG", 1), form_compiler_parameters={"representation": "uflacs"}) alphas = interpolate(temp_DG_1, Quad) alpha_array = alphas.vector().get_local()[:] '''P,S,T = uflforms.stress() Pff = inner(f0,P*f0) p_f = project(Pff, Quad) p_f_array = p_f.vector().get_local()[:]''' #p_f = np.load("/home/fenics/shared/python_dev/test_10/passive_forces.npy") cb_f_array = project(cb_force, Quad).vector().get_local()[:] dumped_populations = np.zeros( (time_steps, no_of_int_points, n_array_length)) y_interp = np.zeros(no_of_int_points * n_array_length) # Need to create a list of dictionaries for parameters for each gauss point hs_params_list = [{}] * no_of_int_points temp_overlap = np.zeros((no_of_int_points)) y_vec_array_new = np.zeros(((no_of_int_points) * n_array_length)) for jj in np.arange(np.shape(hs_params_list)[0]): hs_params_list[jj] = copy.deepcopy(hs_params) t = 0.0 #delta_hsls = np.zeros((time_steps,24)) for l in range(time_steps): tarray.append(t) for m in range(no_of_int_points): for k in range(n_array_length): dumped_populations[l, m, k] = y_interp[m * n_array_length + k] #hslarray.append(hsl_array[0]) #strarray.append(cb_f_array[0]) #pstrarray.append(p_f_array[0]) # _Ca_params = {"time_point": l}; # Myosim.Ca_params.update(_Ca_params) #print p_f[l] #for k in range(no_of_int_points): # pop_holder = implement.update_simulation(hs, step_size, delta_hsl_array[k], hsl_array[k], y_vec_array[k*n_array_length:(k+1)*n_array_length],p_f_array[k], cb_f_array[k], prev_ca[l]) # y_vec_array_new = Myosim.apply_time_step(y_vec_array, delta_hsl_array, hsl_array, p_f_array, cb_f_array) #y_vec_array_new[k*n_array_length:(k+1)*n_array_length] = pop_holder # Right now, not general. The calcium depends on cycle number, just saying 0 cycle = 0 calcium[l] = cell_ion.model_class.calculate_concentrations(cycle, t) #calcium[l] = cell_ion.model.calculate_concentrations(0,t) # Looping through integration points within Python Myosim, not here # Debugging, checking if y_input matches y_output between steps #print y_vec_array[0:53] # Quick hack if l == 0: overlap_counter = 1 else: overlap_counter = l for mm in np.arange(no_of_int_points): #print hsl_array[mm] temp_overlap[mm], y_interp[mm * n_array_length:( mm + 1) * n_array_length], y_vec_array_new[mm * n_array_length:( mm + 1) * n_array_length] = implement.update_simulation( hs, step_size, delta_hsl_array[mm], hsl_array[mm], y_vec_array[mm * n_array_length:(mm + 1) * n_array_length], p_f_array[mm], cb_f_array[mm], calcium[l], n_array_length, t, overlaparray[overlap_counter, mm], hs_params_list[mm]) #temp_overlap, y_interp, y_vec_array_new = implement.update_simulation(hs, step_size, delta_hsl_array, hsl_array, y_vec_array, p_f_array, cb_f_array, calcium[l], n_array_length, t,overlaparray[overlap_counter,:]) #print y_vec_array_new[0:53] y_vec_array = y_vec_array_new # for Myosim y_vec.vector()[:] = y_vec_array # for PDE # print y_vec_array[0:53] hsl_array_old = hsl_array solve(Ftotal == 0, w, bcs, J=Jac, form_compiler_parameters={"representation": "uflacs"}, solver_parameters={ "newton_solver": { "relative_tolerance": 1e-8 }, "newton_solver": { "maximum_iterations": 50 }, "newton_solver": { "absolute_tolerance": 1e-8 } }) np.save(output_path + "dumped_populations", dumped_populations) np.save(output_path + "tarray", tarray) np.save(output_path + "stress_array", strarray) np.save(output_path + "hsl", hslarray) np.save(output_path + "overlap", overlaparray) np.save(output_path + "pstress_array", pstrarray) #np.save(output_path + "alpha_array",alphaarray) np.save(output_path + "calcium", calarray) displacementfile << w.sub(0) hsl_old.vector()[:] = project(hsl, Quad).vector().get_local()[:] # for PDE hsl_array = project(hsl, Quad).vector().get_local()[:] # for Myosim delta_hsl_array = project( sqrt(dot(f0, Cmat * f0)) * hsl0, Quad).vector().get_local()[:] - hsl_array_old # for Myosim #delta_hsls[l] = delta_hsl_array temp_DG = project( Pff, FunctionSpace(mesh, "DG", 1), form_compiler_parameters={"representation": "uflacs"}) p_f = interpolate(temp_DG, Quad) p_f_array = p_f.vector().get_local()[:] cb_f_array = project(cb_force, Quad).vector().get_local()[:] strarray.append(cb_f_array[0]) pstrarray.append(p_f_array[0]) hslarray.append(hsl_array[0] + delta_hsl_array[0]) overlaparray[l, :] = temp_overlap #print(cb_f_array) """if t <= 100: # stretch to 1300 u_D.u_D += .003 if t < 500 and t > 100: u_D.u_D =u_D.u_D if t < 600 and t >= 500: u_D.u_D += .0005 if t < 800 and t >=600: u_D.u_D = u_D.u_D if t < 900 and t >= 800: u_D.u_D -= .0005 if t >= 900: u_D.u_D = u_D.u_D""" """if t < 170 and t > 150: u_D.u_D -= 0.005 else: u_D.u_D = u_D.u_D""" u_D.u_D = u_D.u_D t = t + step_size calarray.append(hs.Ca_conc * np.ones(no_of_int_points)) """for m in range(no_of_int_points): for k in range(n_array_length): dumped_populations[l, m, k] = y_vec_array[m * n_array_length + k]""" rate_constants = np.zeros((no_of_x_bins, no_of_transitions + 1)) #for l in range(no_of_x_bins): # for m in range(no_of_transitions + 1): # rate_constants[l,m] = Myosim.dump_rate_constants(l, m, 0) fluxes, rates = implement.return_rates_fenics(hs) #np.save("/home/fenics/shared/python_dev/test_10_pm/rates",rates) #np.save("/home/fenics/shared/python_dev/test_10_pm/dumped_populations",dumped_populations) #np.save("/home/fenics/shared/python_dev/test_10_pm/tarray",tarray) #np.save("/home/fenics/shared/python_dev/test_10_pm/stress_array",strarray) #np.save("/home/fenics/shared/python_dev/test_10_pm/pstress_array",p_f) #np.save("/home/fenics/shared/python_dev/test_10_pm/calcium",calarray) #np.save("/home/fenics/shared/test_10/displacements",darray) #np.save("/home/fenics/shared/python_dev/test_10_pm/HSL",hslarray) #np.save("/home/fenics/shared/test_10/DHSL",delta_hsls) outputs = { "rates": rates, "dumped_populations": dumped_populations, "tarray": tarray, "strarray": strarray, "pstrarray": pstrarray, "alphaarray": darray, "calarray": calarray, "hsl": hslarray, "overlap": overlaparray } np.save(output_path + "dumped_populations", dumped_populations) np.save(output_path + "tarray", tarray) np.save(output_path + "stress_array", strarray) np.save(output_path + "hsl", hslarray) np.save(output_path + "overlap", overlaparray) np.save(output_path + "pstress_array", pstrarray) #np.save(output_path + "alpha_array",alphaarray) np.save(output_path + "calcium", calarray) fdataCa.close() return (outputs)
Tetrahedral meshes generation with package mshr and dolfin. You can then visualize the file with: > vtkplotter shuttle.xml """ import mshr import dolfin from vtkplotter.dolfin import datadir, plot fname = "shuttle.stl" surface = mshr.Surface3D(datadir + fname) # add a cylinder cyl = mshr.Cylinder(dolfin.Point(-1.4, 0, 0), dolfin.Point(-1.0, 0, 0), 0.5, 0.7) totdomain = surface + cyl polyhedral_domain = mshr.CSGCGALDomain3D(totdomain) dolfin.info(polyhedral_domain, True) generator = mshr.CSGCGALMeshGenerator3D() #### Try automatic generator.parameters["mesh_resolution"] = 35.0 mesh = generator.generate(polyhedral_domain) xmlname = fname.split(".")[0] + ".xml" dolfin.File(xmlname) << mesh print(mesh, "saved to " + xmlname)
def import_mesh(sim_geometry, options): # create a dictionary to pass info for fcn assignments later lv_options = {} if sim_geometry == "box_mesh": print "Creating Box Mesh" # setting default values box_mesh_specs = {} box_mesh_specs["base_corner_x"] = [0.0] box_mesh_specs["base_corner_y"] = [0.0] box_mesh_specs["base_corner_z"] = [0.0] box_mesh_specs["end_x"] = [10.0] box_mesh_specs["end_y"] = [1.0] box_mesh_specs["end_z"] = [1.0] box_mesh_specs["refinement_x"] = [10.0] box_mesh_specs["refinement_y"] = [5.0] box_mesh_specs["refinement_z"] = [5.0] box_mesh_specs.update(options) base_corner = Point(box_mesh_specs["base_corner_x"][0], box_mesh_specs["base_corner_y"][0], box_mesh_specs["base_corner_z"][0]) end_corner = Point(box_mesh_specs["end_x"][0], box_mesh_specs["end_y"][0], box_mesh_specs["end_z"][0]) mesh = BoxMesh(base_corner, end_corner, box_mesh_specs["refinement_x"][0], box_mesh_specs["refinement_y"][0], box_mesh_specs["refinement_z"][0]) if sim_geometry == "gmesh_cylinder": path_to_mesh = options["mesh_path"][0] #mesh = Mesh(path_to_mesh) mesh = Mesh() f = XDMFFile(mpi_comm_world(), path_to_mesh) f.read(mesh) f.close() if sim_geometry == "cylinder": # initialize dictionary cylinder_specs = {} # default values #---------------- # Center point for end of cylinder cylinder_specs["end_x"] = [10.0] cylinder_specs["end_y"] = [0.0] cylinder_specs["end_z"] = [0.0] # Center point for base of cylinder cylinder_specs["base_x"] = [0.0] cylinder_specs["base_y"] = [0.0] cylinder_specs["base_z"] = [0.0] # Base radius cylinder_specs["base_radius"] = [1.0] cylinder_specs["end_radius"] = [1.0] # Segments for approximating round shape cylinder_specs["segments"] = [20] # Refinement of mesh cylinder_specs["refinement"] = [30] # If user provides any alternate values, update # the cylinder_specs dictionary now cylinder_specs.update(options) cyl_bottom_center = Point(cylinder_specs["base_x"][0], cylinder_specs["base_y"][0], cylinder_specs["base_z"][0]) cyl_top_center = Point(cylinder_specs["end_x"][0], cylinder_specs["end_y"][0], cylinder_specs["end_z"][0]) # Create cylinder geometry cylinder_geometry = mshr.Cylinder(cyl_top_center, cyl_bottom_center, cylinder_specs["end_radius"][0], cylinder_specs["base_radius"][0], cylinder_specs["segments"][0]) # Create mesh print "Creating cylinder mesh" mesh = mshr.generate_mesh(cylinder_geometry, cylinder_specs["refinement"][0]) if sim_geometry == "unit_cube": # Use built in function mesh = UnitCubeMesh(1, 1, 1) if sim_geometry == "ventricle" or sim_geometry == "ellipsoid": if sim_geometry == "ellipsoid": casename = "ellipsoid_scaled" else: casename = "New_mesh" #New_mesh is the default casename in scripts sent from Dr. Lee mesh_path = options["mesh_path"][0] lv_options["casename"] = casename lv_options["mesh_path"] = mesh_path # check to see if it exists if not os.path.exists(mesh_path): print "mesh file not found" exit() if "hdf5" in mesh_path: print "Importing hdf5 mesh" mesh = Mesh() f = HDF5File(mpi_comm_world(), mesh_path, 'r') if "grown_mesh" in options.keys(): casename = "grown_mesh" if options["scaled"][0] == "True": print "using scaled version of mesh" casename = "scaled_mesh" f.read(mesh, casename, False) # had to read casename for scaled mesh. Now switch casename back to original # to access all other functions for ellipsoid sim print "SIM_GEOMETRY", sim_geometry if sim_geometry == "ellipsoid": print "CHANGING CASENAME" lv_options["casename"] = "ellipsoidal" #f.close() #ugrid = vtk_py.convertXMLMeshToUGrid(mesh) #ugrid = vtk_py.rotateUGrid(ugrid, sx=0.1, sy=0.1, sz=0.1) #mesh = vtk_py.convertUGridToXMLMesh(ugrid) #f = HDF5File(mpi_comm_world(), mesh_path, 'a') #f.write(mesh,"ellipsoid_scaled") #f.close() lv_options["f"] = f #hdf5_file = HDF5File(mpi_comm_world(),'scaled_mesh.hdf5',"w") #hdf5_file.write(mesh,"Mesh") return mesh, lv_options
from __future__ import print_function import mshr import dolfin TOLERANCE = 1e-10 # This geometry generates a lot of degenerate facets cone = mshr.Cylinder(dolfin.Point(-1.0, 1.0, 1.0), dolfin.Point(1.0, -1.0, -1.0), .5, .5) cyl = mshr.Cone(dolfin.Point(1.0, -1.0, 1.0), dolfin.Point(-1.0, 1.0, -1.0), .5) geometry = cone + cyl; polyhedral_domain = mshr.CSGCGALDomain3D(geometry) print("Degenerate facets after boolean operation: {0}".format(polyhedral_domain.num_degenerate_facets(TOLERANCE))) polyhedral_domain.remove_degenerate_facets(TOLERANCE) dolfin.info(polyhedral_domain, True)
import dolfin import mshr x = 10.0 y = 0.0 z = 0.0 cyl_top = dolfin.Point(x,y,z) cyl_bottom = dolfin.Point(0,0,0) top_radius = 1.0 bottom_radius = 1.0 segments = 20.0 geometry = mshr.Cylinder(cyl_top,cyl_bottom,top_radius,bottom_radius,segments) mesh = mshr.generate_mesh(geometry,20) File('cylinder_3.pvd') << mesh
def fenics(sim_params,file_inputs,output_params,passive_params,hs_params,cell_ion_params,monodomain_params,windkessel_params,pso): # marking these as indices because this is a function called from fenics_driver i,j = indices(2) #------------------## Load in all information and set up simulation -------- output_path = output_params["output_path"][0] displacementfile = File(output_path + "u_disp.pvd") save_output = sim_params["save_output"][0] filament_compliance_factor = hs_params["myofilament_parameters"]["filament_compliance_factor"][0] no_of_states = hs_params["myofilament_parameters"]["num_states"][0] no_of_attached_states = hs_params["myofilament_parameters"]["num_attached_states"][0] no_of_detached_states = no_of_states-no_of_attached_states no_of_transitions = hs_params["myofilament_parameters"]["num_transitions"][0] state_attached = hs_params["myofilament_parameters"]["state_attached"][0] cb_extensions = hs_params["myofilament_parameters"]["cb_extensions"][0] k_cb_multiplier = hs_params["myofilament_parameters"]["k_cb_multiplier"][0] k_cb_pos = hs_params["myofilament_parameters"]["k_cb_pos"][0] k_cb_neg = hs_params["myofilament_parameters"]["k_cb_neg"][0] cb_number_density = hs_params["cb_number_density"][0] alpha_value = hs_params["myofilament_parameters"]["alpha"][0] x_bin_min = hs_params["myofilament_parameters"]["bin_min"][0] x_bin_max = hs_params["myofilament_parameters"]["bin_max"][0] x_bin_increment = hs_params["myofilament_parameters"]["bin_width"][0] work_loop = sim_params["work_loop"][0] ## --------- Set up information for active force calculation ------------------ # Create x interval for cross-bridges xx = np.arange(x_bin_min, x_bin_max + x_bin_increment, x_bin_increment) # Define number of intervals cross-bridges are defined over no_of_x_bins = np.shape(xx)[0] # Define the length of the populations vector n_array_length = no_of_attached_states * no_of_x_bins + no_of_detached_states + 2 print "n array length = " + str(n_array_length) n_vector_indices = [[0,0], [1,1], [2,2+no_of_x_bins-1]] hsl0 = hs_params["initial_hs_length"][0] step_size = sim_params["sim_timestep"][0] sim_duration = sim_params["sim_duration"][0] time_steps = int(sim_duration/step_size +1) Ca_flag = 4 constant_pCa = 6.5 fdataCa = open(output_path + "calcium_.txt", "w", 0) pk1file = File(output_path + "pk1_act_on_f0.pvd") hsl_file = File(output_path + "hsl_mesh.pvd") # holder for reaction force at right end fx_rxn = np.zeros((time_steps)) shorten_flag = 0 # switches to one if shortening begins # Define the cylinder x = 10.0 y = 0.0 z = 0.0 cyl_top = Point(x,y,z) cyl_bottom = Point(0,0,0) top_radius = 1.0 bottom_radius = 1.0 segments = 4 geometry = mshr.Cylinder(cyl_top,cyl_bottom,top_radius,bottom_radius,segments) # Create the mesh mesh = mshr.generate_mesh(geometry,20) # Save the mesh File('cylinder_3.pvd') << mesh no_of_int_points = 4 * np.shape(mesh.cells())[0] # General quadrature element whose points we will evaluate myosim at Quadelem = FiniteElement("Quadrature", tetrahedron, degree=2, quad_scheme="default") Quadelem._quad_scheme = 'default' # Vector element at gauss points (for fibers) VQuadelem = VectorElement("Quadrature", mesh.ufl_cell(), degree=2, quad_scheme="default") VQuadelem._quad_scheme = 'default' # Real element for rigid body motion boundary condition Relem = FiniteElement("Real", mesh.ufl_cell(), 0, quad_scheme="default") Relem._quad_scheme = 'default' # Quadrature space for information needed at gauss points, such as # hsl, cb_force, passive forces, etc. Quad = FunctionSpace(mesh, Quadelem) # Initialize the half-sarcomere class. Its methods will be used to solve for cell populations hs = half_sarcomere.half_sarcomere(hs_params,1) # Need to create a list of dictionaries for parameters for each gauss point hs_params_list = [{}]*no_of_int_points passive_params_list = [{}]*no_of_int_points # Initialize ion class (get calcium transient from here) cell_ion = cell_ion_driver.cell_ion_driver(cell_ion_params) calcium = np.zeros(time_steps) calcium[0] = cell_ion.calculate_concentrations(0,0) for jj in np.arange(np.shape(hs_params_list)[0]): hs_params_list[jj] = copy.deepcopy(hs_params) passive_params_list[jj] = copy.deepcopy(passive_params) # Create a simple expression to test if x_coord is > 9.0 # making last 10% of cylinder spring elements tester = Expression("x[0]",degree=1) digitation = Expression("pow(x[1],2) + pow(x[2],2) + 0.5",degree=1) point_radius = Expression("sqrt(pow(x[1],2)+pow(x[2],2))",degree=1) # Project the expression onto the mesh temp_tester_values = project(tester,FunctionSpace(mesh,"DG",1),form_compiler_parameters={"representation":"uflacs"}) dig_values = project(digitation,FunctionSpace(mesh,"DG",1),form_compiler_parameters={"representation":"uflacs"}) point_rad_values = project(point_radius,FunctionSpace(mesh,"DG",1),form_compiler_parameters={"representation":"uflacs"}) # Interpolate onto the FunctionSpace for quadrature points temp_tester = interpolate(temp_tester_values,Quad) dig = interpolate(dig_values,Quad) point_rad = interpolate(point_rad_values,Quad) # Create array of the expression values temp_tester_array = temp_tester.vector().get_local() dig_array = dig.vector().get_local() point_rad_array = point_rad.vector().get_local() parameters["form_compiler"]["quadrature_degree"]=2 parameters["form_compiler"]["representation"] = "quadrature" # defining parts of the model where the boundary condition should be applied later # where x[0] = 0 class Left(SubDomain): def inside(self, x, on_boundary): tol = 1E-14 return on_boundary and abs(x[0]) < tol # where x[0] = 10 class Right(SubDomain): def inside(self, x, on_boundary): tol = 1E-14 return on_boundary and abs(x[0]-10.0) < tol class Fix_y(SubDomain): def inside(self, x, on_boundary): tol = 1E-1 return near(x[0],0.0,tol) and near(x[1],0.0,tol) class Fix_y_right(SubDomain): def inside(self, x, on_boundary): tol = 1E-14 return near(x[0],10.0,tol) and near(x[1],0.0,tol) class Fix_z_right(SubDomain): def inside(self, x, on_boundary): tol = 1E-14 return near(x[0],10.0,tol) and near(x[2],0.0,tol) class Fix_z(SubDomain): def inside(self, x, on_boundary): tol = 1E-14 return (near(x[0],0.0,tol) and near(x[2],0.0,tol)) # now test_marker_fcn has value of 1 on right boundary always # Define spatial coordinate system used in rigid motion constraint X = SpatialCoordinate (mesh) facetboundaries = MeshFunction('size_t', mesh, mesh.topology().dim()-1) edgeboundaries = MeshFunction('size_t', mesh, mesh.topology().dim()-2) facetboundaries.set_all(0) left = Left() right = Right() fix_y = Fix_y() fix_y_right = Fix_y_right() fix_z = Fix_z() fix_z_right = Fix_z_right() #horizontal = Horizontal() #lower = Lower() #front = Front() # left.mark(facetboundaries, 1) right.mark(facetboundaries, 2) fix_y.mark(facetboundaries, 3) #horizontal.mark(facetboundaries,4) fix_z.mark(facetboundaries,5) marker_space = FunctionSpace(mesh,'CG',1) bc_right_test = DirichletBC(marker_space,Constant(1),facetboundaries,2) test_marker_fcn = Function(marker_space) bc_right_test.apply(test_marker_fcn.vector()) File(output_path + "facetboundaries.pvd") << facetboundaries #lower.mark(facetboundaries, 4) #front.mark(facetboundaries, 5) # ds = dolfin.ds(subdomain_data = facetboundaries) # ############################################################################### isincomp = True#False N = FacetNormal (mesh) #Cparam = Constant(1.0e2) TF = TensorFunctionSpace(mesh, 'DG', 1) Velem = VectorElement("Lagrange", tetrahedron, 2, quad_scheme="default") Velem._quad_scheme = 'default' Qelem = FiniteElement("Lagrange", tetrahedron, 1, quad_scheme="default") Qelem._quad_scheme = 'default' # Mixed element for rigid body motion. One each for x, y displacement. One each for # x, y, z rotation VRelem = MixedElement([Relem, Relem, Relem, Relem, Relem]) W = FunctionSpace(mesh, MixedElement([Velem,Qelem,VRelem])) x_dofs = W.sub(0).sub(0).dofmap().dofs() Quad_vectorized_Fspace = FunctionSpace(mesh, MixedElement(n_array_length*[Quadelem])) # Kurtis trying to initialize vectors fiberFS = FunctionSpace(mesh, VQuadelem) f0 = Function(fiberFS) s0 = Function(fiberFS) n0 = Function(fiberFS) f0_diff = Function(fiberFS) c_param = Function(Quad) c2_param = Function(Quad) c3_param = Function(Quad) File(output_path + "fiber1.pvd") << project(f0, VectorFunctionSpace(mesh, "DG", 0)) m_x = 1.0 m_y = 0.0 m_z = 0.0 width = sim_params["width"][0] #x_comps = r.normal(m_x,width,no_of_int_points) #y_comps = r.normal(m_y,width,no_of_int_points) #z_comps = r.normal(m_z,width,no_of_int_points) for jj in np.arange(no_of_int_points): #if (temp_tester_array[jj] < dig_array[jj]) or (temp_tester_array[jj] > -dig_array[jj] + 10.0): if (temp_tester_array[jj] > 9.0) or (temp_tester_array[jj] < 1.0): # inside left end f0.vector()[jj*3] = 1.0 f0.vector()[jj*3+1] = 0.0 f0.vector()[jj*3+2] = 0.0 hs_params_list[jj]["myofilament_parameters"]["k_3"][0] = 0.0 #passive_params_list[jj]["c"][0] = 2000 c_param.vector()[jj] = 400 c2_param.vector()[jj] = 250 c3_param.vector()[jj] = 10 else: # In middle region, assign fiber vector # find radius of point temp_radius = point_rad_array[jj] if np.abs(temp_radius - top_radius) < 0.01: temp_width = 0.0 else: temp_width = width*(1.0-(temp_radius*temp_radius/(top_radius*top_radius))) f0.vector()[jj*3] = r.normal(m_x,temp_width,1)[0] f0.vector()[jj*3+1] = r.normal(m_y,temp_width,1)[0] f0.vector()[jj*3+2] = r.normal(m_z,temp_width,1)[0] c_param.vector()[jj] = 1000 c2_param.vector()[jj] = 250 c3_param.vector()[jj] = 15 """f0.vector()[kk*3] = x_comps[kk] # assign y component f0.vector()[kk*3+1] = y_comps[kk] # z component would look like f0.vector()[kk*3+2] = z_comps[kk]""" f0 = f0/sqrt(inner(f0,f0)) #f0_norm = project(sqrt(inner(f0,f0)),FunctionSpace(mesh,"CG",1)) #print "norm is " + str(f0_norm.vector().array()) #stop f0_diff = f0 - Constant((1.,0.,0.)) long_axis = Function(fiberFS) for nn in np.arange(no_of_int_points): long_axis.vector()[nn*3] = 0.0 long_axis.vector()[nn*3+1] = 0.0 long_axis.vector()[nn*3+2] = 1.0 #s0 = f0 + f0_diff # sum object #n0 = cross(f0,s0) # cross object #s0 = project(Constant((0,1,0))+f0_diff,VectorFunctionSpace(mesh, "DG", 0)) s0 = cross(long_axis,f0) s0 = s0/sqrt(inner(s0,s0)) File(output_path + "sheet.pvd") << project(s0,VectorFunctionSpace(mesh, "DG", 0)) n0 = project(cross(f0,s0),VectorFunctionSpace(mesh, "DG", 0)) n0 = n0/sqrt(inner(n0,n0)) File(output_path + "sheet_normal.pvd") << project(n0,VectorFunctionSpace(mesh, "DG", 0)) File(output_path + "fiber.pvd") << project(f0, VectorFunctionSpace(mesh, "CG", 1)) #test_tensor = as_tensor(f0*f0) # assigning BCs u_D = Expression(("u_D"), u_D = 0.0, degree = 2) bcleft= DirichletBC(W.sub(0).sub(0), Constant((0.0)), facetboundaries, 1) # u1 = 0 on left face bcright= DirichletBC(W.sub(0).sub(0), u_D, facetboundaries, 2) bcfix_y = DirichletBC(W.sub(0).sub(1), Constant((0.0)), fix_y, method="pointwise") bcfix_z = DirichletBC(W.sub(0).sub(2), Constant((0.0)), fix_z, method="pointwise") # at one vertex u = v = w = 0 bcfix_y_right = DirichletBC(W.sub(0).sub(1), Constant((0.0)),fix_y_right, method="pointwise") bcfix_z_right = DirichletBC(W.sub(0).sub(2), Constant((0.0)),fix_z_right, method="pointwise") #bchorizontal = DirichletBC(W.sub(0).sub(1), Constant((0.0)), horizontal, method="pointwise") #bclower= DirichletBC(W.sub(0).sub(2), Constant((0.0)), facetboundaries, 4) # u3 = 0 on lower face #bcfront= DirichletBC(W.sub(0).sub(1), Constant((0.0)), facetboundaries, 5) # u2 = 0 on front face #bcs = [bcleft, bclower, bcfront, bcright,bcfix] bcs = [bcleft, bcright,bcfix_y,bcfix_z,bcfix_y_right,bcfix_z_right] du,dp,dc11 = TrialFunctions(W) w = Function(W) dw = TrialFunction(W) (u,p,c11) = split(w) (v,q,v11) = TestFunctions(W) wtest = TestFunction(W) params= {"mesh": mesh, "facetboundaries": facetboundaries, "facet_normal": N, "mixedfunctionspace": W, "mixedfunction": w, "displacement_variable": u, "pressure_variable": p, "fiber": f0, "sheet": s0, "sheet-normal": n0, #"C_param": Cparam, "incompressible": isincomp, "Kappa":Constant(1e5)} params.update(passive_params) params["c"] = c_param params["c2"] = c2_param params["c3"] = c3_param uflforms = Forms(params) Fmat = uflforms.Fmat() Cmat = (Fmat.T*Fmat) Emat = uflforms.Emat() J = uflforms.J() n = J*inv(Fmat.T)*N dx = dolfin.dx(mesh,metadata = {"integration_order":2}) #Ematrix = project(Emat, TF) Wp = uflforms.PassiveMatSEF() #Active force calculation------------------------------------------------------ y_vec = Function(Quad_vectorized_Fspace) hsl = sqrt(dot(f0, Cmat*f0))*hsl0 hsl_old = Function(Quad) #hsl_old = hsl delta_hsl = hsl - hsl_old #delta_hsl = 0.0 #f_holder = Constant(0.0) cb_force = Constant(0.0) y_vec_split = split(y_vec) #print "shape of yvecsplit " + str(np.shape(y_vec_split)) for jj in range(no_of_states): f_holder = Constant(0.0) temp_holder = Constant(0.0) if state_attached[jj] == 1: cb_ext = cb_extensions[jj] for kk in range(no_of_x_bins): dxx = xx[kk] + delta_hsl * filament_compliance_factor n_pop = y_vec_split[n_vector_indices[jj][0] + kk] temp_holder = n_pop * k_cb_multiplier[jj] * (dxx + cb_ext) * conditional(gt(dxx + cb_ext,0.0), k_cb_pos, k_cb_neg) #temp_holder = temp_holder*conditional(gt(abs(dxx),x_bin_max),0.0,1.0) #f_holder = f_holder + conditional(gt(temp_holder,0.0),temp_holder,0.0) f_holder = f_holder + temp_holder f_holder = f_holder * cb_number_density * 1e-9 f_holder = f_holder * alpha_value cb_force = cb_force + f_holder #print "rank" + str(f0.rank()) Pactive = cb_force * as_tensor(f0[i]*f0[j], (i,j)) Press = Expression(("P"), P=0.0, degree=0) # Automatic differentiation ##################################################################################################### F1 = derivative(Wp, w, wtest)*dx F2 = inner(Fmat*Pactive, grad(v))*dx F3 = inner(Press*N, v)*ds(2, domain=mesh) # constrain rigid body motion """L4 = inner(as_vector([c11[0], c11[1], 0.0]), u)*dx + \ inner(as_vector([0.0, 0.0, c11[2]]), cross(X, u))*dx + \ inner(as_vector([c11[3], 0.0, 0.0]), cross(X, u))*dx + \ inner(as_vector([0.0, c11[4], 0.0]), cross(X, u))*dx F4 = derivative(L4, w, wtest)""" Ftotal = F1 + F2 - F3 #+ F4 Jac1 = derivative(F1, w, dw) Jac2 = derivative(F2, w, dw) Jac3 = derivative(F3, w, dw) #Jac4 = derivative(F4, w, dw) Jac = Jac1 + Jac2 - Jac3 #+ Jac4 ################################################################################################################################## darray = [] """hslarray = np.zeros((time_steps+1,no_of_int_points)) calarray = [] strarray = np.zeros((time_steps+1,no_of_int_points)) pstrarray = np.zeros((time_steps+1,no_of_int_points)) overlaparray = np.zeros((time_steps+1,no_of_int_points))""" calcium_ds = pd.DataFrame(np.zeros(no_of_int_points),index=None) calcium_ds = calcium_ds.transpose() calcium = np.zeros(time_steps) active_stress_ds = pd.DataFrame(np.zeros(no_of_int_points),index=None) active_stress_ds = active_stress_ds.transpose() dumped_populations_ds = pd.DataFrame(np.zeros((no_of_int_points,n_array_length))) tarray_ds = pd.DataFrame(np.zeros(time_steps+1),index=None) tarray_ds = tarray_ds.transpose() tarray = np.zeros(time_steps) p_f_array_ds = pd.DataFrame(np.zeros(no_of_int_points),index=None) p_f_array_ds = p_f_array_ds.transpose() pgf_array_ds = pd.DataFrame(np.zeros(no_of_int_points),index=None) pgf_array_ds = pgf_array_ds.transpose() pgt_array_ds = pd.DataFrame(np.zeros(no_of_int_points),index=None) pgt_array_ds = pgt_array_ds.transpose() pgs_array_ds =pd.DataFrame(np.zeros(no_of_int_points),index=None) pgs_array_ds = pgs_array_ds.transpose() temp_overlap_ds = pd.DataFrame(np.zeros(no_of_int_points),index=None) temp_overlap_ds = temp_overlap_ds.transpose() alpha_array_ds = pd.DataFrame(np.zeros(no_of_int_points),index=None) alpha_array_ds = alpha_array_ds.transpose() hsl_array_ds =pd.DataFrame(np.zeros(no_of_int_points),index=None) hsl_array_ds = hsl_array_ds.transpose() delta_hsl_array_ds = pd.DataFrame(np.zeros(no_of_int_points),index=None) delta_hsl_array_ds = delta_hsl_array_ds.transpose() y_vec_array = y_vec.vector().get_local()[:] hsl_array = project(hsl, Quad).vector().get_local()[:] #hsl_array = np.ones(no_of_int_points)*hsl0 delta_hsl_array = np.zeros(no_of_int_points) for counter in range(0,n_array_length * no_of_int_points,n_array_length): y_vec_array[counter] = 1 y_vec_array[counter-2] = 1 Pg, Pff, alpha = uflforms.stress() # Magnitude of bulk passive stress in fiber direction Pg_fiber = inner(f0,Pg*f0) Pg_transverse = inner(n0,Pg*n0) Pg_shear = inner(n0,Pg*f0) temp_DG = project(Pff, FunctionSpace(mesh, "DG", 1), form_compiler_parameters={"representation":"uflacs"}) p_f = interpolate(temp_DG, Quad) p_f_array = p_f.vector().get_local()[:] temp_DG_1 = project(alpha, FunctionSpace(mesh, "DG", 1), form_compiler_parameters={"representation":"uflacs"}) alphas = interpolate(temp_DG_1, Quad) alpha_array = alphas.vector().get_local()[:] cb_f_array = project(cb_force, Quad).vector().get_local()[:] dumped_populations = np.zeros((no_of_int_points, n_array_length)) y_interp = np.zeros((no_of_int_points)*n_array_length) x_dofs = W.sub(0).sub(0).dofmap().dofs() temp_overlap = np.zeros((no_of_int_points)) y_vec_array_new = np.zeros(((no_of_int_points)*n_array_length)) j3_fluxes = np.zeros((no_of_int_points,time_steps)) j4_fluxes = np.zeros((no_of_int_points,time_steps)) #print "shapes of stuff" #print np.shape(temp_overlap) #print np.shape(y_vec_array_new) temp_astress = np.ones(no_of_int_points) t = 0.0 #delta_hsls = np.zeros((time_steps,24)) for l in range(time_steps): tarray[l]=(t) # Right now, not general. The calcium depends on cycle number, just saying 0 cycle = 0 #calcium[l] = cell_ion.model_class.calculate_concentrations(cycle,t) calcium[l] = cell_ion.calculate_concentrations(step_size,l) #calcium[l] = cell_ion.model.calculate_concentrations(0,t) # Looping through integration points within Python Myosim, not here # Quick hack if l == 0: overlap_counter = 1 else: overlap_counter = l # Because we want to be able to change contractility parameters for each # gauss point, we need to loop through the gauss points here #temp_overlap, y_interp, y_vec_array_new = implement.update_simulation(hs, step_size, delta_hsl_array, hsl_array, y_vec_array, p_f_array, cb_f_array, calcium[l], n_array_length, t,overlaparray[overlap_counter,:]) #print "hs list dict " + str(hs_params_list #print "y_vec_new " + str(y_vec_array_new) for mm in np.arange(no_of_int_points): #print hsl_array[mm] temp_overlap[mm], y_interp[mm*n_array_length:(mm+1)*n_array_length], y_vec_array_new[mm*n_array_length:(mm+1)*n_array_length] = implement.update_simulation(hs, step_size, delta_hsl_array[mm], hsl_array[mm], y_vec_array[mm*n_array_length:(mm+1)*n_array_length], p_f_array[mm], cb_f_array[mm], calcium[l], n_array_length, t,hs_params_list[mm]) temp_flux_dict, temp_rate_dict = implement.return_rates_fenics(hs) #print temp_flux_dict["J3"] j3_fluxes[mm,l] = sum(temp_flux_dict["J3"]) j4_fluxes[mm,l] = sum(temp_flux_dict["J4"]) # print y_vec_array_new[0:53] y_vec_array = y_vec_array_new # for Myosim print " num gauss points " + str(no_of_int_points) print "y_vec shape" + str(np.shape(y_vec_array)) print "y_interp shape" + str(np.shape(y_interp)) for m in range(no_of_int_points): for k in range(n_array_length): dumped_populations[m, k] = y_interp[m * n_array_length + k] #print "shapes of stuff" #print np.shape(y_vec.vector()) #print np.shape(y_vec_array) y_vec.vector()[:] = y_vec_array # for PDE # print y_vec_array[0:53] hsl_array_old = hsl_array # trying to implement a work loop if work_loop: if l>0: temp_astress = cb_f_array[:] temp_astress = temp_astress[temp_astress > 0.0] if np.shape(temp_astress)[0] == 0: temp_astress=0.0 """if l > 2: u_check = project(u,VectorFunctionSpace(mesh,"CG",2)) disp_value = u_check.vector()[test_marker_fcn.vector()==1] print "displacement after shortening on right is = " + str(disp_value[0]) u_D.u_D=disp_value[0]""" if np.average(temp_astress>=50000): Press.P=50000 bcs = [bcleft,bcfix_y,bcfix_z,bcfix_y_right,bcfix_z_right] shorten_flag = 1 else: if shorten_flag < 0: u_D.u_D = u_D.u_D Press.P=0.0 if shorten_flag > 0: u_check = project(u,VectorFunctionSpace(mesh,"CG",2)) disp_value = u_check.vector()[test_marker_fcn.vector()==1] print "displacement after shortening on right is = " + str(disp_value[0]) u_D.u_D=disp_value[0] shorten_flag = -1 bcs = [bcleft,bcright,bcfix_y,bcfix_z,bcfix_y_right,bcfix_z_right] solve(Ftotal == 0, w, bcs, J = Jac, form_compiler_parameters={"representation":"uflacs"},solver_parameters={"newton_solver":{"relative_tolerance":1e-8},"newton_solver":{"maximum_iterations":50},"newton_solver":{"absolute_tolerance":1e-8}}) """np.save(output_path +"dumped_populations", dumped_populations) np.save(output_path + "tarray", tarray) np.save(output_path + "stress_array", strarray) np.save(output_path + "hsl", hslarray) np.save(output_path + "overlap", overlaparray) np.save(output_path + "pstress_array",pstrarray) #np.save(output_path + "alpha_array",alphaarray) np.save(output_path + "calcium",calarray)""" displacementfile << w.sub(0) pk1temp = project(inner(f0,Pactive*f0),FunctionSpace(mesh,'CG',1)) pk1temp.rename("pk1temp","pk1temp") pk1file << pk1temp hsl_temp = project(hsl,FunctionSpace(mesh,'DG',1)) hsl_temp.rename("hsl_temp","hsl") #hsl_file << hsl_temp hsl_old.vector()[:] = project(hsl, Quad).vector().get_local()[:] # for PDE hsl_array = project(hsl, Quad).vector().get_local()[:] # for Myosim delta_hsl_array = project(sqrt(dot(f0, Cmat*f0))*hsl0, Quad).vector().get_local()[:] - hsl_array_old # for Myosim #delta_hsls[l] = delta_hsl_array temp_DG = project(Pff, FunctionSpace(mesh, "DG", 1), form_compiler_parameters={"representation":"uflacs"}) p_f = interpolate(temp_DG, Quad) p_f_array = p_f.vector().get_local()[:] for ii in range(np.shape(hsl_array)[0]): if p_f_array[ii] < 0.0: p_f_array[ii] = 0.0 temp_DG_2 = project(Pg_fiber, FunctionSpace(mesh, "DG", 1), form_compiler_parameters={"representation":"uflacs"}) pgf = interpolate(temp_DG_2, Quad) pgf_array = pgf.vector().get_local()[:] temp_DG_3 = project(Pg_transverse, FunctionSpace(mesh, "DG", 1), form_compiler_parameters={"representation":"uflacs"}) pgt = interpolate(temp_DG_3, Quad) pgt_array = pgt.vector().get_local()[:] temp_DG_4 = project(Pg_shear, FunctionSpace(mesh, "DG", 1), form_compiler_parameters={"representation":"uflacs"}) pgs = interpolate(temp_DG_4, Quad) pgs_array = pgs.vector().get_local()[:] cb_f_array = project(cb_force, Quad).vector().get_local()[:] #strarray.append(cb_f_array[0]) #strarray[l,:] = cb_f_array[:] #pstrarray[l,:] = p_f_array[:] #hslarray.append(hsl_array[0]+delta_hsl_array[0]) #hslarray[l,:] = hsl_array[:] + delta_hsl_array[:] #overlaparray[l,:] = temp_overlap # Calculate reaction force at right end b = assemble(Ftotal,form_compiler_parameters={"representation":"uflacs"}) bcleft.apply(b) bcfix_y.apply(b) bcfix_z.apply(b) bcfix_y_right.apply(b) bcfix_z_right.apply(b) f_int_total = b.copy() for kk in x_dofs: fx_rxn[l] += f_int_total[kk] #bcleft.apply(f_int_total) #FX = 0 #for kk in x_dofs: # FX += f_int_total[i] #fx_rxn[l] = Fx np.save(output_path + "fx",fx_rxn) if t <= 5: u_D.u_D += .14 else: u_D.u_D = u_D.u_D #print(cb_f_array) """if t <= 100: # stretch to 1300 u_D.u_D += .003 if t < 500 and t > 100: u_D.u_D =u_D.u_D if t < 600 and t >= 500: u_D.u_D += .0005 if t < 800 and t >=600: u_D.u_D = u_D.u_D if t < 900 and t >= 800: u_D.u_D -= .0005 if t >= 900: u_D.u_D = u_D.u_D""" """if t < 170 and t > 150: u_D.u_D -= 0.005 else: u_D.u_D = u_D.u_D""" """if t < 5: u_D.u_D += 0.03 else: u_D.u_D = u_D.u_D""" t = t + step_size #calarray.append(hs.Ca_conc*np.ones(no_of_int_points)) #calcium[] = hs.Ca_conc* if save_output: active_stress_ds.iloc[0,:] = cb_f_array[:] active_stress_ds.to_csv(output_path + 'active_stress.csv',mode='a',header=False) #active_stress_ds = active_stress_ds.transpose() #hsl_array_ds.iloc[0,:] = hsl_array[:] #hsl_array_ds.to_csv(output_path + 'half_sarcomere_lengths.csv',mode='a',header=False) calcium_ds.iloc[0,:] = calcium[l] calcium_ds.to_csv(output_path + 'calcium.csv',mode='a',header=False) #for i in range(no_of_int_points): # dumped_populations_ds.iloc[i,:] = dumped_populations[i,:] #dumped_populations_ds.to_csv(output_path + 'populations.csv',mode='a',header=False) tarray_ds[l] = tarray[l] tarray_ds.to_csv(output_path + 'time.csv',mode='a',header=False) #p_f_array_ds.iloc[0,:] = p_f_array[:] #p_f_array_ds.to_csv(output_path + 'myofiber_passive.csv',mode='a',header=False) #pgf_array_ds.iloc[0,:] = pgf_array[:] #pgf_array_ds.to_csv(output_path + 'gucc_fiber_pstress.csv',mode='a',header=False) #pgt_array_ds.iloc[0,:] = pgt_array[:] #pgt_array_ds.to_csv(output_path + 'gucc_trans_pstress.csv',mode='a',header=False) #pgs_array_ds.iloc[0,:] = pgs_array[:] #pgs_array_ds.to_csv(output_path + 'gucc_shear_pstress.csv',mode='a',header=False) #temp_overlap_ds.iloc[0,:] = temp_overlap[:] #temp_overlap_ds.to_csv(output_path + 'overlap.csv',mode='a',header=False) #alpha_array_ds.iloc[0,:] = alpha_array[:] #alpha_array_ds.to_csv(output_path + 'alpha.csv',mode='a',header=False) #delta_hsl_array_ds.iloc[0,:] = delta_hsl_array[:] #delta_hsl_array_ds.to_csv(output_path + 'delta_hsl.csv',mode='a',header=False) # Update Fiber orientation #f0 = f0+step_size*(Cmat*f0-f0)/sqrt(inner(Cmat*f0-f0,Cmat*f0-f0)) #target_vec = Cmat*f0 #print target_vec.type() #target_diff = target_vec - f0 #target_diff = target_diff/sqrt(inner(target_diff,target_diff)) #f0 = f0 + step_size*target_diff #File(output_path + "fiber_" +str(t)+ ".pvd") << project(f0, VectorFunctionSpace(mesh, "CG", 1)) """for m in range(no_of_int_points): for k in range(n_array_length): dumped_populations[l, m, k] = y_vec_array[m * n_array_length + k]""" rate_constants = np.zeros((no_of_x_bins,no_of_transitions + 1)) #for l in range(no_of_x_bins): # for m in range(no_of_transitions + 1): # rate_constants[l,m] = Myosim.dump_rate_constants(l, m, 0) fluxes, rates = implement.return_rates_fenics(hs) #np.save("/home/fenics/shared/python_dev/test_10_pm/rates",rates) #np.save("/home/fenics/shared/python_dev/test_10_pm/dumped_populations",dumped_populations) #np.save("/home/fenics/shared/python_dev/test_10_pm/tarray",tarray) #np.save("/home/fenics/shared/python_dev/test_10_pm/stress_array",strarray) #np.save("/home/fenics/shared/python_dev/test_10_pm/pstress_array",p_f) #np.save("/home/fenics/shared/python_dev/test_10_pm/calcium",calarray) #np.save("/home/fenics/shared/test_10/displacements",darray) #np.save("/home/fenics/shared/python_dev/test_10_pm/HSL",hslarray) #np.save("/home/fenics/shared/test_10/DHSL",delta_hsls) """outputs = { "rates": rates, "dumped_populations": dumped_populations, "tarray": tarray, "strarray": strarray, "pstrarray": pstrarray, "alphaarray": darray, "calarray": calarray, "hsl": hslarray, #"overlap": overlaparray }""" outputs = {} """np.save(output_path +"dumped_populations", dumped_populations) np.save(output_path + "tarray", tarray) np.save(output_path + "stress_array", strarray) np.save(output_path + "hsl", hslarray) np.save(output_path + "overlap", overlaparray) np.save(output_path + "pstress_array",pstrarray) np.save(output_path + "j3",j3_fluxes) np.save(output_path + "j4",j4_fluxes) #np.save(output_path + "alpha_array",alphaarray) np.save(output_path + "calcium",calarray)""" fdataCa.close() return(outputs)
def import_mesh(sim_geometry, options): # create a dictionary to pass info for fcn assignments later lv_options = {} if sim_geometry == "box_mesh": print "Creating Box Mesh" # setting default values box_mesh_specs = {} box_mesh_specs["base_corner_x"] = [0.0] box_mesh_specs["base_corner_y"] = [0.0] box_mesh_specs["base_corner_z"] = [0.0] box_mesh_specs["end_x"] = [10.0] box_mesh_specs["end_y"] = [1.0] box_mesh_specs["end_z"] = [1.0] box_mesh_specs["refinement_x"] = [10.0] box_mesh_specs["refinement_y"] = [5.0] box_mesh_specs["refinement_z"] = [5.0] box_mesh_specs.update(options) base_corner = Point(box_mesh_specs["base_corner_x"][0], box_mesh_specs["base_corner_y"][0], box_mesh_specs["base_corner_z"][0]) end_corner = Point(box_mesh_specs["end_x"][0], box_mesh_specs["end_y"][0], box_mesh_specs["end_z"][0]) mesh = BoxMesh(base_corner, end_corner, box_mesh_specs["refinement_x"][0], box_mesh_specs["refinement_y"][0], box_mesh_specs["refinement_z"][0]) if sim_geometry == "gmesh_cylinder": path_to_mesh = options["mesh_path"][0] #mesh = Mesh(path_to_mesh) mesh = Mesh() f = XDMFFile(mpi_comm_world(), path_to_mesh) f.read(mesh) f.close() if sim_geometry == "cylinder": # initialize dictionary cylinder_specs = {} # default values #---------------- # Center point for end of cylinder cylinder_specs["end_x"] = [10.0] cylinder_specs["end_y"] = [0.0] cylinder_specs["end_z"] = [0.0] # Center point for base of cylinder cylinder_specs["base_x"] = [0.0] cylinder_specs["base_y"] = [0.0] cylinder_specs["base_z"] = [0.0] # Base radius cylinder_specs["base_radius"] = [1.0] cylinder_specs["end_radius"] = [1.0] # Segments for approximating round shape cylinder_specs["segments"] = [20] # Refinement of mesh cylinder_specs["refinement"] = [30] # If user provides any alternate values, update # the cylinder_specs dictionary now cylinder_specs.update(options) cyl_bottom_center = Point(cylinder_specs["base_x"][0], cylinder_specs["base_y"][0], cylinder_specs["base_z"][0]) cyl_top_center = Point(cylinder_specs["end_x"][0], cylinder_specs["end_y"][0], cylinder_specs["end_z"][0]) # Create cylinder geometry cylinder_geometry = mshr.Cylinder(cyl_top_center, cyl_bottom_center, cylinder_specs["end_radius"][0], cylinder_specs["base_radius"][0], cylinder_specs["segments"][0]) # Create mesh print "Creating cylinder mesh" mesh = mshr.generate_mesh(cylinder_geometry, cylinder_specs["refinement"][0]) if sim_geometry == "unit_cube": # Use built in function mesh = UnitCubeMesh(1, 1, 1) if sim_geometry == "ventricle" or sim_geometry == "ellipsoid": if sim_geometry == "ellipsoid": casename = "ellipsoidal" else: casename = "New_mesh" #New_mesh is the default casename in scripts sent from Dr. Lee mesh_path = options["mesh_path"][0] lv_options["casename"] = casename lv_options["mesh_path"] = mesh_path # check to see if it exists if not os.path.exists(mesh_path): print "mesh file not found" exit() if "hdf5" in mesh_path: mesh = Mesh() f = HDF5File(mpi_comm_world(), mesh_path, 'r') f.read(mesh, casename, False) ugrid = vtk_py.convertXMLMeshToUGrid(mesh) ugrid = vtk_py.rotateUGrid(ugrid, sx=0.1, sy=0.1, sz=0.1) mesh = vtk_py.convertUGridToXMLMesh(ugrid) lv_options["f"] = f return mesh, lv_options
from dolfin import * import mshr # Parameters for geometry a = 0.04 b = a + 0.004 c = a + 0.01 L = 0.5 # Define cylinders inner = mshr.CSGCGALDomain3D( mshr.Cylinder(Point(0, 0, 0), Point(0, 0, L), a, a)) mid = mshr.CSGCGALDomain3D(mshr.Cylinder(Point(0, 0, 0), Point(0, 0, L), b, b)) outer = mshr.CSGCGALDomain3D( mshr.Cylinder(Point(0, 0, 0), Point(0, 0, L), c, c)) generator = mshr.TetgenMeshGenerator3D() generator.parameters["preserve_surface"] = True generator.parameters["mesh_resolution"] = 16. # Mesh inner cylinder inner_mesh = generator.generate(inner) # Mesh mid part mid_mesh = generator.generate(mshr.CSGCGALDomain3D(mid - inner)) # Mesh outer part outer_mesh = generator.generate(mshr.CSGCGALDomain3D(outer - mid)) # Glue together inner and mid mesh inner_mid_mesh = mshr.DolfinMeshUtils.merge_meshes(inner_mesh, mid_mesh)