f = Function(V) dt_inv = Constant(1 / dt) diffusion_source = 1 diffusion_drain = 1 if args.source: F = dt_inv * (u - u_n) * v * dx - (f - u_ini) * v * dx + diffusion_source * inner(grad(u), grad(v)) * dx elif args.drain: F = dt_inv * (u - u_n) * v * dx - (f - u) * v * dx + diffusion_drain * inner(grad(u), grad(v)) * dx # Time-stepping u_np1 = Function(V) if args.source: u_n.rename("Source-Data", "") u_np1.rename("Source-Data", "") elif args.drain: u_n.rename("Drain-Data", "") u_np1.rename("Drain-Data", "") t = 0 mesh_rank = MeshFunction("size_t", mesh, mesh.topology().dim()) if args.source: mesh_rank.set_all(MPI.rank(MPI.comm_world) + 4) else: mesh_rank.set_all(MPI.rank(MPI.comm_world) + 0) mesh_rank.rename("myRank", "") # Generating output files
gamma=gamma, t=0) F = u * v / dt * dx + dot(grad(u), grad(v)) * dx - (u_n / dt + f) * v * dx if problem is ProblemType.DIRICHLET: # apply Dirichlet boundary condition on coupling interface bcs.append(precice.create_coupling_dirichlet_boundary_condition(V)) if problem is ProblemType.NEUMANN: # apply Neumann boundary condition on coupling interface, modify weak form correspondingly F += precice.create_coupling_neumann_boundary_condition(v) a, L = lhs(F), rhs(F) # Time-stepping u_np1 = Function(V) u_np1.rename("Temperature", "") t = 0 # reference solution at t=0 u_ref = interpolate(u_D, V) u_ref.rename("reference", " ") temperature_out = File("out/%s.pvd" % precice.get_solver_name()) ref_out = File("out/ref%s.pvd" % precice.get_solver_name()) error_out = File("out/error%s.pvd" % precice.get_solver_name()) # output solution and reference solution at t=0, n=0 n = 0 print('output u^%d and u_ref^%d' % (n, n)) temperature_out << u_n ref_out << u_ref
# mark mesh w.r.t ranks ranks = File("output/ranks%s.pvd.pvd" % precice.get_participant_name()) mesh_rank = MeshFunction("size_t", mesh, mesh.topology().dim()) mesh_rank.set_all(MPI.rank(MPI.comm_world)) mesh_rank.rename("myRank", "") ranks << mesh_rank # Create output file file_out = File("output/%s.pvd" % precice.get_participant_name()) file_out << u_n print("output vtk for time = {}".format(float(t))) n = 0 fluxes = Function(V_g) fluxes.rename("Fluxes", "") while precice.is_coupling_ongoing(): if precice.is_action_required( precice.action_write_iteration_checkpoint()): # write checkpoint precice.store_checkpoint(u_n, t, n) read_data = precice.read_data() # Update the coupling expression with the new read data precice.update_coupling_expression(coupling_expression, read_data) dt.assign(np.min([fenics_dt, precice_dt])) # Compute solution
a_np1 = update_a(du, u_n, v_n, a_n, ufl=True) v_np1 = update_v(a_np1, u_n, v_n, a_n, ufl=True) res = m(avg(a_n, a_np1, alpha_m), v) + k(avg(u_n, du, alpha_f), v) a_form = lhs(res) L_form = rhs(res) # parameters for Time-Stepping t = 0.0 n = 0 E_ext = 0 displacement_out = File("output/u_fsi.pvd") u_n.rename("Displacement", "") u_np1.rename("Displacement", "") displacement_out << u_n while precice.is_coupling_ongoing(): if precice.is_action_required( precice.action_write_iteration_checkpoint()): # write checkpoint precice.store_checkpoint(u_n, t, n) # read data from preCICE and get a new coupling expression read_data = precice.read_data() # Update the point sources on the coupling boundary with the new read data Forces_x, Forces_y = precice.get_point_sources(read_data)
# Define variational problem u = TrialFunction(V) v = TestFunction(V) F = u * v / dt * dx + alpha * dot(grad(u), grad(v)) * dx - u_n * v / dt * dx # apply Dirichlet boundary condition on coupling interface bcs.append(precice.create_coupling_dirichlet_boundary_condition(V)) a, L = lhs(F), rhs(F) # Time-stepping u_np1 = Function(V) F_known_u = u_np1 * v / dt * dx + alpha * dot(grad(u_np1), grad(v)) * dx - u_n * v / dt * dx u_np1.rename("T", "") t = 0 u_D.t = t + precice._precice_tau assert (dt == precice._precice_tau) file_out = File("Solid/VTK/%s.pvd" % solver_name) while precice.is_coupling_ongoing(): # Compute solution solve(a == L, u_np1, bcs) # Dirichlet problem obtains flux from solution and sends flux on boundary to Neumann problem fluxes = fluxes_from_temperature_full_domain(F_known_u, V, k) is_converged = precice.advance(fluxes, dt)
f = Constant(beta - 2 - 2 * alpha) F = u * v / dt * dx + dot(grad(u), grad(v)) * dx - (u_n / dt + f) * v * dx if problem is ProblemType.DIRICHLET: # apply Dirichlet boundary condition on coupling interface bcs.append(precice.create_coupling_dirichlet_boundary_condition(V)) if problem is ProblemType.NEUMANN: # apply Neumann boundary condition on coupling interface, modify weak form correspondingly F += precice.create_coupling_neumann_boundary_condition(v) a, L = lhs(F), rhs(F) # Time-stepping u_np1 = Function(V) F_known_u = u_np1 * v / dt * dx + dot(grad(u_np1), grad(v)) * dx - (u_n / dt + f) * v * dx u_np1.rename("Temperature", "") t = 0 # reference solution at t=0 u_ref = interpolate(u_D, V) u_ref.rename("reference", " ") temperature_out = File("out/%s.pvd" % precice._solver_name) ref_out = File("out/ref%s.pvd" % precice._solver_name) error_out = File("out/error%s.pvd" % precice._solver_name) # output solution and reference solution at t=0, n=0 n = 0 print('output u^%d and u_ref^%d' % (n, n)) temperature_out << u_n ref_out << u_ref
def compute_conv_diff_reac_video(self, initial_condition=None, video_ref=None, video_size=None): names = {'Cl', 'K'} P1 = FiniteElement('P', fe.triangle, 1) element = fe.MixedElement([P1, P1]) V_single = FunctionSpace(self.mesh, P1) V = FunctionSpace(self.mesh, element) self.V_conc = V # load video video = VideoData(element=P1) video.load_video(self.video_filename) if( video_ref is not None and video_size is not None): video.set_reference_frame(video_ref, video_size) print(video) dt = 0.05 t = 0. t_end = 20. u_init = Function(V) (u_cl, u_k) = TrialFunction(V) (v_cl, v_k) = TestFunction(V) #u_na = video if initial_condition is None: #initial_condition = Expression(("f*exp(-0.5*((x[0]-a)*(x[0]-a)+(x[1]-b)*(x[1]-b))/var)/(sqrt(2*pi)*var)", # "0."), a = 80, b= 55, var=10, f=10, pi=fe.pi, element=element) initial_condition = Expression(("f", "0."), a=80, b=55, var=0.1, f=0.1, pi=fe.pi, element=element) u_init = fe.interpolate(initial_condition, V) u_init_cl = u_init[0] u_init_k = u_init[1] u_init_na : VideoData= video assert (self.flow is not None) n = fe.FacetNormal(self.mesh) dx, ds = self.dx, self.ds flow = 5. * self.flow f_in = fe.Constant(0.00) f_in_cl = fe.Constant(-0.05) D = fe.Constant(0.1) C_na = fe.Constant(0.1) k1 = fe.Constant(0.2) k_1 = fe.Constant(0.00001) # explicit F = ( (u_cl - u_init_cl) * v_cl * dx + dt * D * inner(grad(u_cl), grad(v_cl)) * dx + dt * inner(flow, grad(u_cl)) * v_cl * dx #+ (u_na - u_init_na) * v_na * dx #+ dt * D * inner(grad(u_na), grad(v_na)) * dx #+ dt * inner(flow, grad(u_na)) * v_na * dx + (u_k - u_init_k) * v_k * dx + dt * D * inner(grad(u_k), grad(v_k)) * dx + dt * inner(flow, grad(u_k)) * v_k * dx + f_in_cl * v_cl * dx #+ f_in * v_na * dx + f_in * v_k * dx + dt * k1 * u_init_cl * C_na * u_init_na * v_cl * dx #+ dt * k1 * u_init_cl * u_init_na * v_na * dx - dt * k1 * u_init_cl * C_na * u_init_na * v_k * dx - dt * k_1 * u_init_k * v_cl * dx #- dt * k_1 * u_init_k * v_na * dx + dt * k_1 * u_init_k * v_k * dx ) # implicit F = ( (u_cl - u_init_cl) * v_cl * dx + dt * D * inner(grad(u_cl), grad(v_cl)) * dx + dt * inner(flow, grad(u_cl)) * v_cl * dx # + (u_na - u_init_na) * v_na * dx # + dt * D * inner(grad(u_na), grad(v_na)) * dx # + dt * inner(flow, grad(u_na)) * v_na * dx + (u_k - u_init_k) * v_k * dx + dt * D * inner(grad(u_k), grad(v_k)) * dx + dt * inner(flow, grad(u_k)) * v_k * dx + f_in_cl * v_cl * dx # + f_in * v_na * dx + f_in * v_k * dx + dt * k1 * u_cl * C_na * u_init_na * v_cl * dx # + dt * k1 * u_init_cl * u_init_na * v_na * dx - dt * k1 * u_cl * C_na * u_init_na * v_k * dx - dt * k_1 * u_k * v_cl * dx # - dt * k_1 * u_init_k * v_na * dx + dt * k_1 * u_k * v_k * dx ) self.F = F a, L = fe.lhs(F), fe.rhs(F) a_mat = fe.assemble(a) L_vec = fe.assemble(L) output1 = fe.File('/tmp/cl_dyn.pvd') output2 = fe.File('/tmp/na_dyn.pvd') output3 = fe.File('/tmp/k_dyn.pvd') output4 = fe.File('/tmp/all_dyn.pvd') # solve self.sol = [] u_na = Function(V_single) u_na = fe.interpolate(u_init_na,V_single) na_inflow = 0 t_plot = 0.5 t_last_plot = 0 while t < t_end: t = t + dt t_last_plot += dt print(t) u = Function(V) u_init_na.set_time(5*t) a_mat = fe.assemble(a) L_vec = fe.assemble(L) fe.solve(a_mat, u.vector(), L_vec) # NonlinearVariationalProblem(F,u) u_init.assign(u) u_cl, u_k = u.split() # u_init_cl.assign(u_cl) # u_init_na.assign(u_na) # u_init_k.assign(u_k) u_na = fe.interpolate(u_init_na, V_single) u_cl.rename("cl", "cl") u_na.rename("na", "na") u_k.rename("k", "k") output1 << u_cl, t output2 << u_na, t output3 << u_k, t self.sol.append((u_cl, u_na, u_k)) print( fe.assemble(u_cl*self.dx)) if t_last_plot > t_plot: t_last_plot = 0 plt.figure(figsize=(8,16)) plt.subplot(211) fe.plot(u_cl) plt.subplot(212) fe.plot(u_k) plt.show() self.u_cl = u_cl #self.u_na = u_na self.u_k = u_k