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)
