def discretize(n, nt, blocks):
h = 1. / blocks
ops = [WrappedDiffusionOperator.create(n, h * i, h * (i + 1)) for i in range(blocks)]
pfs = [ProjectionParameterFunctional('diffusion_coefficients', blocks, i) for i in range(blocks)]
operator = LincombOperator(ops, pfs)
initial_data = operator.source.zeros()
# use data property of WrappedVector to setup rhs
# note that we cannot use the data property of ListVectorArray,
# since ListVectorArray will always return a copy
rhs_vec = operator.range.zeros()
rhs_data = rhs_vec._list[0].to_numpy()
rhs_data[:] = np.ones(len(rhs_data))
rhs_data[0] = 0
rhs_data[len(rhs_data) - 1] = 0
rhs = VectorOperator(rhs_vec)
# hack together a visualizer ...
grid = OnedGrid(domain=(0, 1), num_intervals=n)
visualizer = OnedVisualizer(grid)
time_stepper = ExplicitEulerTimeStepper(nt)
fom = InstationaryModel(T=1e-0, operator=operator, rhs=rhs, initial_data=initial_data,
time_stepper=time_stepper, num_values=20,
visualizer=visualizer, name='C++-Model')
return fom
def discretize(n, nt, blocks):
h = 1. / blocks
ops = [
WrappedDiffusionOperator.create(n, h * i, h * (i + 1))
for i in range(blocks)
]
pfs = [
ProjectionParameterFunctional('diffusion_coefficients', (blocks, ),
(i, )) for i in range(blocks)
]
operator = LincombOperator(ops, pfs)
initial_data = operator.source.zeros()
# use data property of WrappedVector to setup rhs
# note that we cannot use the data property of ListVectorArray,
# since ListVectorArray will always return a copy
rhs_vec = operator.range.zeros()
rhs_data = rhs_vec._list[0].data
rhs_data[:] = np.ones(len(rhs_data))
rhs_data[0] = 0
rhs_data[len(rhs_data) - 1] = 0
rhs = VectorFunctional(rhs_vec)
# hack together a visualizer ...
grid = OnedGrid(domain=(0, 1), num_intervals=n)
visualizer = Matplotlib1DVisualizer(grid)
time_stepper = ExplicitEulerTimeStepper(nt)
parameter_space = CubicParameterSpace(operator.parameter_type, 0.1, 1)
d = InstationaryDiscretization(T=1e-0,
operator=operator,
rhs=rhs,
initial_data=initial_data,
time_stepper=time_stepper,
num_values=20,
parameter_space=parameter_space,
visualizer=visualizer,
name='C++-Discretization',
cache_region=None)
return d
my=mxyz[1],
mz=mxyz[2],
tfinal=timeFinal,
num_output_times=numberOfOutputTimes)
q0 = np.reshape(problem.claw.solution.state.q,
problem.claw.solution.state.q.size,
order='F')
q0_array = NumpyVectorSpace(problem.claw.solution.state.q.size).make_array(
[q0])
source_space = NumpyVectorSpace(problem.claw.solution.state.q.size)
source_space.make_array([q0])
range_space = NumpyVectorSpace(problem.claw.solution.state.q.size)
op = PyClawOperator(problem.claw, source_space, range_space)
vis = PyClawVisualizer(problem.claw)
ts = ExplicitEulerTimeStepper(nt=240)
problem.claw.solver.setup(problem.claw.solution)
fom = InstationaryModel(T=120.,
initial_data=q0_array,
operator=op,
rhs=None,
mass=None,
visualizer=vis,
time_stepper=ts,
num_values=20)
# Constant Timesteps
dt = fom.T / fom.time_stepper.nt
problem.claw.solver.dt = dt
def discretize_instationary_cg(analytical_problem,
diameter=None,
domain_discretizer=None,
grid_type=None,
grid=None,
boundary_info=None,
num_values=None,
time_stepper=None,
nt=None,
preassemble=True):
"""Discretizes an |InstationaryProblem| with a |StationaryProblem| as stationary part
using finite elements.
Parameters
----------
analytical_problem
The |InstationaryProblem| to discretize.
diameter
If not `None`, `diameter` is passed as an argument to the `domain_discretizer`.
domain_discretizer
Discretizer to be used for discretizing the analytical domain. This has
to be a function `domain_discretizer(domain_description, diameter, ...)`.
If `None`, |discretize_domain_default| is used.
grid_type
If not `None`, this parameter is forwarded to `domain_discretizer` to specify
the type of the generated |Grid|.
grid
Instead of using a domain discretizer, the |Grid| can also be passed directly
using this parameter.
boundary_info
A |BoundaryInfo| specifying the boundary types of the grid boundary entities.
Must be provided if `grid` is specified.
num_values
The number of returned vectors of the solution trajectory. If `None`, each
intermediate vector that is calculated is returned.
time_stepper
The :class:`time-stepper <pymor.algorithms.timestepping.TimeStepperInterface>`
to be used by :class:`~pymor.models.basic.InstationaryModel.solve`.
nt
If `time_stepper` is not specified, the number of time steps for implicit
Euler time stepping.
preassemble
If `True`, preassemble all operators in the resulting |Model|.
Returns
-------
m
The |Model| that has been generated.
data
Dictionary with the following entries:
:grid: The generated |Grid|.
:boundary_info: The generated |BoundaryInfo|.
:unassembled_m: In case `preassemble` is `True`, the generated |Model|
before preassembling operators.
"""
assert isinstance(analytical_problem, InstationaryProblem)
assert isinstance(analytical_problem.stationary_part, StationaryProblem)
assert grid is None or boundary_info is not None
assert boundary_info is None or grid is not None
assert grid is None or domain_discretizer is None
assert (time_stepper is None) != (nt is None)
p = analytical_problem
m, data = discretize_stationary_cg(p.stationary_part,
diameter=diameter,
domain_discretizer=domain_discretizer,
grid_type=grid_type,
grid=grid,
boundary_info=boundary_info)
if p.initial_data.parametric:
I = InterpolationOperator(data['grid'], p.initial_data)
else:
I = p.initial_data.evaluate(data['grid'].centers(data['grid'].dim))
I = m.solution_space.make_array(I)
if time_stepper is None:
if p.stationary_part.diffusion is None:
time_stepper = ExplicitEulerTimeStepper(nt=nt)
else:
time_stepper = ImplicitEulerTimeStepper(nt=nt)
mass = m.l2_0_product
m = InstationaryModel(operator=m.operator,
rhs=m.rhs,
mass=mass,
initial_data=I,
T=p.T,
products=m.products,
output_functional=m.output_functional,
time_stepper=time_stepper,
parameter_space=p.parameter_space,
visualizer=m.visualizer,
num_values=num_values,
name=f'{p.name}_CG')
if preassemble:
data['unassembled_m'] = m
m = preassemble_(m)
return m, data
def discretize_instationary_fv(analytical_problem, diameter=None, domain_discretizer=None, grid_type=None,
num_flux='lax_friedrichs', lxf_lambda=1., eo_gausspoints=5, eo_intervals=1,
grid=None, boundary_info=None, num_values=None, time_stepper=None, nt=None,
preassemble=True):
"""Discretizes an |InstationaryProblem| with a |StationaryProblem| as stationary part
using the finite volume method.
Parameters
----------
analytical_problem
The |InstationaryProblem| to discretize.
diameter
If not `None`, `diameter` is passed to the `domain_discretizer`.
domain_discretizer
Discretizer to be used for discretizing the analytical domain. This has
to be a function `domain_discretizer(domain_description, diameter, ...)`.
If further arguments should be passed to the discretizer, use
:func:`functools.partial`. If `None`, |discretize_domain_default| is used.
grid_type
If not `None`, this parameter is forwarded to `domain_discretizer` to specify
the type of the generated |Grid|.
num_flux
The numerical flux to use in the finite volume formulation. Allowed
values are `'lax_friedrichs'`, `'engquist_osher'`, `'simplified_engquist_osher'`
(see :mod:`pymor.discretizers.builtin.fv`).
lxf_lambda
The stabilization parameter for the Lax-Friedrichs numerical flux
(ignored, if different flux is chosen).
eo_gausspoints
Number of Gauss points for the Engquist-Osher numerical flux
(ignored, if different flux is chosen).
eo_intervals
Number of sub-intervals to use for integration when using Engquist-Osher
numerical flux (ignored, if different flux is chosen).
grid
Instead of using a domain discretizer, the |Grid| can also be passed directly
using this parameter.
boundary_info
A |BoundaryInfo| specifying the boundary types of the grid boundary entities.
Must be provided if `grid` is specified.
num_values
The number of returned vectors of the solution trajectory. If `None`, each
intermediate vector that is calculated is returned.
time_stepper
The :class:`time-stepper <pymor.algorithms.timestepping.TimeStepper>`
to be used by :class:`~pymor.models.basic.InstationaryModel.solve`.
nt
If `time_stepper` is not specified, the number of time steps for implicit
Euler time stepping.
preassemble
If `True`, preassemble all operators in the resulting |Model|.
Returns
-------
m
The |Model| that has been generated.
data
Dictionary with the following entries:
:grid: The generated |Grid|.
:boundary_info: The generated |BoundaryInfo|.
:unassembled_m: In case `preassemble` is `True`, the generated |Model|
before preassembling operators.
"""
assert isinstance(analytical_problem, InstationaryProblem)
assert isinstance(analytical_problem.stationary_part, StationaryProblem)
assert grid is None or boundary_info is not None
assert boundary_info is None or grid is not None
assert grid is None or domain_discretizer is None
assert (time_stepper is None) != (nt is None)
p = analytical_problem
m, data = discretize_stationary_fv(p.stationary_part, diameter=diameter, domain_discretizer=domain_discretizer,
grid_type=grid_type, num_flux=num_flux, lxf_lambda=lxf_lambda,
eo_gausspoints=eo_gausspoints, eo_intervals=eo_intervals, grid=grid,
boundary_info=boundary_info)
grid = data['grid']
if p.initial_data.parametric:
def initial_projection(U, mu):
I = p.initial_data.evaluate(grid.quadrature_points(0, order=2), mu).squeeze()
I = np.sum(I * grid.reference_element.quadrature(order=2)[1], axis=1) * (1. / grid.reference_element.volume)
I = m.solution_space.make_array(I)
return I.lincomb(U).to_numpy()
I = NumpyGenericOperator(initial_projection, dim_range=grid.size(0), linear=True, range_id=m.solution_space.id,
parameter_type=p.initial_data.parameter_type)
else:
I = p.initial_data.evaluate(grid.quadrature_points(0, order=2)).squeeze()
I = np.sum(I * grid.reference_element.quadrature(order=2)[1], axis=1) * (1. / grid.reference_element.volume)
I = m.solution_space.make_array(I)
if time_stepper is None:
if p.stationary_part.diffusion is None:
time_stepper = ExplicitEulerTimeStepper(nt=nt)
else:
time_stepper = ImplicitEulerTimeStepper(nt=nt)
rhs = None if isinstance(m.rhs, ZeroOperator) else m.rhs
m = InstationaryModel(operator=m.operator, rhs=rhs, mass=None, initial_data=I, T=p.T,
products=m.products, time_stepper=time_stepper,
parameter_space=p.parameter_space, visualizer=m.visualizer,
num_values=num_values, name=f'{p.name}_FV')
if preassemble:
data['unassembled_m'] = m
m = preassemble_(m)
return m, data
def discretize_nonlinear_instationary_advection_fv(analytical_problem,
diameter=None,
nt=100,
num_flux='lax_friedrichs',
lxf_lambda=1.,
eo_gausspoints=5,
eo_intervals=1,
num_values=None,
domain_discretizer=None,
grid=None,
boundary_info=None):
"""Discretizes an |InstationaryAdvectionProblem| using the finite volume method.
Simple explicit Euler time-stepping is used for time-discretization.
Parameters
----------
analytical_problem
The |InstationaryAdvectionProblem| to discretize.
diameter
If not `None`, `diameter` is passed to the `domain_discretizer`.
nt
The number of time-steps.
num_flux
The numerical flux to use in the finite volume formulation. Allowed
values are `'lax_friedrichs'`, `'engquist_osher'`, `'simplified_engquist_osher'`.
(See :mod:`pymor.operators.fv`.)
lxf_lambda
The stabilization parameter for the Lax-Friedrichs numerical flux.
(Ignored, if different flux is chosen.)
eo_gausspoints
Number of Gauss points for the Engquist-Osher numerical flux.
(Ignored, if different flux is chosen.)
eo_intervals
Number of sub-intervals to use for integration when using Engquist-Osher
numerical flux. (Ignored, if different flux is chosen.)
num_values
The number of returned vectors of the solution trajectory. If `None`, each
intermediate vector that is calculated is returned.
domain_discretizer
Discretizer to be used for discretizing the analytical domain. This has
to be a function `domain_discretizer(domain_description, diameter, ...)`.
If further arguments should be passed to the discretizer, use
:func:`functools.partial`. If `None`, |discretize_domain_default| is used.
grid
Instead of using a domain discretizer, the |Grid| can also be passed directly
using this parameter.
boundary_info
A |BoundaryInfo| specifying the boundary types of the grid boundary entities.
Must be provided if `grid` is specified.
Returns
-------
discretization
The |Discretization| that has been generated.
data
Dictionary with the following entries:
:grid: The generated |Grid|.
:boundary_info: The generated |BoundaryInfo|.
"""
assert isinstance(analytical_problem, InstationaryAdvectionProblem)
assert grid is None or boundary_info is not None
assert boundary_info is None or grid is not None
assert grid is None or domain_discretizer is None
assert num_flux in ('lax_friedrichs', 'engquist_osher',
'simplified_engquist_osher')
if grid is None:
domain_discretizer = domain_discretizer or discretize_domain_default
if diameter is None:
grid, boundary_info = domain_discretizer(analytical_problem.domain)
else:
grid, boundary_info = domain_discretizer(analytical_problem.domain,
diameter=diameter)
p = analytical_problem
if num_flux == 'lax_friedrichs':
L = nonlinear_advection_lax_friedrichs_operator(
grid,
boundary_info,
p.flux_function,
dirichlet_data=p.dirichlet_data,
lxf_lambda=lxf_lambda)
elif num_flux == 'engquist_osher':
L = nonlinear_advection_engquist_osher_operator(
grid,
boundary_info,
p.flux_function,
p.flux_function_derivative,
gausspoints=eo_gausspoints,
intervals=eo_intervals,
dirichlet_data=p.dirichlet_data)
else:
L = nonlinear_advection_simplified_engquist_osher_operator(
grid,
boundary_info,
p.flux_function,
p.flux_function_derivative,
dirichlet_data=p.dirichlet_data)
F = None if p.rhs is None else L2ProductFunctional(grid, p.rhs)
if p.initial_data.parametric:
def initial_projection(U, mu):
I = p.initial_data.evaluate(grid.quadrature_points(0, order=2),
mu).squeeze()
I = np.sum(I * grid.reference_element.quadrature(order=2)[1],
axis=1) * (1. / grid.reference_element.volume)
I = NumpyVectorArray(I, copy=False)
return I.lincomb(U).data
inject_sid(
initial_projection, __name__ +
'.discretize_nonlinear_instationary_advection_fv.initial_data',
p.initial_data, grid)
I = NumpyGenericOperator(initial_projection,
dim_range=grid.size(0),
linear=True,
parameter_type=p.initial_data.parameter_type)
else:
I = p.initial_data.evaluate(grid.quadrature_points(0,
order=2)).squeeze()
I = np.sum(I * grid.reference_element.quadrature(order=2)[1],
axis=1) * (1. / grid.reference_element.volume)
I = NumpyVectorArray(I, copy=False)
inject_sid(
I, __name__ +
'.discretize_nonlinear_instationary_advection_fv.initial_data',
p.initial_data, grid)
products = {'l2': L2Product(grid, boundary_info)}
if grid.dim == 2:
visualizer = PatchVisualizer(grid=grid,
bounding_box=grid.domain,
codim=0)
elif grid.dim == 1:
visualizer = Matplotlib1DVisualizer(grid, codim=0)
else:
visualizer = None
parameter_space = p.parameter_space if hasattr(p,
'parameter_space') else None
time_stepper = ExplicitEulerTimeStepper(nt=nt)
discretization = InstationaryDiscretization(
operator=L,
rhs=F,
initial_data=I,
T=p.T,
products=products,
time_stepper=time_stepper,
parameter_space=parameter_space,
visualizer=visualizer,
num_values=num_values,
name='{}_FV'.format(p.name))
return discretization, {'grid': grid, 'boundary_info': boundary_info}
