# pymor.discretizers.builtin package¶

## Submodules¶

### cg module¶

This module provides some operators for continuous finite element discretizations.

class pymor.discretizers.builtin.cg.AdvectionOperatorP1(*args, **kwargs)[source]

Linear advection Operator for linear finite elements.

The operator is of the form

(Lu)(x) = c ∇ ⋅ [ v(x) u(x) ]


The function v has to be vector-valued.

Parameters

grid

The Grid for which to assemble the operator.

boundary_info

BoundaryInfo for the treatment of Dirichlet boundary conditions.

The Function v(x) with shape_range = (grid.dim, ). If None, constant one is assumed.

The constant c. If None, c is set to one.

dirichlet_clear_columns

If True, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero to obtain a symmetric system matrix. Otherwise, only the rows will be set to zero.

dirichlet_clear_diag

If True, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise they are set to one.

solver_options

The solver_options for the operator.

name

Name of the operator.

class pymor.discretizers.builtin.cg.AdvectionOperatorQ1(*args, **kwargs)[source]

Linear advection Operator for bilinear finite elements.

The operator is of the form

(Lu)(x) = c ∇ ⋅ [ v(x) u(x) ]


The function v has to be vector-valued.

Parameters

grid

The Grid for which to assemble the operator.

boundary_info

BoundaryInfo for the treatment of Dirichlet boundary conditions.

The Function v(x) with shape_range = (grid.dim, ). If None, constant one is assumed.

The constant c. If None, c is set to one.

dirichlet_clear_columns

If True, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero to obtain a symmetric system matrix. Otherwise, only the rows will be set to zero.

dirichlet_clear_diag

If True, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise they are set to one.

solver_options

The solver_options for the operator.

name

Name of the operator.

class pymor.discretizers.builtin.cg.BoundaryDirichletFunctional(*args, **kwargs)[source]

Linear finite element functional for enforcing Dirichlet boundary values.

Parameters

grid

Grid for which to assemble the functional.

dirichlet_data

Function providing the Dirichlet boundary values.

boundary_info

BoundaryInfo determining the Dirichlet boundaries.

name

The name of the functional.

class pymor.discretizers.builtin.cg.BoundaryL2ProductFunctional(*args, **kwargs)[source]

Linear finite element 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.

dirichlet_clear_dofs

If True, set dirichlet boundary DOFs to zero.

boundary_info

If boundary_type is specified or dirichlet_clear_dofs is True, the BoundaryInfo determining which boundary entity belongs to which physical boundary.

name

The name of the functional.

pymor.discretizers.builtin.cg.CGVectorSpace(grid, id='STATE')[source]

class pymor.discretizers.builtin.cg.DiffusionOperatorP1(*args, **kwargs)[source]

Diffusion Operator for linear finite elements.

The operator is of the form

(Lu)(x) = c ∇ ⋅ [ d(x) ∇ u(x) ]


The function d can be scalar- or matrix-valued.

Parameters

grid

The Grid for which to assemble the operator.

boundary_info

BoundaryInfo for the treatment of Dirichlet boundary conditions.

diffusion_function

The Function d(x) with shape_range == () or shape_range = (grid.dim, grid.dim). If None, constant one is assumed.

diffusion_constant

The constant c. If None, c is set to one.

dirichlet_clear_columns

If True, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero to obtain a symmetric system matrix. Otherwise, only the rows will be set to zero.

dirichlet_clear_diag

If True, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise they are set to one.

solver_options

The solver_options for the operator.

name

Name of the operator.

class pymor.discretizers.builtin.cg.DiffusionOperatorQ1(*args, **kwargs)[source]

Diffusion Operator for bilinear finite elements.

The operator is of the form

(Lu)(x) = c ∇ ⋅ [ d(x) ∇ u(x) ]


The function d can be scalar- or matrix-valued.

Parameters

grid

The Grid for which to assemble the operator.

boundary_info

BoundaryInfo for the treatment of Dirichlet boundary conditions.

diffusion_function

The Function d(x) with shape_range == () or shape_range = (grid.dim, grid.dim). If None, constant one is assumed.

diffusion_constant

The constant c. If None, c is set to one.

dirichlet_clear_columns

If True, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero to obtain a symmetric system matrix. Otherwise, only the rows will be set to zero.

dirichlet_clear_diag

If True, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise they are set to one.

solver_options

The solver_options for the operator.

name

Name of the operator.

class pymor.discretizers.builtin.cg.InterpolationOperator(*args, **kwargs)[source]

Vector-like Lagrange interpolation Operator for continuous finite element spaces.

Parameters

grid

The Grid on which to interpolate.

function

The Function to interpolate.

class pymor.discretizers.builtin.cg.L2ProductFunctionalP1(*args, **kwargs)[source]

Linear finite element functional representing the inner product with an L2-Function.

Parameters

grid

Grid for which to assemble the functional.

function

The Function with which to take the inner product.

dirichlet_clear_dofs

If True, set dirichlet boundary DOFs to zero.

boundary_info

BoundaryInfo determining the Dirichlet boundaries in case dirichlet_clear_dofs is set to True.

name

The name of the functional.

class pymor.discretizers.builtin.cg.L2ProductFunctionalQ1(*args, **kwargs)[source]

Bilinear finite element functional representing the inner product with an L2-Function.

Parameters

grid

Grid for which to assemble the functional.

function

The Function with which to take the inner product.

dirichlet_clear_dofs

If True, set dirichlet boundary DOFs to zero.

boundary_info

BoundaryInfo determining the Dirichlet boundaries in case dirichlet_clear_dofs is set to True.

name

The name of the functional.

class pymor.discretizers.builtin.cg.L2ProductP1(*args, **kwargs)[source]

Operator representing the L2-product between linear finite element functions.

Parameters

grid

The Grid for which to assemble the product.

boundary_info

BoundaryInfo for the treatment of Dirichlet boundary conditions.

dirichlet_clear_rows

If True, set the rows of the system matrix corresponding to Dirichlet boundary DOFs to zero.

dirichlet_clear_columns

If True, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero.

dirichlet_clear_diag

If True, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise, if either dirichlet_clear_rows or dirichlet_clear_columns is True, the diagonal entries are set to one.

coefficient_function

Coefficient Function for product with shape_range == (). If None, constant one is assumed.

solver_options

The solver_options for the operator.

name

The name of the product.

class pymor.discretizers.builtin.cg.L2ProductQ1(*args, **kwargs)[source]

Operator representing the L2-product between bilinear finite element functions.

Parameters

grid

The Grid for which to assemble the product.

boundary_info

BoundaryInfo for the treatment of Dirichlet boundary conditions.

dirichlet_clear_rows

If True, set the rows of the system matrix corresponding to Dirichlet boundary DOFs to zero.

dirichlet_clear_columns

If True, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero.

dirichlet_clear_diag

If True, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise, if either dirichlet_clear_rows or dirichlet_clear_columns is True, the diagonal entries are set to one.

coefficient_function

Coefficient Function for product with shape_range == (). If None, constant one is assumed.

solver_options

The solver_options for the operator.

name

The name of the product.

class pymor.discretizers.builtin.cg.RobinBoundaryOperator(*args, **kwargs)[source]

Robin boundary Operator for linear finite elements.

The operator represents the contribution of Robin boundary conditions to the stiffness matrix, where the boundary condition is supposed to be given in the form

-[ d(x) ∇u(x) ] ⋅ n(x) = c(x) (u(x) - g(x))


d and n are the diffusion function (see DiffusionOperatorP1) and the unit outer normal in x, while c is the (scalar) Robin parameter function and g is the (also scalar) Robin boundary value function.

Parameters

grid

The Grid over which to assemble the operator.

boundary_info

BoundaryInfo for the treatment of Dirichlet boundary conditions.

robin_data

Tuple providing two Functions that represent the Robin parameter and boundary value function. If None, the resulting operator is zero.

solver_options

The solver_options for the operator.

name

Name of the operator.

pymor.discretizers.builtin.cg.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)[source]

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 time-stepper to be used by 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.

pymor.discretizers.builtin.cg.discretize_stationary_cg(analytical_problem, diameter=None, domain_discretizer=None, grid_type=None, grid=None, boundary_info=None, preassemble=True, mu_energy_product=None)[source]

Discretizes a StationaryProblem using finite elements.

Parameters

analytical_problem

The StationaryProblem 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.

preassemble

If True, preassemble all operators in the resulting Model.

mu_energy_product

If not None, parameter values for which to assemble the symmetric part of the Operator of the resulting Model fom (ignoring the advection part). Thus, assuming no advection and a symmetric diffusion tensor, fom.products['energy'] is equal to fom.operator.assemble(mu), except for the fact that the former has cleared Dirichlet rows and columns, while the latter only has cleared Dirichlet rows).

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.

### fv module¶

This module provides some operators for finite volume discretizations.

class pymor.discretizers.builtin.fv.DiffusionOperator(*args, **kwargs)[source]

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). If None, constant one is assumed.

diffusion_constant

The constant c. If None, c is set to one.

solver_options

The solver_options for the operator.

name

Name of the operator.

class pymor.discretizers.builtin.fv.EngquistOsherFlux(*args, **kwargs)[source]

Engquist-Osher numerical flux.

If f is the analytical flux, and f' 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

flux

Function defining the analytical flux f.

flux_derivative

Function defining the analytical flux derivative f'.

gausspoints

Number of Gauss quadrature points to be used for integration.

intervals

Number of subintervals to be used for integration.

Methods

 EngquistOsherFlux evaluate_stage1, evaluate_stage2 ImmutableObject BasicObject

pymor.discretizers.builtin.fv.FVVectorSpace(grid, id='STATE')[source]

class pymor.discretizers.builtin.fv.L2Product(*args, **kwargs)[source]

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.L2ProductFunctional(*args, **kwargs)[source]

Finite volume functional representing the inner product with an L2-Function.

Additionally, boundary conditions can be enforced by providing dirichlet_data and neumann_data functions.

Parameters

grid

Grid for which to assemble the functional.

function

The Function with which to take the inner product or None.

boundary_info

BoundaryInfo determining the Dirichlet and Neumann boundaries or None. If None, no boundary treatment is performed.

dirichlet_data

Function providing the Dirichlet boundary values. If None, constant-zero boundary is assumed.

diffusion_function

See DiffusionOperator. Has to be specified in case dirichlet_data is given.

diffusion_constant

See DiffusionOperator. Has to be specified in case dirichlet_data is given.

neumann_data

Function providing the Neumann boundary values. If None, 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.LaxFriedrichsFlux(*args, **kwargs)[source]

Lax-Friedrichs numerical flux.

If f is the analytical flux, the Lax-Friedrichs flux F 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 flux f.

lxf_lambda

The stabilization parameter λ.

Methods

 LaxFriedrichsFlux evaluate_stage1, evaluate_stage2 ImmutableObject BasicObject

pymor.discretizers.builtin.fv.LinearAdvectionLaxFriedrichs(*args, **kwargs)[source]

class pymor.discretizers.builtin.fv.LinearAdvectionLaxFriedrichsOperator(*args, **kwargs)[source]

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 field v.

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(*args, **kwargs)[source]

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. If None, constant-zero boundary is assumed.

solver_options

The solver_options for the operator.

name

The name of the operator.

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 array source_dofs such that for any VectorArray U in self.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 few source_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 operator range to which to restrict.

Returns

restricted_op

The restricted operator as defined above. The operator will have NumpyVectorSpace (len(source_dofs)) as source and NumpyVectorSpace (len(dofs)) as range.

source_dofs

One-dimensional NumPy array of source degrees of freedom as defined above.

class pymor.discretizers.builtin.fv.NonlinearReactionOperator(*args, **kwargs)[source]
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(*args, **kwargs)[source]

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:
1. evaluate_stage1 receives a NumPy array U of all values which appear as U_inner or U_outer for all edges the flux shall be evaluated at and returns a tuple of NumPy arrays each of the same length as U.

2. evaluate_stage2 receives the reordered stage1_data for each edge as well as the unit outer normal and the volume of the edges.

stage1_data is given as follows: If R_l is l-th entry of the tuple returned by evaluate_stage1, the l-th entry D_l of of the stage1_data tuple has the shape (num_edges, 2) + R_l.shape[1:]. If for edge k the values U_inner and U_outer are the i-th and j-th value in the U array provided to evaluate_stage1, we have

D_l[k, 0] == R_l[i],    D_l[k, 1] == R_l[j].


evaluate_stage2 returns a NumPy array of the flux evaluations for each edge.

Methods

 NumericalConvectiveFlux evaluate_stage1, evaluate_stage2 ImmutableObject BasicObject

class pymor.discretizers.builtin.fv.ReactionOperator(*args, **kwargs)[source]

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(*args, **kwargs)[source]

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 that f(0) == 0 and the derivative of f only changes sign at 0.

Parameters

flux

Function defining the analytical flux f.

flux_derivative

Function defining the analytical flux derivative f'.

Methods

 SimplifiedEngquistOsherFlux evaluate_stage1, evaluate_stage2 ImmutableObject BasicObject

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]

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 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 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 time-stepper to be used by 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.

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 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.

num_flux

The numerical flux to use in the finite volume formulation. Allowed values are 'lax_friedrichs', 'engquist_osher', 'simplified_engquist_osher' (see 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.

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.

pymor.discretizers.builtin.fv.jacobian_options(delta=1e-07)[source]

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 using EngquistOsherFlux.

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 using LaxFriedrichsFlux.

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]

Instantiate a NonlinearAdvectionOperator using SimplifiedEngquistOsherFlux.

### inverse module¶

pymor.discretizers.builtin.inverse.inv_transposed_two_by_two(A)[source]

Efficiently compute the tranposed inverses of a NumPy array of 2x2-matrices

|  retval[i1,...,ik,m,n] = numpy.linalg.inv(A[i1,...,ik,:,:]).


pymor.discretizers.builtin.inverse.inv_two_by_two(A)[source]

Efficiently compute the inverses of a NumPy array of 2x2-matrices

|  retval[i1,...,ik,m,n] = numpy.linalg.inv(A[i1,...,ik,:,:]).


### list module¶

class pymor.discretizers.builtin.list.ConvertToNumpyListVectorArrayRules[source]

Methods

 RuleTable append_rule, apply, apply_children, breakpoint_for_name, breakpoint_for_obj, get_children, insert_rule, replace_children BasicObject

Attributes

 ConvertToNumpyListVectorArrayRules action_NumpyMatrixOperator, action_recurse, action_VectorArrayOperator, rules BasicObject

pymor.discretizers.builtin.list.convert_to_numpy_list_vector_array(obj)[source]

This simple function recursively converts NumpyMatrixOperators to corresponding NumpyListVectorArrayMatrixOperators.

Returns

The converted Operator or Model.

class pymor.discretizers.builtin.quadratures.GaussQuadratures[source]

Bases: object

Gauss quadrature on the interval [0, 1]

Methods

 GaussQuadratures iter_quadrature, maxpoints, quadrature

Attributes

 GaussQuadratures a, order_map, orders, points, weights
classmethod iter_quadrature(order=None, npoints=None)[source]

iterates over a quadrature tuple wise

classmethod quadrature(order=None, npoints=None)[source]

returns tuple (P, W) where P is an array of Gauss points with corresponding weights W for the given integration order “order” or with “npoints” integration points