def run_estimates(): # Input parameters T = 1.0 alpha = (1.0, 1.0, 1.0, 1.0) mu = 0.5 lamb = 1.0 c = (1.0, 1.0, 1.0, 1.0) K = (1.0, 1.0, 1.0, 1.0) xi = (1.0, 1.0, 1.0, 1.0, 1.0, 1.0) # Get source terms using sympy u_str = "(cos(pi*x)*sin(pi*y)*sin(2*pi*t), sin(pi*x)*cos(pi*y)*sin(2*pi*t))" # string expression p_str = "(sin(pi*x)*sin(pi*y)*sin(2*pi*t), sin(pi*x)*sin(pi*y)*sin(2*pi*t), \ sin(pi*x)*sin(pi*y)*sin(2*pi*t), sin(pi*x)*sin(pi*y)*sin(2*pi*t))" # string expression u_s = st.str2exp(u_str) p_s = st.str2exp(p_str) # create FEniCS expressions (fs, gs) = st.get_source_terms(u_str, p_str) # get source terms # Print parameter-info to terminal print("alpha =", alpha, "nu =", nu, "E = ", E, "mu =", mu) print("lamb = ", lamb, "c = ", c, "K =", K, "xi = ", xi) params = dict(alpha=alpha, mu=mu, lamb=lamb, c=c, K=K, xi=xi) for N in [4, 8, 16, 32, 64]: dt = (1. / N)**2 mesh = UnitSquareMesh(N, N) u_h, p_h, u_e, p_e, eta, mesh = compute_estimates( mesh, T, dt, u_s, p_s, fs, gs, params)
def run_solver(): """ Run default parameters, all set to 1. """ # Parameters T = 0.1 alpha = (1.0, 1.0) nu = None E = None mu = 0.5 lamb = 1.0 c = (1.0, 1.0) K = (1.0, 1.0) xi = (1.0, 1.0) params = dict(alpha=alpha, mu=mu, lamb=lamb, nu=nu, E=E, c=c, K=K, xi=xi) # Print parameter-info to terminal print "alpha =", alpha, "nu =", nu, "E = ", E, "mu =", mu print "lamb = ", lamb, "c = ", c, "K =", K, "xi = ", xi # Get source terms using sympy u_str = "(cos(pi*x)*sin(pi*y)*sin(pi*t), sin(pi*x)*cos(pi*y)*sin(pi*t))" # string expression p_str = "(sin(pi*x)*cos(pi*y)*sin(2*pi*t), cos(pi*x)*sin(pi*y)*sin(2*pi*t))" # string expression u_s = st.str2exp(u_str) p_s = st.str2exp(p_str) # create FEniCS expressions (fs, gs) = st.get_source_terms(u_str, p_str) # get source terms # Error lists E_u = [] E_p1 = [] E_p2 = [] h = [] # Solve for each N for N in [4, 8, 16, 32, 64]: dt = (1. / N)**2 u_h, p_h, u_e, p_e, mesh = solver(N, T, dt, u_s, p_s, fs, gs, params) # Compute error norms u_error = errornorm(u_h, u_e, "H1") p1_error = errornorm(p_h[0], p_e[0], "L2") p2_error = errornorm(p_h[1], p_e[1], "L2") # Append error to list E_u.append(u_error) E_p1.append(p1_error) E_p2.append(p2_error) h.append(mesh.hmin()) # Print info to terminal print "N = %.d, dt = %.1e, u: %.3e, p1: %.3e, p2: %.3e" % ( N, dt, u_error, p1_error, p2_error) # Convergence rate E = dict(u=E_u, p1=E_p1, p2=E_p2) convergence_rate(E, h)
def run(params, refinement): # Get source terms using sympy u_str = "(cos(pi*x)*sin(pi*y)*sin(2*pi*t), sin(pi*x)*cos(pi*y)*sin(2*pi*t))" # string expression p_str = "(sin(pi*x)*sin(pi*y)*sin(2*pi*t), sin(pi*x)*sin(pi*y)*sin(2*pi*t), \ sin(pi*x)*sin(pi*y)*sin(2*pi*t), sin(pi*x)*sin(pi*y)*sin(2*pi*t))" # string expression u_s = st.str2exp(u_str); p_s = st.str2exp(p_str) # create FEniCS expressions (fs, gs) = st.get_source_terms(u_str, p_str) # get source terms # Brain mesh path = r"%s/mesh" % os.getcwd() mesh = Mesh("%s/brain.xml" %path) #edge_numbers = MeshFunction("size_t", mesh, mesh.topology().dim() - 1, mesh.domains()) if refinement == "space": # Parameters T = 0.1 dt = 5.0e-3 # Error lists E_u = []; E_p1 = []; E_p2 = []; E_p3 = []; E_p4 = []; h = [] E_eta1 = []; E_eta2 = []; E_eta3 = []; E_eta4 = [] # Solve for each unformal mesh refinement for i in range(0,2): u_h, p_h, u_e, p_e, eta, mesh_ = ce.compute_estimates(mesh, T, dt, u_s, p_s, fs, gs, params, refinement) # Error norms u_error = errornorm(u_e, u_h, "H1", mesh=mesh) p1_error = errornorm(p_e[0], p_h[0], "L2", mesh=mesh) p2_error = errornorm(p_e[1], p_h[1], "L2", mesh=mesh) p3_error = errornorm(p_e[2], p_h[2], "L2", mesh=mesh) p4_error = errornorm(p_e[3], p_h[3], "L2", mesh=mesh) # Save error to lists E_u.append(u_error); E_p1.append(p1_error); E_p2.append(p2_error); E_p3.append(p3_error); E_p4.append(p4_error) h.append(mesh_.hmin()) # Print error print("num_cells = %.d, dt = %.3e, u_err: %.3e, p1_err: %.3e, p2_err: %.3e, p3_err: %.3e, p4_err: %.3e" % (mesh.num_cells(), dt, u_error, p1_error, p2_error, p3_error, p4_error)) print("eta1: %.3e, eta2: %.3e, eta3: %.3e, eta4: %.3e" % (eta[0], eta[1], eta[2], eta[3])) # Refine mesh uniformly mesh = adapt(mesh_) #refined_edge_numbers = adapt(edge_numbers, mesh) # Convergence rate error = dict(u=E_u, p1=E_p1, p2=E_p2, p3=E_p3, p4=E_p4) convergence_rate(error, h) eta = dict(eta1=E_eta1, pta2=E_eta2, eta3=E_eta3, eta4=E_eta4) convergence_rate(eta, h) if refinement == "time": # Parameters T = 1.0 # Error lists E_u = []; E_p1 = []; E_p2 = []; E_p3 = []; E_p4 = []; tau = [] E_eta1 = []; E_eta2 = []; E_eta3 = []; E_eta4 = [] # Solve for each N for dt in [0.02, 0.01, 0.005, 0.0025, 0.00125]: u_h, p_h, u_e, p_e, eta, mesh = ce.compute_estimates(mesh, T, dt, u_s, p_s, fs, gs, params, refinement) # Error norms u_error = errornorm(u_e, u_h, "H1", mesh=mesh) p1_error = errornorm(p_e[0], p_h[0], "L2", mesh=mesh) p2_error = errornorm(p_e[1], p_h[1], "L2", mesh=mesh) p3_error = errornorm(p_e[2], p_h[2], "L2", mesh=mesh) p4_error = errornorm(p_e[3], p_h[3], "L2", mesh=mesh) # Save error to lists E_u.append(u_error); E_p1.append(p1_error); E_p2.append(p2_error); E_p3.append(p3_error); E_p4.append(p4_error) tau.append(dt) # Print error print("num_cells = %.d, dt = %.3e, u_err: %.3e, p1_err: %.3e, p2_err: %.3e, p3_err: %.3e, p4_err: %.3e" % (mesh.num_cells(), dt, u_error, p1_error, p2_error, p3_error, p4_error)) print("eta1: %.3e, eta2: %.3e, eta3: %.3e, eta4: %.3e" % (eta[0], eta[1], eta[2], eta[3])) # Convergence rate error = dict(u=E_u, p1=E_p1, p2=E_p2, p3=E_p3, p4=E_p4) convergence_rate(error, tau) eta = dict(eta4=E_eta4) convergence_rate(eta, tau) file = File("fig/mesh.pvd") file << mesh
def run_estimates(): """ Compute a posteriori error estimates with default parameters under simultaneous space/time refinement. """ # Parameters T = 1.0 alpha = (1.0, 1.0) nu = None E = None mu = 0.5 lamb = 1.0 c = (1.0, 1.0) K = (1.0, 1.0) xi = (1.0, 1.0) # Print parameter-info to terminal print("alpha =", alpha, "nu =", nu, "E = ", E, "mu =", mu) print("lamb = ", lamb, "c = ", c, "K =", K, "xi = ", xi) params = dict(alpha=alpha, mu=mu, lamb=lamb, c=c, K=K, xi=xi) # Get source terms using sympy u_str = "(cos(pi*x)*sin(pi*y)*sin(pi*t), sin(pi*x)*cos(pi*y)*sin(pi*t))" # string expression p_str = "(sin(pi*x)*cos(pi*y)*sin(2*pi*t), cos(pi*x)*sin(pi*y)*sin(2*pi*t))" # string expression u_s = st.str2exp(u_str) p_s = st.str2exp(p_str) # create FEniCS expressions (fs, gs) = st.get_source_terms(u_str, p_str) # get source terms # Error lists E_u = [] E_p1 = [] E_p2 = [] h = [] tau = [] E_eta1 = [] E_eta2 = [] E_eta3 = [] E_eta4 = [] for N in [4, 8, 16, 32, 64]: dt = (1. / N)**2 u_h, p_h, u_e, p_e, eta, mesh = compute_estimates(N, T, dt, u_s, p_s, fs, gs, params, experiment="test", refinement=None) # Compute error norms u_error = errornorm(u_h, u_e, "H1") p1_error = errornorm(p_h[0], p_e[0], "L2") p2_error = errornorm(p_h[1], p_e[1], "L2") # Append error to list E_u.append(u_error) E_p1.append(p1_error) E_p2.append(p2_error) E_eta1.append(eta[0]) E_eta2.append(eta[1]) E_eta3.append(eta[2]) E_eta4.append(eta[3]) h.append(mesh.hmin()) # Print info to terminal print("N = %.d, dt = %.1e, u: %.3e, p1: %.3e, p2: %.3e" % (N, dt, u_error, p1_error, p2_error)) print("eta1: %.3e, eta2: %.3e, eta3: %.3e, eta4: %.3e" % (eta[0], eta[1], eta[2], eta[3])) # Convergence rate E = dict(u=E_u, p1=E_p1, p2=E_p2, eta1=E_eta1, eta2=E_eta2, eta3=E_eta3, eta4=E_eta4) convergence_rate(E, h)
def run(params, experiment="default", refinement="space"): # Get source terms using sympy u_str = "(cos(pi*x)*sin(pi*y)*sin(pi*t), sin(pi*x)*cos(pi*y)*sin(pi*t))" # string expression p_str = "(sin(pi*x)*cos(pi*y)*sin(2*pi*t), cos(pi*x)*sin(pi*y)*sin(2*pi*t))" # string expression u_s = st.str2exp(u_str) p_s = st.str2exp(p_str) # create FEniCS expressions (fs, gs) = st.get_source_terms(u_str, p_str) # get source terms if refinement == "space": print("============= Space refinement =============") # Parameters T = 0.1 dt = 5.0e-5 # Error lists E_u = [] E_p1 = [] E_p2 = [] h = [] tau = [] E_eta1 = [] E_eta2 = [] E_eta3 = [] E_eta4 = [] # Solve for each N for N in [4, 8, 16, 32, 64]: u_h, p_h, u_e, p_e, eta, mesh = ce.compute_estimates( N, T, dt, u_s, p_s, fs, gs, params, experiment, refinement) # Compute error norms u_error = errornorm(u_e, u_h, "H1", mesh=mesh) p1_error = errornorm(p_e[0], p_h[0], "L2", mesh=mesh) p2_error = errornorm(p_e[1], p_h[1], "L2", mesh=mesh) # Append error to list E_u.append(u_error) E_p1.append(p1_error) E_p2.append(p2_error) E_eta1.append(eta[0]) E_eta2.append(eta[1]) E_eta3.append(eta[2]) E_eta4.append(eta[3]) h.append(mesh.hmin()) # Print info to terminal print("N = %.d, dt = %.1e, u: %.3e, p1: %.3e, p2: %.3e" % (N, dt, u_error, p1_error, p2_error)) print("eta1: %.3e, eta2: %.3e, eta3: %.3e, eta4: %.3e" % (eta[0], eta[1], eta[2], eta[3])) # Solution plots for each N viz_sol(u_h, "u_num_%d" % N, experiment, refinement) viz_sol(u_e, "u_exact_%d" % N, experiment, refinement) viz_sol(p_h[0], "p1_num_%d" % N, experiment, refinement) viz_sol(p_e[0], "p1_exact_%d" % N, experiment, refinement) viz_sol(p_h[1], "p2_num_%d" % N, experiment, refinement) viz_sol(p_e[1], "p2_exact_%d" % N, experiment, refinement) # Convergence rate E = dict(u=E_u, p1=E_p1, p2=E_p2, eta1=E_eta1, eta2=E_eta2, eta3=E_eta3, eta4=E_eta4) convergence_rate(E, h) # Error plots error = dict(u=E_u, p1=E_p1, p2=E_p2) plot_loglog(h, error, experiment, refinement, plotname="solution") est = dict(eta1=E_eta1, eta2=E_eta2, eta3=E_eta3, eta4=E_eta4) plot_loglog(h, est, experiment, refinement, plotname="estimator") if refinement == "time": print("============= Time refinement =============") # Parameters N = 128 T = 1.0 # Error lists E_u = [] E_p1 = [] E_p2 = [] h = [] tau = [] E_eta1 = [] E_eta2 = [] E_eta3 = [] E_eta4 = [] # Solve for each dt for dt in [0.02, 0.01, 0.005, 0.0025, 0.00125]: u_h, p_h, u_e, p_e, eta, mesh = ce.compute_estimates( N, T, dt, u_s, p_s, fs, gs, params, experiment, refinement) # Compute error norms u_error = errornorm(u_e, u_h, "H1", mesh=mesh) p1_error = errornorm(p_e[0], p_h[0], "L2", mesh=mesh) p2_error = errornorm(p_e[1], p_h[1], "L2", mesh=mesh) # Append error to list E_u.append(u_error) E_p1.append(p1_error) E_p2.append(p2_error) E_eta1.append(eta[0]) E_eta2.append(eta[1]) E_eta3.append(eta[2]) E_eta4.append(eta[3]) h.append(mesh.hmin()) tau.append(dt) # Print info to terminal print("N = %.d, dt = %.1e, u: %.3e, p1: %.3e, p2: %.3e" % (N, dt, u_error, p1_error, p2_error)) print("eta1: %.3e, eta2: %.3e, eta3: %.3e, eta4: %.3e" % (eta[0], eta[1], eta[2], eta[3])) # Solution plots for each dt viz_sol(u_h, "u_num_%.f" % dt, experiment, refinement) viz_sol(u_e, "u_exact%.f" % dt, experiment, refinement) viz_sol(p_h[0], "p1_num%.f" % dt, experiment, refinement) viz_sol(p_e[0], "p1_exact%.f" % dt, experiment, refinement) viz_sol(p_h[1], "p2_num%.f" % dt, experiment, refinement) viz_sol(p_e[1], "p2_exact%.f" % dt, experiment, refinement) # Convergence rate E = dict(u=E_u, p1=E_p1, p2=E_p2, eta4=E_eta4) convergence_rate(E, tau) # Error plots error = dict(u=E_u, p1=E_p1, p2=E_p2) plot_loglog(tau, error, experiment, refinement, plotname="solution") est = dict(eta1=E_eta1, eta2=E_eta2, eta3=E_eta3, eta4=E_eta4) plot_loglog(tau, est, experiment, refinement, plotname="estimator") if refinement == None: print("============= Time/space refinement =============") # Parameters T = 1.0 # Error lists E_u = [] E_p1 = [] E_p2 = [] h = [] tau = [] E_eta1 = [] E_eta2 = [] E_eta3 = [] E_eta4 = [] for dt in [(1. / 4)**2, (1. / 8)**2, (1. / 16)**2, (1. / 32)**2]: # Error lists E_u = [] E_p1 = [] E_p2 = [] h = [] tau = [] E_eta1 = [] E_eta2 = [] E_eta3 = [] E_eta4 = [] # Solve for each N for N in [4, 8, 16, 32]: u_h, p_h, u_e, p_e, eta, mesh = ce.compute_estimates( N, T, dt, u_s, p_s, fs, gs, params, experiment, refinement) # Compute error norms u_error = errornorm(u_e, u_h, "H1", mesh=mesh) p1_error = errornorm(p_e[0], p_h[0], "L2", mesh=mesh) p2_error = errornorm(p_e[1], p_h[1], "L2", mesh=mesh) # Append error to list E_u.append(u_error) E_p1.append(p1_error) E_p2.append(p2_error) E_eta1.append(eta[0]) E_eta2.append(eta[1]) E_eta3.append(eta[2]) E_eta4.append(eta[3]) h.append(mesh.hmin()) # Print info to terminal print( "N = %.d, dt = %.1e, u: %.3e, p1: %.3e, p2: %.3e, eta1: %.3e, eta2: %.3e, eta3: %.3e, eta4: %.3e" % (N, dt, u_error, p1_error, p2_error, eta[0], eta[1], eta[2], eta[3])) # Convergence rate error = dict(u=E_u, p1=E_p1, p2=E_p2, eta1=E_eta1, eta2=E_eta2, eta3=E_eta3, eta4=E_eta4) convergence_rate(error, h)
def run_solver(): # Input parameters T = 1.0 alpha = (1.0, 1.0, 1.0, 1.0) mu = 0.5 lamb = 1.0 c = (1.0, 1.0, 1.0, 1.0) K = (1.0, 1.0, 1.0, 1.0) xi = (1.0, 1.0, 1.0, 1.0, 1.0, 1.0) E = None nu = None #mu = E/(2.0*((1.0 + nu))) #lamb = nu*E/((1.0-2.0*nu)*(1.0+nu)) # Get source terms using sympy u_str = "(cos(pi*x)*sin(pi*y)*sin(2*pi*t), sin(pi*x)*cos(pi*y)*sin(2*pi*t))" # string expression p_str = "(sin(pi*x)*sin(pi*y)*sin(2*pi*t), sin(pi*x)*sin(pi*y)*sin(2*pi*t), \ sin(pi*x)*sin(pi*y)*sin(2*pi*t), sin(pi*x)*sin(pi*y)*sin(2*pi*t))" # string expression u_s = st.str2exp(u_str) p_s = st.str2exp(p_str) # create FEniCS expressions (fs, gs) = st.get_source_terms(u_str, p_str) # get source terms # Print parameter-info to terminal print("alpha =", alpha, "nu =", nu, "E = ", E, "mu =", mu) print("lamb = ", lamb, "c = ", c, "K =", K, "xi = ", xi) params = dict(alpha=alpha, mu=mu, lamb=lamb, c=c, K=K, xi=xi) # Error lists E_u = [] E_p1 = [] E_p2 = [] E_p3 = [] E_p4 = [] h = [] # Solve for each N for N in [4, 8, 16, 32, 64]: dt = (1. / N)**2 u_h, p_h, u_e, p_e, mesh = solver(N, T, dt, u_s, p_s, fs, gs, params) # Error norms u_error = errornorm(u_h, u_e, "H1", mesh=mesh) p1_error = errornorm(p_h[0], p_e[0], "L2", mesh=mesh) p2_error = errornorm(p_h[1], p_e[1], "L2", mesh=mesh) p3_error = errornorm(p_h[2], p_e[2], "L2", mesh=mesh) p4_error = errornorm(p_h[3], p_e[3], "L2", mesh=mesh) E_u.append(u_error) E_p1.append(p1_error) E_p2.append(p2_error) E_p3.append(p3_error) E_p4.append(p4_error) h.append(mesh.hmin()) print( "N = %.d, dt = %.3e, u_err: %.3e, p1_err: %.3e, p2_err: %.3e, p3_err: %.3e, p4_err: %.3e" % (N, dt, u_error, p1_error, p2_error, p3_error, p4_error)) # Convergence rate error = dict(u=E_u, p1=E_p1, p2=E_p2, p3=E_p3, p4=E_p4) convergence_rate(error, h)