def __eval_fexpl(self, u, t):
"""
Helper routine to evaluate the explicit part of the RHS
Args:
u: current values (not used here)
t: current time
Returns:
explicit part of RHS
"""
fexpl = mesh(self.nvars)
# Copy values of u into pyClaw state object
self.state.q[0, :, :] = u.values[0, :, :]
# Evaluate right hand side
self.solver.before_step(self.solver, self.state)
tmp = self.solver.dqdt(self.state)
fexpl.values[0, :, :] = unflatten(tmp, 1, self.nvars[1], self.nvars[2])
# Copy values of u into pyClaw state object
#self.state.q[0,:,:] = u.values[1,:,:]
# Evaluate right hand side
#tmp = self.solver.dqdt(self.state)
#fexpl.values[1,:,:] = tmp.reshape(self.nvars[1:])
return fexpl
def u_exact(self, t):
"""
Routine to compute the exact solution at time t
Args:
t: current time
Returns:
exact solution
"""
sigma_0 = 0.1
k = 7.0 * 2.0 * np.pi
x_0 = 0.75
x_1 = 0.25
ms = 0.0
if self.multiscale:
ms = 1.0
me = mesh(self.nvars)
me.values[0, :] = np.exp(
-np.square(self.mesh - x_0 - self.cs * t) /
(sigma_0 * sigma_0)) + ms * np.exp(
-np.square(self.mesh - x_1 - self.cs * t) /
(sigma_0 * sigma_0)) * np.cos(
k * (self.mesh - self.cs * t) / sigma_0)
me.values[1, :] = me.values[0, :]
return me
def solve_system(self, rhs, factor, u0, t):
"""
Simple linear solver for (I-dtA)u = rhs
Args:
rhs: right-hand side for the nonlinear system
factor: abbrev. for the node-to-node stepsize (or any other factor required)
u0: initial guess for the iterative solver (not used here so far)
t: current time (e.g. for time-dependent BCs)
Returns:
solution as mesh
"""
b = rhs.values.flatten()
# NOTE: A = -M, therefore solve Id + factor*M here
sol, info = LA.gmres(self.Id + factor * self.c_s * self.M,
b,
x0=u0.values.flatten(),
tol=1e-13,
restart=10,
maxiter=20)
me = mesh(self.nvars)
me.values = unflatten(sol, 3, self.N[0], self.N[1])
return me
def u_exact(self, t):
"""
Routine to compute the exact solution at time t
Args:
t: current time
Returns:
exact solution
"""
me = mesh(self.nvars)
me.values = np.cos(2.0 * np.pi * (self.mesh - self.c * t))
return me
def u_exact(self, t):
"""
Routine to compute the exact solution at time t
Args:
t: current time
Returns:
exact solution
"""
xc = self.state.grid.x.centers
me = mesh(self.nvars)
me.values = np.sin(2.0 * np.pi * (xc - t))
return me
def __eval_fimpl(self, u, t):
"""
Helper routine to evaluate the implicit part of the RHS
Args:
u: current values
t: current time (not used here)
Returns:
implicit part of RHS
"""
fimpl = mesh(self.nvars)
fimpl.values = self.A.dot(u.values)
return fimpl
def eval_f(self, u, t):
"""
Routine to evaluate both parts of the RHS
Args:
u: current values
t: current time
Returns:
the RHS divided into two parts
"""
f = mesh(self.nvars)
f.values = self.A.dot(u.values)
return f
def u_exact(self, t):
"""
Routine to compute the exact solution at time t
Args:
t: current time
Returns:
exact solution
"""
me = mesh(self.nvars)
me.values[0, :, :] = np.sin(2 * np.pi * self.xc) * np.sin(
2 * np.pi * self.yc)
#me.values[1,:,:] = np.sin(2*np.pi*self.xc)#*np.sin(2*np.pi*self.yc)
return me
def u_exact(self,t):
"""
Routine to compute the exact solution at time t
Args:
t: current time
Returns:
exact solution
"""
me = mesh(self.nvars)
me.values[0,:,:] = 0.0*self.xx
me.values[1,:,:] = 0.0*self.xx
#me.values[2,:,:] = 0.5*np.exp(-0.5*( self.xx-self.c_s*t - self.u_adv*t )**2/0.2**2.0) + 0.5*np.exp(-0.5*( self.xx + self.c_s*t - self.u_adv*t)**2/0.2**2.0)
me.values[2,:,:] = np.exp(-0.5*(self.xx-0.0)**2.0/0.15**2.0)*np.exp(-0.5*(self.zz-0.5)**2/0.15**2)
return me
def prolong_space(self,G):
"""
Prolongation implementation
Args:
G: the coarse level data (easier to access than via the coarse attribute)
"""
if isinstance(G,mesh):
u_fine = mesh(self.init_c,val=0)
u_fine.values = self.Pspace.dot(G.values)
elif isinstance(G,rhs_imex_mesh):
u_fine = rhs_imex_mesh(self.init_c)
u_fine.impl.values = self.Pspace.dot(G.impl.values)
u_fine.expl.values = self.Pspace.dot(G.expl.values)
return u_fine
def restrict_space(self,F):
"""
Restriction implementation
Args:
F: the fine level data (easier to access than via the fine attribute)
"""
if isinstance(F,mesh):
u_coarse = mesh(self.init_c,val=0)
u_coarse.values = self.Rspace.dot(F.values)
elif isinstance(F,rhs_imex_mesh):
u_coarse = rhs_imex_mesh(self.init_c)
u_coarse.impl.values = self.Rspace.dot(F.impl.values)
u_coarse.expl.values = self.Rspace.dot(F.expl.values)
return u_coarse
def solve_system(self, rhs, factor, u0, t):
"""
Simple linear solver for (I-dtA)u = rhs
Args:
rhs: right-hand side for the nonlinear system
factor: abbrev. for the node-to-node stepsize (or any other factor required)
u0: initial guess for the iterative solver (not used here so far)
t: current time (e.g. for time-dependent BCs)
Returns:
solution as mesh
"""
me = mesh(self.nvars)
me.values = LA.spsolve(
sp.eye(self.nvars) - factor * self.A, rhs.values)
return me
def __eval_fexpl(self, u, t):
"""
Helper routine to evaluate the explicit part of the RHS
Args:
u: current values (not used here)
t: current time
Returns:
explicit part of RHS
"""
b = np.concatenate((u.values[0, :], u.values[1, :]))
sol = self.Dx.dot(b)
fexpl = mesh(self.nvars)
fexpl.values[0, :], fexpl.values[1, :] = np.split(sol, 2)
return fexpl
def __eval_fimpl(self, u, t):
"""
Helper routine to evaluate the implicit part of the RHS
Args:
u: current values
t: current time (not used here)
Returns:
implicit part of RHS
"""
b = np.concatenate((u.values[0, :], u.values[1, :]))
sol = self.A.dot(b)
fimpl = mesh(self.nvars, val=0.0)
fimpl.values[0, :], fimpl.values[1, :] = np.split(sol, 2)
return fimpl
def __eval_fimpl(self,u,t):
"""
Helper routine to evaluate the implicit part of the RHS
Args:
u: current values
t: current time (not used here)
Returns:
implicit part of RHS
"""
temp = u.values.flatten()
temp = self.M.dot(temp)
fimpl = mesh(self.nvars,val=0.0)
# NOTE: M = -A, therefore add a minus here
fimpl.values = unflatten(-self.c_s*temp, 3, self.N[0], self.N[1])
return fimpl
def __eval_fexpl(self, u, t):
"""
Helper routine to evaluate the explicit part of the RHS
Args:
u: current values (not used here)
t: current time
Returns:
explicit part of RHS
"""
# Copy values of u into pyClaw state object
self.state.q[0, :] = u.values
# Evaluate right hand side
fexpl = mesh(self.nvars)
fexpl.values = self.solver.dqdt(self.state)
return fexpl
def __eval_fexpl(self,u,t):
"""
Helper routine to evaluate the explicit part of the RHS
Args:
u: current values (not used here)
t: current time
Returns:
explicit part of RHS
"""
# Evaluate right hand side
fexpl = mesh(self.nvars)
temp = u.values.flatten()
temp = self.D_upwind.dot(temp)
# NOTE: M_adv = -D_upwind, therefore add a minus here
fexpl.values = unflatten(-self.u_adv*temp, 3, self.N[0], self.N[1])
#fexpl.values = np.zeros((3, self.N[0], self.N[1]))
return fexpl
def solve_system(self, rhs, factor, u0, t):
"""
Simple linear solver for (I-dtA)u = rhs
Args:
rhs: right-hand side for the nonlinear system
factor: abbrev. for the node-to-node stepsize (or any other factor required)
u0: initial guess for the iterative solver (not used here so far)
t: current time (e.g. for time-dependent BCs)
Returns:
solution as mesh
"""
M = self.Id - factor * self.A
b = np.concatenate((rhs.values[0, :], rhs.values[1, :]))
sol = LA.spsolve(M, b)
me = mesh(self.nvars)
me.values[0, :], me.values[1, :] = np.split(sol, 2)
return me
