pymor.discretizers.builtin.fv
¶
This module provides some operators for finite volume discretizations.
Module Contents¶
- class pymor.discretizers.builtin.fv.BoundaryL2Functional(grid, function, boundary_type=None, boundary_info=None, name=None)[source]¶
Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
FV functional representing the inner product with an L2-
Function
on the boundary.- Parameters:
grid –
Grid
for which to assemble the functional.function – The
Function
with which to take the inner product.boundary_type – The type of domain boundary (e.g. ‘neumann’) on which to assemble the functional. If
None
the functional is assembled over the whole boundary.boundary_info – If
boundary_type
is specified, theBoundaryInfo
determining which boundary entity belongs to which physical boundary.name – The name of the functional.
- class pymor.discretizers.builtin.fv.DiffusionOperator(grid, boundary_info, diffusion_function=None, diffusion_constant=None, solver_options=None, name=None)[source]¶
Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Finite Volume Diffusion
Operator
.The operator is of the form
(Lu)(x) = c ∇ ⋅ [ d(x) ∇ u(x) ]
- Parameters:
grid – The
Grid
over which to assemble the operator.boundary_info –
BoundaryInfo
for the treatment of Dirichlet boundary conditions.diffusion_function – The scalar-valued
Function
d(x)
. IfNone
, constant one is assumed.diffusion_constant – The constant
c
. IfNone
,c
is set to one.solver_options – The
solver_options
for the operator.name – Name of the operator.
- class pymor.discretizers.builtin.fv.EngquistOsherFlux(flux, flux_derivative, gausspoints=5, intervals=1)[source]¶
Bases:
NumericalConvectiveFlux
Engquist-Osher numerical flux.
If
f
is the analytical flux, andf'
its derivative, the Engquist-Osher flux is given by:F(U_in, U_out, normal, vol) = vol * [c^+(U_in, normal) + c^-(U_out, normal)] U_in c^+(U_in, normal) = f(0)⋅normal + ∫ max(f'(s)⋅normal, 0) ds s=0 U_out c^-(U_out, normal) = ∫ min(f'(s)⋅normal, 0) ds s=0
- Parameters:
Methods
- class pymor.discretizers.builtin.fv.InterpolationOperator(grid, function, order=0)[source]¶
Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Vector-like L^2-projection interpolation
Operator
for finite volume spaces.- Parameters:
- class pymor.discretizers.builtin.fv.L2Functional(grid, function=None, boundary_info=None, dirichlet_data=None, diffusion_function=None, diffusion_constant=None, neumann_data=None, order=1, name=None)[source]¶
Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Finite volume functional representing the inner product with an L2-
Function
.Additionally, boundary conditions can be enforced by providing
dirichlet_data
andneumann_data
functions.- Parameters:
grid –
Grid
for which to assemble the functional.function – The
Function
with which to take the inner product orNone
.boundary_info –
BoundaryInfo
determining the Dirichlet and Neumann boundaries orNone
. IfNone
, no boundary treatment is performed.dirichlet_data –
Function
providing the Dirichlet boundary values. IfNone
, constant-zero boundary is assumed.diffusion_function – See
DiffusionOperator
. Has to be specified in casedirichlet_data
is given.diffusion_constant – See
DiffusionOperator
. Has to be specified in casedirichlet_data
is given.neumann_data –
Function
providing the Neumann boundary values. IfNone
, constant-zero is assumed.order – Order of the Gauss quadrature to use for numerical integration.
name – The name of the functional.
- class pymor.discretizers.builtin.fv.L2Product(grid, solver_options=None, name=None)[source]¶
Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Operator
representing the L2-product between finite volume functions.- Parameters:
grid – The
Grid
for which to assemble the product.solver_options – The
solver_options
for the operator.name – The name of the product.
- class pymor.discretizers.builtin.fv.LaxFriedrichsFlux(flux, lxf_lambda=1.0)[source]¶
Bases:
NumericalConvectiveFlux
Lax-Friedrichs numerical flux.
If
f
is the analytical flux, the Lax-Friedrichs fluxF
is given by:F(U_in, U_out, normal, vol) = vol * [normal⋅(f(U_in) + f(U_out))/2 + (U_in - U_out)/(2*λ)]
- Parameters:
flux –
Function
defining the analytical fluxf
.lxf_lambda – The stabilization parameter
λ
.
Methods
- class pymor.discretizers.builtin.fv.LinearAdvectionLaxFriedrichsOperator(grid, boundary_info, velocity_field, lxf_lambda=1.0, solver_options=None, name=None)[source]¶
Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Linear advection finite Volume
Operator
using Lax-Friedrichs flux.The operator is of the form
L(u, mu)(x) = ∇ ⋅ (v(x, mu)⋅u(x))
See
LaxFriedrichsFlux
for the definition of the Lax-Friedrichs flux.- Parameters:
grid –
Grid
over which to assemble the operator.boundary_info –
BoundaryInfo
determining the Dirichlet and Neumann boundaries.velocity_field –
Function
defining the velocity fieldv
.lxf_lambda – The stabilization parameter
λ
.solver_options – The
solver_options
for the operator.name – The name of the operator.
- class pymor.discretizers.builtin.fv.NonlinearAdvectionOperator(grid, boundary_info, numerical_flux, dirichlet_data=None, solver_options=None, name=None)[source]¶
Bases:
pymor.operators.interface.Operator
Nonlinear finite volume advection
Operator
.The operator is of the form
L(u, mu)(x) = ∇ ⋅ f(u(x), mu)
- Parameters:
grid –
Grid
for which to evaluate the operator.boundary_info –
BoundaryInfo
determining the Dirichlet and Neumann boundaries.numerical_flux – The
NumericalConvectiveFlux
to use.dirichlet_data –
Function
providing the Dirichlet boundary values. IfNone
, constant-zero boundary is assumed.solver_options – The
solver_options
for the operator.name – The name of the operator.
Methods
Apply the operator to a
VectorArray
.Return the operator's Jacobian as a new
Operator
.Restrict the operator range to a given set of degrees of freedom.
- apply(U, mu=None)[source]¶
Apply the operator to a
VectorArray
.- Parameters:
U –
VectorArray
of vectors to which the operator is applied.mu – The
parameter values
for which to evaluate the operator.
- Returns:
|VectorArray| of the operator evaluations.
- jacobian(U, mu=None)[source]¶
Return the operator’s Jacobian as a new
Operator
.- Parameters:
U – Length 1
VectorArray
containing the vector for which to compute the Jacobian.mu – The
parameter values
for which to compute the Jacobian.
- Returns:
Linear |Operator| representing the Jacobian.
- restricted(dofs)[source]¶
Restrict the operator range to a given set of degrees of freedom.
This method returns a restricted version
restricted_op
of the operator along with an arraysource_dofs
such that for anyVectorArray
U
inself.source
the following is true:self.apply(U, mu).dofs(dofs) == restricted_op.apply(restricted_op.source.from_numpy(U.dofs(source_dofs)) mu).to_numpy()
Such an operator is mainly useful for
empirical interpolation
where the evaluation of the original operator only needs to be known for few selected degrees of freedom. If the operator has a small stencil, only fewsource_dofs
will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.- Parameters:
dofs – One-dimensional
NumPy array
of degrees of freedom in the operatorrange
to which to restrict.- Returns:
restricted_op – The restricted operator as defined above. The operator will have
NumpyVectorSpace
(len(source_dofs))
assource
andNumpyVectorSpace
(len(dofs))
asrange
.source_dofs – One-dimensional
NumPy array
of source degrees of freedom as defined above.
- class pymor.discretizers.builtin.fv.NonlinearReactionOperator(grid, reaction_function, reaction_function_derivative=None, name=None)[source]¶
Bases:
pymor.operators.interface.Operator
Finite Volume nonlinear reaction
Operator
.- Parameters:
grid – The
Grid
for which to assemble the operator.reaction_function – The reaction function.
reaction_function_derivative – The reaction function derivative.
name – The name of the operator.
Methods
Apply the operator to a
VectorArray
.Return the operator's Jacobian as a new
Operator
.- apply(U, ind=None, mu=None)[source]¶
Apply the operator to a
VectorArray
.- Parameters:
U –
VectorArray
of vectors to which the operator is applied.mu – The
parameter values
for which to evaluate the operator.
- Returns:
|VectorArray| of the operator evaluations.
- jacobian(U, mu=None)[source]¶
Return the operator’s Jacobian as a new
Operator
.- Parameters:
U – Length 1
VectorArray
containing the vector for which to compute the Jacobian.mu – The
parameter values
for which to compute the Jacobian.
- Returns:
Linear |Operator| representing the Jacobian.
- class pymor.discretizers.builtin.fv.NumericalConvectiveFlux[source]¶
Bases:
pymor.parameters.base.ParametricObject
Interface for numerical convective fluxes for finite volume schemes.
Numerical fluxes defined by this interfaces are functions of the form
F(U_inner, U_outer, unit_outer_normal, edge_volume, mu)
.- The flux evaluation is vectorized and happens in two stages:
evaluate_stage1
receives aNumPy array
U
of all values which appear asU_inner
orU_outer
for all edges the flux shall be evaluated at and returns atuple
ofNumPy arrays
each of the same length asU
.evaluate_stage2
receives the reorderedstage1_data
for each edge as well as the unit outer normal and the volume of the edges.stage1_data
is given as follows: IfR_l
isl
-th entry of thetuple
returned byevaluate_stage1
, thel
-th entryD_l
of of thestage1_data
tuple has the shape(num_edges, 2) + R_l.shape[1:]
. If for edgek
the valuesU_inner
andU_outer
are thei
-th andj
-th value in theU
array provided toevaluate_stage1
, we haveD_l[k, 0] == R_l[i], D_l[k, 1] == R_l[j].
evaluate_stage2
returns aNumPy array
of the flux evaluations for each edge.
Methods
- class pymor.discretizers.builtin.fv.ReactionOperator(grid, reaction_coefficient, solver_options=None, name=None)[source]¶
Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Finite Volume reaction
Operator
.The operator is of the form
L(u, mu)(x) = c(x, mu)⋅u(x)
- Parameters:
grid – The
Grid
for which to assemble the operator.reaction_coefficient – The function ‘c’
solver_options – The
solver_options
for the operator.name – The name of the operator.
- class pymor.discretizers.builtin.fv.SimplifiedEngquistOsherFlux(flux, flux_derivative)[source]¶
Bases:
NumericalConvectiveFlux
Engquist-Osher numerical flux. Simplified Implementation for special case.
For the definition of the Engquist-Osher flux see
EngquistOsherFlux
. This class provides a faster and more accurate implementation for the special case thatf(0) == 0
and the derivative off
only changes sign at0
.- Parameters:
Methods
- pymor.discretizers.builtin.fv.discretize_instationary_fv(analytical_problem, diameter=None, domain_discretizer=None, grid_type=None, num_flux='lax_friedrichs', lxf_lambda=1.0, eo_gausspoints=5, eo_intervals=1, grid=None, boundary_info=None, num_values=None, time_stepper=None, nt=None, preassemble=True)[source]¶
FV Discretization of an
InstationaryProblem
with aStationaryProblem
as stationary part.- Parameters:
analytical_problem – The
InstationaryProblem
to discretize.diameter – If not
None
,diameter
is passed to thedomain_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, usefunctools.partial
. IfNone
,discretize_domain_default
is used.grid_type – If not
None
, this parameter is forwarded todomain_discretizer
to specify the type of the generatedGrid
.num_flux – The numerical flux to use in the finite volume formulation. Allowed values are
'lax_friedrichs'
,'engquist_osher'
,'simplified_engquist_osher'
(seepymor.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 ifgrid
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
time-stepper
to be used bysolve
ofInstationaryModel
.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 resultingModel
.
- 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
isTrue
, the generatedModel
before preassembling operators.
- pymor.discretizers.builtin.fv.discretize_stationary_fv(analytical_problem, diameter=None, domain_discretizer=None, grid_type=None, num_flux='lax_friedrichs', lxf_lambda=1.0, eo_gausspoints=5, eo_intervals=1, grid=None, boundary_info=None, preassemble=True)[source]¶
Discretizes a
StationaryProblem
using the finite volume method.- Parameters:
analytical_problem – The
StationaryProblem
to discretize.diameter – If not
None
,diameter
is passed as an argument to thedomain_discretizer
.domain_discretizer – Discretizer to be used for discretizing the analytical domain. This has to be a function
domain_discretizer(domain_description, diameter, ...)
. IfNone
,discretize_domain_default
is used.grid_type – If not
None
, this parameter is forwarded todomain_discretizer
to specify the type of the generatedGrid
.num_flux – The numerical flux to use in the finite volume formulation. Allowed values are
'lax_friedrichs'
,'engquist_osher'
,'simplified_engquist_osher'
(seepymor.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 ifgrid
is specified.preassemble – If
True
, preassemble all operators in the resultingModel
.
- 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
isTrue
, the generatedModel
before preassembling operators.
- pymor.discretizers.builtin.fv.nonlinear_advection_engquist_osher_operator(grid, boundary_info, flux, flux_derivative, gausspoints=5, intervals=1, dirichlet_data=None, solver_options=None, name=None)[source]¶
Instantiate a
NonlinearAdvectionOperator
usingEngquistOsherFlux
.
- pymor.discretizers.builtin.fv.nonlinear_advection_lax_friedrichs_operator(grid, boundary_info, flux, lxf_lambda=1.0, dirichlet_data=None, solver_options=None, name=None)[source]¶
Instantiate a
NonlinearAdvectionOperator
usingLaxFriedrichsFlux
.
- pymor.discretizers.builtin.fv.nonlinear_advection_simplified_engquist_osher_operator(grid, boundary_info, flux, flux_derivative, dirichlet_data=None, solver_options=None, name=None)[source]¶
Create a
NonlinearAdvectionOperator
usingSimplifiedEngquistOsherFlux
.