def test_2d(solver, write_file=False): n = 200 np.random.seed(123) x0 = np.random.rand(n, 2) - 0.5 # y0 = np.ones(n) # y0 = x0[:, 0] # y0 = x0[:, 0]**2 # y0 = np.cos(np.pi*x0.T[0]) # y0 = np.cos(np.pi*x0.T[0]) * np.cos(np.pi*x0.T[1]) y0 = np.cos(np.pi * np.sqrt(x0.T[0]**2 + x0.T[1]**2)) import meshzoo points, cells = meshzoo.rectangle(-1.0, 1.0, -1.0, 1.0, 32, 32) # import pygmsh # geom = pygmsh.built_in.Geometry() # geom.add_circle([0.0, 0.0, 0.0], 1.0, 0.1) # points, cells, _, _, _ = pygmsh.generate_mesh(geom) # cells = cells['triangle'] u = smoothfit.fit(x0, y0, points, cells, lmbda=1.0e-5, solver=solver) # ref = 4.411_214_155_799_310_5 # val = assemble(u * u * dx) # assert abs(val - ref) < 1.0e-10 * ref if write_file: from dolfin import XDMFFile xdmf = XDMFFile("temp.xdmf") xdmf.write(u)
class SolutionFile(SolutionFile_Base): # DOLFIN 2018.1.0.dev added (throughout the developement cycle) an optional append # attribute to XDMFFile.write_checkpoint, which should be set to its non-default value, # thus breaking backwards compatibility append_attribute = XDMFFile.write_checkpoint.__doc__.find( "append: bool") > -1 def __init__(self, directory, filename): SolutionFile_Base.__init__(self, directory, filename) self._visualization_file = XDMFFile(self._full_filename + ".xdmf") self._visualization_file.parameters["flush_output"] = True self._restart_file = XDMFFile(self._full_filename + "_checkpoint.xdmf") self._restart_file.parameters["flush_output"] = True @staticmethod def remove_files(directory, filename): SolutionFile_Base.remove_files(directory, filename) # full_filename = os.path.join(str(directory), filename) if is_io_process() and os.path.exists(full_filename + ".xdmf"): os.remove(full_filename + ".xdmf") os.remove(full_filename + ".h5") os.remove(full_filename + "_checkpoint.xdmf") os.remove(full_filename + "_checkpoint.h5") def write(self, function, name, index): assert index in (self._last_index, self._last_index + 1) if index == self._last_index + 1: # writing out solutions after time stepping self._update_function_container(function) time = float(index) self._visualization_file.write(self._function_container, time) bak_log_level = get_log_level() set_log_level(int(WARNING) + 1) # disable xdmf logs) if self.append_attribute: self._restart_file.write_checkpoint( self._function_container, name, time, append=True) else: self._restart_file.write_checkpoint( self._function_container, name, time) set_log_level(bak_log_level) # Once solutions have been written to file, update last written index self._write_last_index(index) elif index == self._last_index: # corner case for problems with two (or more) unknowns which are written separately to file; # one unknown was written to file, while the other was not: since the problem might be coupled, # a recomputation of both is required, but there is no need to update storage pass else: raise ValueError("Invalid index") def read(self, function, name, index): if index <= self._last_index: time = float(index) self._restart_file.read_checkpoint(function, name, index) self._update_function_container(function) self._visualization_file.write(self._function_container, time) else: raise OSError
class SolutionFileXDMF(SolutionFile_Base): # DOLFIN 2018.1.0.dev added (throughout the developement cycle) an optional append # attribute to XDMFFile.write_checkpoint, which should be set to its non-default value, # thus breaking backwards compatibility append_attribute = XDMFFile.write_checkpoint.__doc__.find("append: bool") > - 1 def __init__(self, directory, filename): SolutionFile_Base.__init__(self, directory, filename) self._visualization_file = XDMFFile(self._full_filename + ".xdmf") self._visualization_file.parameters["flush_output"] = True self._restart_file = XDMFFile(self._full_filename + "_checkpoint.xdmf") self._restart_file.parameters["flush_output"] = True @staticmethod def remove_files(directory, filename): SolutionFile_Base.remove_files(directory, filename) # full_filename = os.path.join(str(directory), filename) def remove_files_task(): if os.path.exists(full_filename + ".xdmf"): os.remove(full_filename + ".xdmf") os.remove(full_filename + ".h5") os.remove(full_filename + "_checkpoint.xdmf") os.remove(full_filename + "_checkpoint.h5") parallel_io(remove_files_task) def write(self, function, name, index): time = float(index) # Write visualization file (no append available, will overwrite) self._update_function_container(function) self._visualization_file.write(self._function_container, time) # Write restart file. It might be possible that the solution was written to file in a previous run # and the execution was interrupted before last written index was updated. In this corner case # there would be two functions corresponding to the same time, with two consecutive indices. # For now the inelegant way is to try to read: if that works, assume that we are in the corner case; # otherwise, we are in the standard case and we should write to file. try: self._restart_file.read_checkpoint(self._function_container, name, index) except RuntimeError: from dolfin.cpp.log import get_log_level, LogLevel, set_log_level self._update_function_container(function) bak_log_level = get_log_level() set_log_level(int(LogLevel.WARNING) + 1) # disable xdmf logs if self.append_attribute: self._restart_file.write_checkpoint(self._function_container, name, time, append=True) else: self._restart_file.write_checkpoint(self._function_container, name, time) set_log_level(bak_log_level) # Once solutions have been written to file, update last written index self._write_last_index(index) def read(self, function, name, index): if index <= self._last_index: time = float(index) self._restart_file.read_checkpoint(function, name, index) self._update_function_container(function) self._visualization_file.write(self._function_container, time) # because there is no append option available else: raise OSError
class XDMFWriter(object): def __init__(self, directory, file): self.outputFile = XDMFFile("{}/{}.xdmf".format(directory, file)) self.outputFile.parameters["rewrite_function_mesh"] = False self.outputFile.parameters["functions_share_mesh"] = True def writeSingle(self, solution, time=0.0): self.outputFile.write(solution, time) def writeMultiple(self, solutionList, time=0.0): for solution in solutionList: self.outputFile.write(solution, time) def close(self): self.outputFile.close()
def _write(self, filename, encoding=None): assert filename.endswith(".rtc.xml") or filename.endswith(".rtc.xdmf") # Create output folder try: os.makedirs(filename) except OSError: if not os.path.isdir(filename): raise # Write out MeshFunctions for (d, mesh_function_d) in enumerate(self): if filename.endswith(".rtc.xml"): File(filename + "/mesh_function_" + str(d) + ".xml") << mesh_function_d else: xdmf_file = XDMFFile(filename + "/mesh_function_" + str(d) + ".xdmf") if encoding is not None: xdmf_file.write(mesh_function_d, encoding) else: xdmf_file.write(mesh_function_d)
def _update_xdmf_file(self, field_name, saveformat, data, timestep, t): "Update xdmf file with new data." assert isinstance(data, Function) assert saveformat == "xdmf" fullname, metadata = self._get_datafile_name(field_name, saveformat, timestep) key = (field_name, saveformat) datafile = self._datafile_cache.get(key) if datafile is None: datafile = XDMFFile(mpi_comm_world(), fullname) datafile.parameters["rewrite_function_mesh"] = False datafile.parameters["flush_output"] = True self._datafile_cache[key] = datafile try: datafile.write(data, float(t)) except: datafile << (data, float(t)) return metadata
t1 = Timer("[P] Solve projection") pde_projection.solve_problem(psibar_h, psi_h, "mumps", "default") del t1 else: t1 = Timer("[P] Solve projection") lstsq_psi.project(psi_h) del t1 t1 = Timer("[P] Update and store") # Update old solution assign(psi0_h, psi_h) # Store field if step % store_step == 0 or step == 1: output_field.write(psi_h, t) # Avoid getting accused of cheating, compute # L2 error and mass error at half rotation if int(np.floor(2 * step - num_steps)) == 0: psi0_expression.t = step * float(dt) l2_error_half = sqrt( assemble( dot(psi_h - psi0_expression, psi_h - psi0_expression) * dx)) area_half = assemble(psi_h * dx) del t1 timer.stop() # Compute error (we should accurately recover initial condition) psi0_expression.t = step * float(dt)
# Set-up Stokes Solve forms_stokes = FormsStokes(mesh, mixedL, mixedG, alpha, ds=ds).forms_multiphase(rho, ustar, dt, rho * nu, f) ssc = StokesStaticCondensation(mesh, forms_stokes['A_S'], forms_stokes['G_S'], forms_stokes['B_S'], forms_stokes['Q_S'], forms_stokes['S_S']) # Loop and output step = 0 t = 0. # Store tstep 0 assign(rho, rho0) xdmf_rho.write_checkpoint(rho, "rho", t) xdmf_u.write(Uh.sub(0), t) xdmf_p.write(Uh.sub(1), t) p.dump2file(mesh, fname_list, property_list, 'wb') comm.barrier() # Save some data in txt files nc = mesh.num_entities_global(2) npt = p.number_of_particles() with open(meta_data, "w") as write_file: write_file.write("%-12s %-12s %-15s %-20s %-15s %-15s \n" % ("Time step", "Number of steps", "Number of cells", "Number of particles", "Projection", "Solver")) write_file.write("%-12.5g %-15d %-15d %-20d %-15s %-15s \n" % (float(dt), num_steps, nc, npt, projection_type, solver))
# Initialize advection class, use RK3 scheme ap = advect_rk3(p, V, uh, 'closed') # Init projection lstsq_psi = l2projection(p, W, 1) # Do projection to get initial field lstsq_psi.project(psi_h.cpp_object(), lb, ub) AD = AddDelete(p, 10, 20, [psi_h], [1], [lb, ub]) step = 0 t = 0. area_0 = assemble(psi_h * dx) timer = Timer() timer.start() outfile.write(psi_h, t) while step < num_steps: step += 1 t += float(dt) if comm.Get_rank() == 0: print("Step " + str(step)) AD.do_sweep() ap.do_step(float(dt)) AD.do_sweep_failsafe(4) lstsq_psi.project(psi_h.cpp_object(), lb, ub) if step % store_step == 0: outfile.write(psi_h, t)
b = assemble(L) bc.apply(A, b) # Compute solution solver.solve(S.vector(), b) (u, U) = S.split(True) # Update previous time step update(u, u0, v0, a0, beta, gamma, dt) update(U, U0, V0, A0, beta, gamma, dt) # time_array_x, time_array_y = time_to_pml_border(u_s_0, u0, time_array_x,time_array_y, t, Lx, Ly, n) # Save solution to XDMF file format xdmf_file.write(u, t) if record and rec_counter % 2 == 0: pvd << (u0,t) rec_counter += 1 #s = p.linspace(0,Lx+2*Ly, n) #file_time = open('filename_time_to_pml.obj', 'w') #pickle.dump([s,time_array_x,time_array_y], file_time) #plt.plot(s, time_array_x) #plt.plot(s, time_array_y) #plt.show() # Close file
t += delta_t # Update current time # Solve variational problem for time step solve(F == 0, u, solver_parameters={ "newton_solver": { "relative_tolerance": 1e-6 }, "newton_solver": { "maximum_iterations": 60 } }) print('solver done') # Save solution to files for visualization and postprocessing(HDF5) _u_A, _u_B, _u_C, _u_T = u_n.split() _u_D = _u_C * 3 if Writting_xdmf: xdmffile_A.write(_u_A, t) xdmffile_B.write(_u_B, t) xdmffile_C.write(_u_C, t) xdmffile_D.write(_u_D, t) xdmffile_T.write(_u_T, t) u_n.assign(u) # _______________END_______________ #
if MPI.size(MPI.comm_world) == 1: xdmu = XDMFFile("biot_" + discretization + "_u.xdmf") xdmp = XDMFFile("biot_" + discretization + "_p.xdmf") print("Discretization:", discretization) while t < T: t += dt print("\tsolving at time", t) AA = block_assemble(lhs) FF = block_assemble(rhs) bcs.apply(AA) bcs.apply(FF) block_solve(AA, w.block_vector(), FF, "mumps") block_assign(w0, w) xdmu.write(w[0], t) xdmp.write(w[1], t) u_con.assign(w[0]) p_con.assign(w[1]) mass = assemble(mass_con) print("\taverage mass residual: ", np.average(np.abs(mass[:]))) if discretization == "DG": assert np.isclose(w[0].vector().norm("l2"), 0.019389822) assert np.isclose(w[1].vector().norm("l2"), 11778.77487) elif discretization == "EG": assert np.isclose(w[0].vector().norm("l2"), 0.019391447) # The assert on the norm of w[1] is missing because its value is not consistent across # runs on different machines. The field itself looks very similar to the DG one, though. # TODO Investigate further what the issue is (conditioning?).
ssc = StokesStaticCondensation(mesh, forms_stokes['A_S'], forms_stokes['G_S'], forms_stokes['B_S'], forms_stokes['Q_S'], forms_stokes['S_S']) # Set pressure in upper left corner to zero bc1 = DirichletBC(mixedG.sub(1), Constant(0), Corner(xmin, ymax), "pointwise") bcs = [bc1] lstsq_u = l2projection(p, W_2, 2) # Loop and output step = 0 t = 0. # Store at step 0 xdmf_rho.write(rho0, t) xdmf_u.write(Uh.sub(0), t) xdmf_p.write(Uh.sub(1), t) p.dump2file(mesh, fname_list, property_list, 'wb') dump_list = [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.] with open(pressure_table, "wb") as PT: pickle.dump(dump_list, PT) timer = Timer("[P] Total time consumed") timer.start() while step < num_steps: step += 1 t += float(dt)
def forward(mu_expression, lmbda_expression, rho, Lx=10, Ly=10, t_end=1, omega_p=5, amplitude=5000, center=0, target=False): Lpml = Lx / 10 #c_p = cp(mu.vector(), lmbda.vector(), rho) max_velocity = 200 #c_p.max() stable_hx = stable_dx(max_velocity, omega_p) nx = int(Lx / stable_hx) + 1 #nx = max(nx, 60) ny = int(Ly * nx / Lx) + 1 mesh = mesh_generator(Lx, Ly, Lpml, nx, ny) used_hx = Lx / nx dt = stable_dt(used_hx, max_velocity) cfl_ct = cfl_constant(max_velocity, dt, used_hx) print(used_hx, stable_hx) print(cfl_ct) #time.sleep(10) PE = FunctionSpace(mesh, "DG", 0) mu = interpolate(mu_expression, PE) lmbda = interpolate(lmbda_expression, PE) m = 2 R = 10e-8 t = 0.0 gamma = 0.50 beta = 0.25 ff = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1) Dirichlet(Lx, Ly, Lpml).mark(ff, 1) # Create function spaces VE = VectorElement("CG", mesh.ufl_cell(), 1, dim=2) TE = TensorElement("DG", mesh.ufl_cell(), 0, shape=(2, 2), symmetry=True) W = FunctionSpace(mesh, MixedElement([VE, TE])) F = FunctionSpace(mesh, "CG", 2) V = W.sub(0).collapse() M = W.sub(1).collapse() alpha_0 = Alpha_0(m, stable_hx, R, Lpml) alpha_1 = Alpha_1(alpha_0, Lx, Lpml, degree=2) alpha_2 = Alpha_2(alpha_0, Ly, Lpml, degree=2) beta_0 = Beta_0(m, max_velocity, R, Lpml) beta_1 = Beta_1(beta_0, Lx, Lpml, degree=2) beta_2 = Beta_2(beta_0, Ly, Lpml, degree=2) alpha_1 = interpolate(alpha_1, F) alpha_2 = interpolate(alpha_2, F) beta_1 = interpolate(beta_1, F) beta_2 = interpolate(beta_2, F) a_ = alpha_1 * alpha_2 b_ = alpha_1 * beta_2 + alpha_2 * beta_1 c_ = beta_1 * beta_2 Lambda_e = as_tensor([[alpha_2, 0], [0, alpha_1]]) Lambda_p = as_tensor([[beta_2, 0], [0, beta_1]]) a_ = alpha_1 * alpha_2 b_ = alpha_1 * beta_2 + alpha_2 * beta_1 c_ = beta_1 * beta_2 Lambda_e = as_tensor([[alpha_2, 0], [0, alpha_1]]) Lambda_p = as_tensor([[beta_2, 0], [0, beta_1]]) # Set up boundary condition bc = DirichletBC(W.sub(0), Constant(("0.0", "0.0")), ff, 1) # Create measure for the source term dx = Measure("dx", domain=mesh) ds = Measure("ds", domain=mesh, subdomain_data=ff) # Set up initial values u0 = Function(V) u0.set_allow_extrapolation(True) v0 = Function(V) a0 = Function(V) U0 = Function(M) V0 = Function(M) A0 = Function(M) # Test and trial functions (u, S) = TrialFunctions(W) (w, T) = TestFunctions(W) g = ModifiedRickerPulse(0, omega_p, amplitude, center) F = rho * inner(a_ * N_ddot(u, u0, a0, v0, dt, beta) \ + b_ * N_dot(u, u0, v0, a0, dt, beta, gamma) + c_ * u, w) * dx \ + inner(N_dot(S, U0, V0, A0, dt, beta, gamma).T * Lambda_e + S.T * Lambda_p, grad(w)) * dx \ - inner(g, w) * ds \ + inner(compliance(a_ * N_ddot(S, U0, A0, V0, dt, beta) + b_ * N_dot(S, U0, V0, A0, dt, beta, gamma) + c_ * S, u, mu, lmbda), T) * dx \ - 0.5 * inner(grad(u) * Lambda_p + Lambda_p * grad(u).T + grad(N_dot(u, u0, v0, a0, dt, beta, gamma)) * Lambda_e \ + Lambda_e * grad(N_dot(u, u0, v0, a0, dt, beta, gamma)).T, T) * dx \ a, L = lhs(F), rhs(F) # Assemble rhs (once) A = assemble(a) # Create GMRES Krylov solver solver = KrylovSolver(A, "gmres") # Create solution function S = Function(W) if target: xdmffile_u = XDMFFile("inversion_temporal_file/target/u.xdmf") pvd = File("inversion_temporal_file/target/u.pvd") xdmffile_u.write(u0, t) timeseries_u = TimeSeries( "inversion_temporal_file/target/u_timeseries") else: xdmffile_u = XDMFFile("inversion_temporal_file/obs/u.xdmf") xdmffile_u.write(u0, t) timeseries_u = TimeSeries("inversion_temporal_file/obs/u_timeseries") rec_counter = 0 while t < t_end - 0.5 * dt: t += float(dt) if rec_counter % 10 == 0: print( '\n\rtime: {:.3f} (Progress: {:.2f}%)'.format( t, 100 * t / t_end), ) g.t = t # Assemble rhs and apply boundary condition b = assemble(L) bc.apply(A, b) # Compute solution solver.solve(S.vector(), b) (u, U) = S.split(True) # Update previous time step update(u, u0, v0, a0, beta, gamma, dt) update(U, U0, V0, A0, beta, gamma, dt) xdmffile_u.write(u, t) pvd << (u, t) timeseries_u.store(u.vector(), t) energy = inner(u, u) * dx E = assemble(energy) print("E = ", E) print(u.vector().max())
# Needed for particle advection assign(Udiv, Uh.sub(0)) # Needed for constrained map assign(ubar0_a, Uhbar.sub(0)) assign(u0_a, ustar) assign(duh00, duh0) assign(duh0, project(Uh.sub(0) - ustar, W_2)) p.increment(Udiv.cpp_object(), ustar.cpp_object(), np.array([1, 2], dtype=np.uintp), theta_p, step) if step == 2: theta_L.assign(theta_next) xdmf_u.write(Uh.sub(0), t) xdmf_p.write(Uh.sub(1), t) # Compute vorticity curl_func.assign(project(curl(Uh.sub(0)), W_2)) xdmf_curl.write(curl_func, t) timer.stop() # Compute errors ex = as_vector((1.0, 0.0, 0.0)) ey = as_vector((0.0, 1.0, 0.0)) ez = as_vector((0.0, 0.0, 1.0)) momentum = assemble( (dot(Uh.sub(0), ex) + dot(Uh.sub(0), ey) + dot(Uh.sub(0), ez)) * dx)