def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = ['Tend'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # invoke super init, passing number of dofs, dtype_u and dtype_f super(heat1d_forced_time, self).__init__(problem_params, dtype_u, dtype_f) self.xvalues = np.array( [i * self.dx for i in range(self.params.nvars)]) self.tn = 0.0 self.tnp = 0.0 pass
def __init__(self, problem_params, dtype_u=particles, dtype_f=acceleration): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: particle data type (will be passed parent class) dtype_f: acceleration data type (will be passed parent class) """ if 'sun_only' not in problem_params: problem_params['sun_only'] = False # these parameters will be used later, so assert their existence essential_keys = [] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # invoke super init, passing nparts, dtype_u and dtype_f super(outer_solar_system, self).__init__((3, 6), dtype_u, dtype_f, problem_params) # gravitational constant self.G = 2.95912208286E-4
def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = ['nvars', 'nu', 'freq'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % (key, str(problem_params.keys())) raise ParameterError(msg) # make sure parameters have the correct form if problem_params['freq'] >= 0 and problem_params['freq'] % 2 != 0: raise ProblemError('need even number of frequencies due to periodic BCs') if problem_params['nvars'] % 2 != 0: raise ProblemError('the setup requires nvars = 2^p per dimension') # invoke super init, passing number of dofs, dtype_u and dtype_f super(heat1d_periodic, self).__init__(init=problem_params['nvars'], dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) # compute dx (equal in both dimensions) and get discretization matrix A self.dx = 1.0 / self.params.nvars self.A = self.__get_A(self.params.nvars, self.params.nu, self.dx)
def predict(self): """ Predictor to fill values at nodes before first sweep Default prediction for the sweepers, only copies the values to all collocation nodes and evaluates the RHS of the ODE there """ # get current level and problem description L = self.level P = L.prob # evaluate RHS at left point L.f[0] = P.eval_f(L.u[0], L.time) for m in range(1, self.coll.num_nodes + 1): # copy u[0] to all collocation nodes, evaluate RHS if self.params.initial_guess == 'spread': L.u[m] = P.dtype_u(L.u[0]) L.f[m] = P.eval_f(L.u[m], L.time + L.dt * self.coll.nodes[m - 1]) # start with zero everywhere elif self.params.initial_guess == 'zero': L.u[m] = P.dtype_u(init=P.init, val=0.0) L.f[m] = P.dtype_f(init=P.init, val=0.0) else: raise ParameterError( f'initial_guess option {self.params.initial_guess} not implemented' ) # indicate that this level is now ready for sweeps L.status.unlocked = True L.status.updated = True
def __init__(self, problem_params, dtype_u=particles, dtype_f=acceleration): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: particle data type (will be passed to parent class) dtype_f: acceleration data type (will be passed to parent class) """ # these parameters will be used later, so assert their existence essential_keys = ['k', 'phase', 'amp'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # invoke super init, passing nparts, dtype_u and dtype_f super(harmonic_oscillator, self).__init__(1, dtype_u, dtype_f, problem_params) if self.params.phase != 0.0: raise ProblemError('Phase != 0 not implemented yet') if self.params.amp != 1.0: raise ProblemError('amp != 1 not implemented yet')
def __init__(self, problem_params, dtype_u=particles, dtype_f=acceleration): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: particle data type (will be passed to parent class) dtype_f: acceleration data type (will be passed to parent class) """ # these parameters will be used later, so assert their existence essential_keys = ['npart', 'alpha', 'k', 'energy_modes'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # invoke super init, passing nparts, dtype_u and dtype_f super(fermi_pasta_ulam_tsingou, self).__init__(problem_params['npart'], dtype_u, dtype_f, problem_params)
def __init__(self, problem_params, dtype_u=mesh, dtype_f=rhs_comp2_mesh): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = [ 'nvars', 'dw', 'eps', 'newton_maxiter', 'newton_tol', 'interval', 'radius' ] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on if (problem_params['nvars']) % 2 != 0: raise ProblemError('setup requires nvars = 2^p') if 'stop_at_nan' not in problem_params: problem_params['stop_at_nan'] = True # invoke super init, passing number of dofs, dtype_u and dtype_f super(allencahn_periodic_multiimplicit, self).__init__(problem_params, dtype_u, dtype_f) self.A -= sp.eye(self.init) * 0.0 / self.params.eps**2
def __init__(self, params): """ Initialization routine for the base sweeper Args: params (dict): parameter object """ # set up logger self.logger = logging.getLogger('sweeper') essential_keys = ['collocation_class', 'num_nodes'] for key in essential_keys: if key not in params: msg = 'need %s to instantiate step, only got %s' % ( key, str(params.keys())) self.logger.error(msg) raise ParameterError(msg) self.params = _Pars(params) coll = params['collocation_class'](params['num_nodes'], 0, 1) if not coll.right_is_node and not self.params.do_coll_update: self.logger.warning( 'we need to do a collocation update here, since the right end point is not a node. ' 'Changing this!') self.params.do_coll_update = True # This will be set as soon as the sweeper is instantiated at the level self.__level = None # collocation object self.coll = coll
def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type for solution dtype_f: mesh data type for RHS """ # these parameters will be used later, so assert their existence essential_keys = ['lambdas', 'u0'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) assert not any(isinstance(i, list) for i in problem_params['lambdas']), \ 'ERROR: expect flat list here, got %s' % problem_params['lambdas'] problem_params['nvars'] = len(problem_params['lambdas']) assert problem_params[ 'nvars'] > 0, 'ERROR: expect at least one lambda parameter here' # invoke super init, passing number of dofs, dtype_u and dtype_f super(testequation0d, self).__init__(init=problem_params['nvars'], dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) self.A = self.__get_A(self.params.lambdas)
def __init__(self, problem_params, dtype_u, dtype_f, t): """ Initialization routine Args: problem_params (dict): custom parameters for the example """ # these parameters will be used later, so assert their existence essential_keys = ['lam', 'nvars'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) self.lam = problem_params['lam'] self.nvars = problem_params['nvars'] self.dx = 1.0 / (self.nvars - 1) self.xvalues = np.array([i * self.dx for i in range(self.nvars)]) #print(self.xvalues) self.A = self.__get_A(self.nvars, self.dx) # nu wird so gewaehlt, dass die rechte Seite nu/(dx^2)*A den Eigenwert lambda hat self.nu = -self.lam / max(abs(np.linalg.eigvals(self.A))) self.A *= self.nu self.rhs_mat = self.A self.u0 = self.u_exact(t * 0) self.M = len(t)
def __init__(self, problem_params, dtype_u=mesh, dtype_f=mesh): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type for solution dtype_f: mesh data type for RHS """ # these parameters will be used later, so assert their existence essential_keys = ['nvars', 'nu', 'freq'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on if (problem_params['nvars'] + 1) % 2 != 0: raise ProblemError('setup requires nvars = 2^p - 1') # invoke super init, passing number of dofs, dtype_u and dtype_f super(heat1d, self).__init__(init=problem_params['nvars'], dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) # compute dx and get discretization matrix A self.dx = 1.0 / (self.params.nvars + 1) self.A = self.__get_A(self.params.nvars, self.params.nu, self.dx)
def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data dtype_f: mesh data with two components """ # these parameters will be used later, so assert their existence essential_keys = ['nvars', 'cs', 'cadv', 'order_adv', 'waveno'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # invoke super init, passing number of dofs, dtype_u and dtype_f super(acoustic_1d_imex, self).__init__(problem_params['nvars'], dtype_u, dtype_f, problem_params) self.mesh = np.linspace(0.0, 1.0, self.params.nvars[1], endpoint=False) self.dx = self.mesh[1] - self.mesh[0] self.Dx = -self.params.cadv * getWave1DAdvectionMatrix( self.params.nvars[1], self.dx, self.params.order_adv) self.Id, A = getWave1DMatrix(self.params.nvars[1], self.dx, ['periodic', 'periodic'], ['periodic', 'periodic']) self.A = -self.params.cs * A
def __init__(self, problem_params, dtype_u, dtype_f, t): """ Initialization routine Args: problem_params (dict): custom parameters for the example """ # these parameters will be used later, so assert their existence essential_keys = ['lam', 'nvars'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) #if problem_params['nvars'] != 1: # raise ProblemError('nvars for TestEquation should be 1!') # invoke super init, passing number of dofs, dtype_u and dtype_f super(Test, self).__init__(init=1, dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) self.lam = self.params.lam self.rhs_mat = self.lam self.u0 = np.ones(len(t), dtype=dtype_u) self.M = len(t)
def __init__(self, problem_params, dtype_u=mesh, dtype_f=mesh): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = ['u0', 'mu', 'newton_maxiter', 'newton_tol'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) problem_params['nvars'] = 2 if 'stop_at_nan' not in problem_params: problem_params['stop_at_nan'] = True # invoke super init, passing dtype_u and dtype_f, plus setting number of elements to 2 super(vanderpol, self).__init__(problem_params['nvars'], dtype_u, dtype_f, problem_params)
def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = [ 'nvars', 'nu', 'lambda0', 'newton_maxiter', 'newton_tol', 'interval' ] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on if (problem_params['nvars'] + 1) % 2 != 0: raise ProblemError('setup requires nvars = 2^p - 1') # invoke super init, passing number of dofs, dtype_u and dtype_f super(generalized_fisher, self).__init__(problem_params['nvars'], dtype_u, dtype_f, problem_params) # compute dx and get discretization matrix A self.dx = (self.params.interval[1] - self.params.interval[0]) / (self.params.nvars + 1) self.A = self.__get_A(self.params.nvars, self.dx)
def __init__(self, problem_params, dtype_u=mesh, dtype_f=rhs_imex_mesh): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed to parent class) dtype_f: mesh data type wuth implicit and explicit parts (will be passed to parent class) """ if 'L' not in problem_params: problem_params['L'] = 1.0 if 'init_type' not in problem_params: problem_params['init_type'] = 'circle' # these parameters will be used later, so assert their existence essential_keys = ['nvars', 'nu', 'eps', 'L', 'radius'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on if len(problem_params['nvars']) != 2: raise ProblemError('this is a 2d example, got %s' % problem_params['nvars']) if problem_params['nvars'][0] != problem_params['nvars'][1]: raise ProblemError('need a square domain, got %s' % problem_params['nvars']) if problem_params['nvars'][0] % 2 != 0: raise ProblemError('the setup requires nvars = 2^p per dimension') # invoke super init, passing number of dofs, dtype_u and dtype_f super(allencahn2d_imex, self).__init__(init=problem_params['nvars'], dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) self.dx = self.params.L / self.params.nvars[ 0] # could be useful for hooks, too. self.xvalues = np.array([ i * self.dx - self.params.L / 2.0 for i in range(self.params.nvars[0]) ]) kx = np.zeros(self.init[0]) ky = np.zeros(self.init[1] // 2 + 1) kx[:int(self.init[0] / 2) + 1] = 2 * np.pi / self.params.L * np.arange( 0, int(self.init[0] / 2) + 1) kx[int(self.init[0] / 2) + 1:] = 2 * np.pi / self.params.L * \ np.arange(int(self.init[0] / 2) + 1 - self.init[0], 0) ky[:] = 2 * np.pi / self.params.L * np.arange(0, self.init[1] // 2 + 1) xv, yv = np.meshgrid(kx, ky, indexing='ij') self.lap = -xv**2 - yv**2
def __init__(self, problem_params, dtype_u=fenics_mesh, dtype_f=rhs_fenics_mesh): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: FEniCS mesh data type (will be passed to parent class) dtype_f: FEniCS mesh data data type with implicit and explicit parts (will be passed to parent class) """ # define the Dirichlet boundary # def Boundary(x, on_boundary): # return on_boundary # these parameters will be used later, so assert their existence essential_keys = ['c_nvars', 't0', 'family', 'order', 'refinements', 'nu'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % (key, str(problem_params.keys())) raise ParameterError(msg) # set logger level for FFC and dolfin logging.getLogger('FFC').setLevel(logging.WARNING) logging.getLogger('UFL').setLevel(logging.WARNING) # set solver and form parameters df.parameters["form_compiler"]["optimize"] = True df.parameters["form_compiler"]["cpp_optimize"] = True df.parameters['allow_extrapolation'] = True # set mesh and refinement (for multilevel) mesh = df.UnitIntervalMesh(problem_params['c_nvars']) for i in range(problem_params['refinements']): mesh = df.refine(mesh) # define function space for future reference self.V = df.FunctionSpace(mesh, problem_params['family'], problem_params['order']) tmp = df.Function(self.V) print('DoFs on this level:', len(tmp.vector()[:])) # invoke super init, passing number of dofs, dtype_u and dtype_f super(fenics_heat, self).__init__(self.V, dtype_u, dtype_f, problem_params) # Stiffness term (Laplace) u = df.TrialFunction(self.V) v = df.TestFunction(self.V) a_K = -1.0 * df.inner(df.nabla_grad(u), self.params.nu * df.nabla_grad(v)) * df.dx # Mass term a_M = u * v * df.dx self.M = df.assemble(a_M) self.K = df.assemble(a_K) # set forcing term as expression self.g = df.Expression('-cos(a*x[0]) * (sin(t) - b*a*a*cos(t))', a=np.pi, b=self.params.nu, t=self.params.t0, degree=self.params.order)
def __init__(self, problem_params, dtype_u=dedalus_field, dtype_f=rhs_imex_dedalus_field): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ if 'comm' not in problem_params: problem_params['comm'] = None # these parameters will be used later, so assert their existence essential_keys = ['nvars', 'nu', 'freq', 'comm'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on if problem_params['freq'] % 2 != 0: raise ProblemError('setup requires freq to be an equal number') xbasis = de.Fourier('x', problem_params['nvars'][0], interval=(0, 1), dealias=1) ybasis = de.Fourier('y', problem_params['nvars'][1], interval=(0, 1), dealias=1) domain = de.Domain([xbasis, ybasis], grid_dtype=np.float64, comm=problem_params['comm']) # invoke super init, passing number of dofs, dtype_u and dtype_f super(heat2d_dedalus_forced, self).__init__(init=domain, dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) self.x = self.init.grid(0, scales=1) self.y = self.init.grid(1, scales=1) self.rhs = self.dtype_u(self.init, val=0.0) self.problem = de.IVP(domain=self.init, variables=['u']) self.problem.parameters['nu'] = self.params.nu self.problem.add_equation( "dt(u) - nu * dx(dx(u)) - nu * dy(dy(u)) = 0") self.solver = self.problem.build_solver(de.timesteppers.SBDF1) self.u = self.solver.state['u']
def __init__(self, num_nodes, tleft, tright): """ Initialization Args: num_nodes: number of nodes tleft (float): left interval boundary (usually 0) tright (float): right interval boundary (usually 1) """ if type(num_nodes) is int: max_d = 15 nnodes = num_nodes else: if type(num_nodes) is not tuple: raise ParameterError('Expecting int or tuple for num_nodes parameter, got %s' % type(num_nodes)) if len(num_nodes) != 2: raise ParameterError('Expecting 1 or 2 arguments for num_nodes, got %s' % num_nodes) if type(num_nodes[0]) is not int: raise ParameterError('Expecting int type for first num_nodes argument, got %s' % type(num_nodes[0])) if type(num_nodes[1]) is not int: raise ParameterError('Expecting int type for second num_nodes argument, got %s' % type(num_nodes[1])) max_d = num_nodes[1] nnodes = num_nodes[0] if nnodes < 2: raise CollocationError("Number of nodes should be at least 2 for equidistant, but is %d" % num_nodes) super(Equidistant, self).__init__(nnodes, tleft, tright) self.order = self.num_nodes self.nodes = self._getNodes d = min(self.num_nodes - 1, max_d) self.fh_weights = self._getFHWeights(d) self.weights = self._getWeights(tleft, tright) self.Qmat = self._gen_Qmatrix self.Smat = self._gen_Smatrix self.delta_m = self._gen_deltas self.left_is_node = True self.right_is_node = True
def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ if 'L' not in problem_params: problem_params['L'] = 1.0 # these parameters will be used later, so assert their existence essential_keys = ['nvars', 'c', 'freq', 'nu', 'L'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on if (problem_params['nvars']) % 2 != 0: raise ProblemError('setup requires nvars = 2^p') # invoke super init, passing number of dofs, dtype_u and dtype_f super(advectiondiffusion1d_imex, self).__init__(init=problem_params['nvars'], dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) self.xvalues = np.array([ i * self.params.L / self.params.nvars - self.params.L / 2.0 for i in range(self.params.nvars) ]) kx = np.zeros(self.init // 2 + 1) for i in range(0, len(kx)): kx[i] = 2 * np.pi / self.params.L * i self.ddx = kx * 1j self.lap = -kx**2 rfft_in = pyfftw.empty_aligned(self.init, dtype='float64') fft_out = pyfftw.empty_aligned(self.init // 2 + 1, dtype='complex128') ifft_in = pyfftw.empty_aligned(self.init // 2 + 1, dtype='complex128') irfft_out = pyfftw.empty_aligned(self.init, dtype='float64') self.rfft_object = pyfftw.FFTW(rfft_in, fft_out, direction='FFTW_FORWARD') self.irfft_object = pyfftw.FFTW(ifft_in, irfft_out, direction='FFTW_BACKWARD')
def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ # these parameters will be used later, so assert their existence if 'comm' not in problem_params: problem_params['comm'] = PETSc.COMM_WORLD if 'sol_tol' not in problem_params: problem_params['sol_tol'] = 1E-10 if 'sol_maxiter' not in problem_params: problem_params['sol_maxiter'] = None essential_keys = ['nvars', 'nu', 'freq', 'comm'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % (key, str(problem_params.keys())) raise ParameterError(msg) # make sure parameters have the correct form if len(problem_params['nvars']) != 2: raise ProblemError('this is a 2d example, got %s' % problem_params['nvars']) # create DMDA object which will be used for all grid operations da = PETSc.DMDA().create([problem_params['nvars'][0], problem_params['nvars'][1]], stencil_width=1, comm=problem_params['comm']) # invoke super init, passing number of dofs, dtype_u and dtype_f super(heat2d_petsc_forced, self).__init__(init=da, dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) # compute dx, dy and get local ranges self.dx = 1.0 / (self.params.nvars[0] - 1) self.dy = 1.0 / (self.params.nvars[1] - 1) (self.xs, self.xe), (self.ys, self.ye) = self.init.getRanges() # compute discretization matrix A and identity self.A = self.__get_A() self.Id = self.__get_Id() # setup solver self.ksp = PETSc.KSP() self.ksp.create(comm=self.params.comm) self.ksp.setType('cg') pc = self.ksp.getPC() pc.setType('none') self.ksp.setInitialGuessNonzero(True) self.ksp.setFromOptions() self.ksp.setTolerances(rtol=self.params.sol_tol, atol=self.params.sol_tol, max_it=self.params.sol_maxiter)
def __init__(self, problem_params, dtype_u=parallel_mesh, dtype_f=parallel_comp2_mesh): """ Init routine for the multi-implicit problem class with linear splitting """ if 'newton_maxiter' not in problem_params: raise ParameterError( 'need newton_maxiter as parameter for the problem class') if 'newton_tol' not in problem_params: raise ParameterError( 'need newton_tol as parameter for the problem class') super(grayscott_mi_linear, self).__init__(problem_params, dtype_u=dtype_u, dtype_f=dtype_f) # This may not run in parallel yet.. assert self.params.comm.Get_size() == 1
def __init__(self, problem_params, dtype_u=mesh, dtype_f=mesh): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = [ 'nvars', 'D0', 'D1', 'f', 'k', 'newton_maxiter', 'newton_tol', 'lin_tol', 'lin_maxiter' ] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on #if len(problem_params['nvars']) != 2: # raise ProblemError('this is a 2d example, got %s' % problem_params['nvars']) #if problem_params['nvars'][0] != 2*problem_params['nvars'][1]: # raise ProblemError('nvars is not compatible with system, got %s' % problem_params['nvars']) #if problem_params['nvars'][0] % 2 != 0: # raise ProblemError('the setup requires nvars = 2^p per dimension') # invoke super init, passing number of dofs, dtype_u and dtype_f super(grayscott_fullyimplicit, self).__init__(problem_params['nvars'], dtype_u, dtype_f, problem_params) # compute dx and get discretization matrix A #self.nv = self.params.nvars[1] self.dx = 1. / self.params.nvars[ 1] ################################################################################## #print(self.dx) #exit() self.A = self.__get_A(self.params.nvars, self.dx) self.xvalues = np.array( [i * self.dx for i in range(self.params.nvars[1])]) self.newton_itercount = 0 self.lin_itercount = 0 self.newton_ncalls = 0 self.lin_ncalls = 0 self.warning_count = 0 self.linear_count = 0 self.time_for_solve = 0
def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: particle data type (will be passed parent class) dtype_f: acceleration data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = [ 'nvars', 'c_s', 'u_adv', 'Nfreq', 'x_bounds', 'z_bounds', 'order_upw', 'order', 'gmres_maxiter', 'gmres_restart', 'gmres_tol_limit' ] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # invoke super init, passing number of dofs, dtype_u and dtype_f super(boussinesq_2d_imex, self).__init__(problem_params['nvars'], dtype_u, dtype_f, problem_params) self.N = [self.params.nvars[1], self.params.nvars[2]] self.bc_hor = [['periodic', 'periodic'], ['periodic', 'periodic'], ['periodic', 'periodic'], ['periodic', 'periodic']] self.bc_ver = [['neumann', 'neumann'], ['dirichlet', 'dirichlet'], ['dirichlet', 'dirichlet'], ['neumann', 'neumann']] self.xx, self.zz, self.h = get2DMesh(self.N, self.params.x_bounds, self.params.z_bounds, self.bc_hor[0], self.bc_ver[0]) self.Id, self.M = getBoussinesq2DMatrix(self.N, self.h, self.bc_hor, self.bc_ver, self.params.c_s, self.params.Nfreq, self.params.order) self.D_upwind = getBoussinesq2DUpwindMatrix(self.N, self.h[0], self.params.u_adv, self.params.order_upw) self.gmres_logger = logging()
def __init__(self, problem_params, dtype_u=mesh, dtype_f=mesh): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = [ 'nvars', 'dw', 'eps', 'newton_maxiter', 'newton_tol', 'interval', 'radius' ] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on if (problem_params['nvars']) % 2 != 0: raise ProblemError('setup requires nvars = 2^p') if 'stop_at_nan' not in problem_params: problem_params['stop_at_nan'] = True # invoke super init, passing number of dofs, dtype_u and dtype_f super(allencahn_periodic_fullyimplicit, self).__init__(problem_params['nvars'], dtype_u, dtype_f, problem_params) # compute dx and get discretization matrix A self.dx = (self.params.interval[1] - self.params.interval[0]) / self.params.nvars self.xvalues = np.array([ self.params.interval[0] + i * self.dx for i in range(self.params.nvars) ]) self.A = self.__get_A(self.params.nvars, self.dx) self.newton_itercount = 0 self.lin_itercount = 0 self.newton_ncalls = 0 self.lin_ncalls = 0
def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = [ 'nvars', 'nu', 'eps', 'newton_maxiter', 'newton_tol', 'lin_tol', 'lin_maxiter', 'radius' ] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on if len(problem_params['nvars']) != 2: raise ProblemError('this is a 2d example, got %s' % problem_params['nvars']) if problem_params['nvars'][0] != problem_params['nvars'][1]: raise ProblemError('need a square domain, got %s' % problem_params['nvars']) if problem_params['nvars'][0] % 2 != 0: raise ProblemError('the setup requires nvars = 2^p per dimension') # invoke super init, passing number of dofs, dtype_u and dtype_f super(allencahn_fullyimplicit, self).__init__(problem_params['nvars'], dtype_u, dtype_f, problem_params) # compute dx and get discretization matrix A self.dx = 1.0 / self.params.nvars[0] self.A = self.__get_A(self.params.nvars, self.dx) self.xvalues = np.array( [i * self.dx - 0.5 for i in range(self.params.nvars[0])]) self.newton_itercount = 0 self.lin_itercount = 0 self.newton_ncalls = 0 self.lin_ncalls = 0
def __init__(self, problem_params, dtype_u=pmesh_datatype, dtype_f=rhs_imex_pmesh): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: pmesh data type (will be passed to parent class) dtype_f: pmesh data type wuth implicit and explicit parts (will be passed to parent class) """ if 'L' not in problem_params: problem_params['L'] = 1.0 if 'init_type' not in problem_params: problem_params['init_type'] = 'circle' if 'comm' not in problem_params: problem_params['comm'] = None if 'dw' not in problem_params: problem_params['dw'] = 0.0 # these parameters will be used later, so assert their existence essential_keys = ['nvars', 'eps', 'L', 'radius', 'dw'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % (key, str(problem_params.keys())) raise ParameterError(msg) if not (isinstance(problem_params['nvars'], tuple) and len(problem_params['nvars']) > 1): raise ProblemError('Need at least two dimensions') # Creating ParticleMesh structure self.pm = ParticleMesh(BoxSize=problem_params['L'], Nmesh=list(problem_params['nvars']), dtype='f8', plan_method='measure', comm=problem_params['comm']) # create test RealField to get the local dimensions (there's probably a better way to do that) tmp = self.pm.create(type='real') # invoke super init, passing the communicator and the local dimensions as init super(allencahn_imex, self).__init__(init=(self.pm.comm, tmp.value.shape), dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) # Need this for diagnostics self.dx = self.params.L / problem_params['nvars'][0] self.dy = self.params.L / problem_params['nvars'][1] self.xvalues = [i * self.dx - problem_params['L'] / 2 for i in range(problem_params['nvars'][0])] self.yvalues = [i * self.dy - problem_params['L'] / 2 for i in range(problem_params['nvars'][1])]
def __init__(self, problem_params, dtype_u, dtype_f, t): """ Initialization routine Args: problem_params (dict): custom parameters for the example """ # these parameters will be used later, so assert their existence essential_keys = ['lam', 'nvars'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % (key, str(problem_params.keys())) raise ParameterError(msg) self.lam = problem_params['lam'] self.nvars = problem_params['nvars'] # interval [-20,20] self.dx = 40.0 / self.nvars self.xvalues = np.array([-20 + i * self.dx for i in range(self.nvars)]) self.A = self.__get_A(self.nvars, self.dx) # nu wird so gewaehlt, dass die rechte Seite nu/(dx^2)*A den Eigenwert lambda hat self.nu = 1.0 #def root_conv(d): # exact=[] # n=3 # for time in t: # exact = np.append( exact, 0.5 * (1 - np.tanh((self.xvalues - 2.0/d * time) / d ) )) # return max( abs( np.linalg.eigvals( np.kron( np.eye(int(n)) , self.A) + sp.diags(8./(d*d) * (2* exact-3*exact**2)) ))) + self.lam #d0=1 #print(opt.minimize(root_conv, d0, method='Nelder-Mead').x , self.lam) self.d = -self.lam/ max(abs(np.linalg.eigvals(self.A)))*0.001 #just a random number with nice results self.A *= self.nu self.rhs_mat = self.A self.dtype = dtype_u self.exact = self.u_exact(t)
def compute_residual(self): """ Computation of the residual using the collocation matrix Q """ # get current level and problem description L = self.level P = L.prob # check if there are new values (e.g. from a sweep) # assert L.status.updated # compute the residual for each node # build QF(u) res_norm = [] res = self.integrate() for m in range(self.coll.num_nodes): res[m] += L.u[0] - L.u[m + 1] # add tau if associated if L.tau[m] is not None: res[m] += L.tau[m] # use abs function from data type here res_norm.append(abs(res[m])) # find maximal residual over the nodes if L.params.residual_type == 'full_abs': L.status.residual = max(res_norm) elif L.params.residual_type == 'last_abs': L.status.residual = res_norm[-1] elif L.params.residual_type == 'full_rel': L.status.residual = max(res_norm) / abs(L.u[0]) elif L.params.residual_type == 'last_rel': L.status.residual = res_norm[-1] / abs(L.u[0]) else: raise ParameterError( f'residual_type = {L.params.residual_type} not implemented, choose ' f'full_abs, last_abs, full_rel or last_rel instead') # indicate that the residual has seen the new values L.status.updated = False return None
def __init__(self, problem_params, dtype_u, dtype_f): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: particle data type (will be passed parent class) dtype_f: acceleration data type (will be passed parent class) """ # these parameters will be used later, so assert their existence essential_keys = [] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # invoke super init, passing nparts, dtype_u and dtype_f super(henon_heiles, self).__init__(2, dtype_u, dtype_f, problem_params)