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, experiment, mms_test, refinement):
# Get source terms using sympy
if mms_test == 1:
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)"
if mms_test == 2:
u_str = "(x*(x-1)*sin(pi*x)*cos(pi*y)*sin(pi*t), y*(y-1)*sin(pi*x)*cos(pi*y)*sin(pi*t))" # string expression
p_str = "sin(pi*x)*sin(pi*y)*sin(pi*t)"
if mms_test == 3:
u_str = "(t*t*sin(pi*x)*sin(2*pi*y), t*sin(3*pi*x)*sin(4*pi*y))"
p_str = "t*exp(1-t)*x*y*(1-x)*(1-y)"
if mms_test == 4:
A = 2 * pi**2 * K / (alpha + c)
u_str = "(-exp(-%.5f*t)*(1/2*pi)*cos(pi*x)*sin(pi*y), -exp(-%.5f*t)*(1/2*pi)**sin(pi*x)*cos(pi*y))" % (
A, A)
p_str = "exp(-%.5f*t)*sin(pi*x)*sin(pi*y)*sin(pi*t)" % A
u_s = st.str2expr(u_str)
p_s = st.str2expr(p_str) # create FEniCS expressions
(fs, gs) = st.get_source_terms(u_str, p_str) # get source terms
# Error lists
E_u = []
E_p = []
h = []
tau = []
E_eta1 = []
E_eta2 = []
E_eta3 = []
E_eta4 = []
if refinement == "space":
print "============= Space refinement ============="
# Parameters
T = 0.1
dt = 5.0e-5
# Solve for each N
for N in [4, 8, 16, 32, 64]:
u_h, p_h, u_e, p_e, eta, mesh = solver(N, T, dt, u_s, p_s, fs, gs,
params, experiment,
refinement)
# Error norms
u_error = errornorm(u_e, u_h, "H1")
p_error = errornorm(p_e, p_h, "L2")
# Append error to list
E_u.append(u_error)
E_p.append(p_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, p: %.3e" % (N, dt, u_error,
p_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, "p_num_%d" % N, experiment, refinement)
viz_sol(p_e, "p_exact_%d" % N, experiment, refinement)
# Convergence rate
E = dict(u=E_u,
p=E_p,
eta1=E_eta1,
eta2=E_eta2,
eta3=E_eta3,
eta4=E_eta4)
convergence_rate(E, h)
# Error plots
error = dict(u=E_u, p=E_p)
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
# 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 = solver(N, T, dt, u_s, p_s, fs, gs,
params, experiment,
refinement)
# Error norms
u_error = errornorm(u_e, u_h, "H1")
p_error = errornorm(p_e, p_h, "L2")
# Append error to list
E_u.append(u_error)
E_p.append(p_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, p: %.3e" % (N, dt, u_error,
p_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, "p_num%.f" % dt, experiment, refinement)
viz_sol(p_e, "p_exact%.f" % dt, experiment, refinement)
# Convergence rate
E = dict(u=E_u, p=E_p, eta4=E_eta4)
convergence_rate(E, tau)
# Error plots
error = dict(u=E_u, p=E_p)
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
for dt in [(1. / 4)**2, (1. / 8)**2, (1. / 16)**2, (1. / 32)**2]:
# Error lists
E_u = []
E_p = []
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 = solver(N, T, dt, u_s, p_s, fs,
gs, params, experiment,
refinement)
# Error norms
u_error = errornorm(u_e, u_h, "H1")
p_error = errornorm(p_e, p_h, "L2")
# Append error to list
E_u.append(u_error)
E_p.append(p_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, p: %.3e, eta1: %.3e, eta2: %.3e, eta3: %.3e, eta4: %.3e" % (
N, dt, u_error, p_error, eta[0], eta[1], eta[2], eta[3])
# Convergence rate
error = dict(u=E_u,
p=E_p,
eta1=E_eta1,
eta2=E_eta2,
eta3=E_eta3,
eta4=E_eta4)
convergence_rate(error, 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(mms_test=1, refinement="space"): # Input parameters alpha = 1.0 mu = 0.5 lamb = 1000.0 c = 0.001 K = 0.0001 alpha = 0.75 nu = 0.4 E = 7./20 mu = E/(2.0*((1.0 + nu))) lamb = nu*E/((1.0-2.0*nu)*(1.0+nu)) c = 3./28 K = 0.05 # Get source terms using sympy if mms_test == 1: 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(pi*t)" if mms_test == 2: u_str = "(x*(x-1)*sin(pi*x)*cos(pi*y)*sin(pi*t), y*(y-1)*sin(pi*x)*cos(pi*y)*sin(pi*t))" # string expression p_str = "sin(pi*x)*sin(pi*y)*sin(pi*t)" if mms_test == 3: u_str = "(t*t*sin(pi*x)*sin(2*pi*y), t*sin(3*pi*x)*sin(4*pi*y))" p_str = "t*exp(1-t)*x*y*(1-x)*(1-y)" if mms_test == 4: A = 2*pi**2*K/(alpha + c) u_str = "(-exp(-%.5f*t)*(1/2*pi)*cos(pi*x)*sin(pi*y), -exp(-%.5f*t)*(1/2*pi)**sin(pi*x)*cos(pi*y))" % (A,A) p_str = "exp(-%.5f*t)*sin(pi*x)*sin(pi*y)*sin(pi*t)" % A u_s = st.str2expr(u_str); p_s = st.str2expr(p_str) # create FEniCS expressions (fs, gs) = st.get_source_terms(u_str, p_str) # get source terms # Print parameter-info to terminal print "mu = %.2f, lamb = %.2f, c = %.e, K = %.e" % (mu, lamb, c, K) # Error lists E_u = []; E_p = []; h = []; tau = [] E_eta1 = []; E_eta2 = []; E_eta3 = []; E_eta4 = [] if refinement=="space": print "============= Space refinement =============" # Parameters T = 1.0 dt = 5.0e-5 # Solve for each N for N in [4,8,16,32]: u_h, p_h, u_e, p_e, eta, mesh = solver(N, T, dt, u_s, p_s, fs, gs, alpha, mu, lamb, c, K) # Error norms u_error = errornorm(u_e, u_h, "H1") p_error = errornorm(p_e, p_h, "L2") # Append error to list E_u.append(u_error); E_p.append(p_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, p: %.3e, eta1: %.3e, eta2: %.3e, eta3: %.3e, eta4: %.3e" % (N, dt, u_error, p_error, eta[0], eta[1], eta[2], eta[3]) # Convergence rate error = dict(u=E_u, p=E_p, eta1=E_eta1, eta2=E_eta2, eta3=E_eta3, eta4=E_eta4) convergence_rate(error, h) # Solution plots #viz_solution(u_h, "u_num") #viz_solution(u_e, "u_exact") #viz_solution(u_h, "p_num") #viz_solution(u_e, "p_exact") # Error plots error_plots(h, E_u, E_p, refinement="space") if refinement == "time": print "============= Time refinement =============" # Parameters N = 128 T = 1.0 # Solve for each dt for dt in [0.2, 0.1, 0.02, 0.01, 0.001, 0.0001]: u_h, p_h, u_e, p_e, eta, mesh = solver(N, T, dt, u_s, p_s, fs, gs, alpha, mu, lamb, c, K) # Error norms u_error = errornorm(u_e, u_h, "H1") p_error = errornorm(p_e, p_h, "L2") # Append error to list E_u.append(u_error); E_p.append(p_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, p: %.3e, eta4: %.3e" % (N, dt, u_error, p_error, eta[3]) # Convergence rate error = dict(u=E_u, p=E_p, eta4=E_eta4) convergence_rate(error, tau) # Error plots error_plots(h, E_u, E_p, refinement="time")
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(mms_test=1):
# Input parameters
T = 1.0
alpha = 1.0
nu = 1. / 3
E = 4. / 3
mu = E / (2.0 * ((1.0 + nu)))
lamb = nu * E / ((1.0 - 2.0 * nu) * (1.0 + nu))
c = 1.0
K = 1.0
# Get source terms using sympy
if mms_test == 1:
u_str = "(x*(x-1)*sin(pi*x)*cos(pi*y)*sin(pi*t), y*(y-1)*sin(pi*x)*cos(pi*y)*sin(pi*t))" # string expression
p_str = "sin(pi*x)*sin(pi*y)*sin(pi*t)"
if mms_test == 2:
u_str = "(t*t*sin(pi*x)*sin(2*pi*y), t*sin(3*pi*x)*sin(4*pi*y))"
p_str = "t*exp(1-t)*x*y*(1-x)*(1-y)"
if mms_test == 3:
u_str = "(0.0,0.0)"
p_str = "x*y*(1-x)*(1-y)"
u_s = st.str2expr(u_str)
p_s = st.str2expr(p_str) # create FEniCS expressions
(fs, gs) = st.get_source_terms(u_str, p_str) # get source terms
# Print parameter-info to terminal
print "mu = %.2f, lamb = %.2f, c = %.e, K = %.e" % (mu, lamb, c, K)
# Error lists
E_u = []
E_p = []
h = []
# Solve for each N
for N in [4, 8, 16, 32]:
dt = (1. / N)**2
u_h, p_h, u_e, p_e, mesh = solver(N, T, dt, u_s, p_s, fs, gs, alpha,
mu, lamb, c, K, mms_test)
# Error norms
u_error = errornorm(u_e, u_h, "H1")
p_error = errornorm(p_e, p_h, "L2")
E_u.append(u_error)
E_p.append(p_error)
h.append(mesh.hmin())
print "N = %.d, dt = %.1e, u_error: %.3e, p_error: %.3e" % (
N, dt, u_error, p_error)
# Convergence rate
convergence_rate(E_u, E_p, h)
# Solution plots
viz_solution(u_h, "u_num")
viz_solution(u_e, "u_exact")
viz_solution(p_h, "p_num")
viz_solution(p_e, "p_exact")
# Error plots
error_plots(h, E_u, E_p)
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)
