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