pymor.discretizers.builtin.fv
¶
This module provides some operators for finite volume discretizations.
Module Contents¶
Classes¶
Interface for numerical convective fluxes for finite volume schemes. 

LaxFriedrichs numerical flux. 

EngquistOsher numerical flux. Simplified Implementation for special case. 

EngquistOsher numerical flux. 

Nonlinear finite volume advection 

Linear advection finite Volume 



Finite Volume reaction 

Interface for 

Finite volume functional representing the inner product with an L2 

FV functional representing the inner product with an L2 

Finite Volume Diffusion 

Vectorlike L^2projection interpolation 
Functions¶
Instantiate a 

Create a 

Instantiate a 

Discretizes a 

FV Discretization of an 
 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.
 class pymor.discretizers.builtin.fv.LaxFriedrichsFlux(flux, lxf_lambda=1.0)[source]¶
Bases:
NumericalConvectiveFlux
LaxFriedrichs numerical flux.
If
f
is the analytical flux, the LaxFriedrichs 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
λ
.
 class pymor.discretizers.builtin.fv.SimplifiedEngquistOsherFlux(flux, flux_derivative)[source]¶
Bases:
NumericalConvectiveFlux
EngquistOsher numerical flux. Simplified Implementation for special case.
For the definition of the EngquistOsher 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
 class pymor.discretizers.builtin.fv.EngquistOsherFlux(flux, flux_derivative, gausspoints=5, intervals=1)[source]¶
Bases:
NumericalConvectiveFlux
EngquistOsher numerical flux.
If
f
is the analytical flux, andf'
its derivative, the EngquistOsher 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
 class pymor.discretizers.builtin.fv.NonlinearAdvectionOperator(grid, boundary_info, numerical_flux, dirichlet_data=None, solver_options=None, space_id='STATE', 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
, constantzero boundary is assumed. solver_options
The
solver_options
for the operator. name
The name of the operator.
 restricted(self, 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(NumpyVectorArray(U.dofs(source_dofs)), mu))
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
Onedimensional
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
Onedimensional
NumPy array
of source degrees of freedom as defined above.
 apply(self, 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(self, 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.
 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
.
 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
.
 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 LaxFriedrichs flux.The operator is of the form
L(u, mu)(x) = ∇ ⋅ (v(x, mu)⋅u(x))
See
LaxFriedrichsFlux
for the definition of the LaxFriedrichs 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.L2Product(grid, solver_options=None, name=None)[source]¶
Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Operator
representing the L2product 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.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.NonlinearReactionOperator(grid, reaction_function, reaction_function_derivative=None, space_id='STATE', name=None)[source]¶
Bases:
pymor.operators.interface.Operator
Interface for
Parameter
dependent discrete operators.An operator in pyMOR is simply a mapping which for any given
parameter values
maps vectors from itssource
VectorSpace
to vectors in itsrange
VectorSpace
.Note that there is no special distinction between functionals and operators in pyMOR. A functional is simply an operator with
NumpyVectorSpace
(1)
as itsrange
VectorSpace
. solver_options[source]¶
If not
None
, a dict which can contain the following keys: ‘inverse’
solver options used for
apply_inverse
 ‘inverse_adjoint’
solver options used for
apply_inverse_adjoint
 ‘jacobian’
solver options for the operators returned by
jacobian
(has no effect for linear operators)
If
solver_options
isNone
or a dict entry is missing orNone
, default options are used. The interpretation of the given solver options is up to the operator at hand. In general, values insolver_options
should either be strings (indicating a solver type) or dicts of options, usually with an entry'type'
which specifies the solver type to use and further items which configure this solver.
 source[source]¶
The source
VectorSpace
.
 range[source]¶
The range
VectorSpace
.
 H[source]¶
The adjoint operator, i.e.
self.H.apply(V, mu) == self.apply_adjoint(V, mu)
for all V, mu.
 apply(self, 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(self, 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.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
, constantzero 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
, constantzero is assumed. order
Order of the Gauss quadrature to use for numerical integration.
 name
The name of the functional.
 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 scalarvalued
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.InterpolationOperator(grid, function, order=0)[source]¶
Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Vectorlike L^2projection interpolation
Operator
for finite volume spaces.Parameters
 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 LaxFriedrichs numerical flux (ignored, if different flux is chosen).
 eo_gausspoints
Number of Gauss points for the EngquistOsher numerical flux (ignored, if different flux is chosen).
 eo_intervals
Number of subintervals to use for integration when using EngquistOsher 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.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 partParameters
 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 LaxFriedrichs numerical flux (ignored, if different flux is chosen).
 eo_gausspoints
Number of Gauss points for the EngquistOsher numerical flux (ignored, if different flux is chosen).
 eo_intervals
Number of subintervals to use for integration when using EngquistOsher 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
timestepper
to be used bysolve
. 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.