Laplacian¶

class odl.discr.diff_ops.Laplacian(*args, **kwargs)[source]¶

Bases: odl.operator.tensor_ops.PointwiseTensorFieldOperator

Spatial Laplacian operator for DiscretizedSpace spaces.

Calls helper function finite_diff to calculate each component of the resulting product space vector.

Outside the domain zero padding is assumed.

Attributes

adjoint: Return the adjoint operator.
base_space: Base space X of this operator’s domain and range.
domain: Set of objects on which this operator can be evaluated.
inverse: Return the operator inverse.
is_functional: True if this operator’s range is a Field.
is_linear: True if this operator is linear.
range: Set in which the result of an evaluation of this operator lies.

Methods

`_call`(self, x[, out])	Calculate the spatial Laplacian of `x`.
`derivative`(self[, point])	Return the derivative operator.
`norm`(self[, estimate])	Return the operator norm of this operator.

__init__(self, domain, range=None, pad_mode='constant', pad_const=0)[source]¶

Initialize a new instance.

Parameters

domainDiscretizedSpace

Space of elements which the operator is acting on.

pad_modestring, optional

The padding mode to use outside the domain.

'constant': Fill with pad_const.

'symmetric': Reflect at the boundaries, not doubling the outmost values.

'periodic': Fill in values from the other side, keeping the order.

'order0': Extend constantly with the outmost values (ensures continuity).

'order1': Extend with constant slope (ensures continuity of the first derivative). This requires at least 2 values along each axis.

'order2': Extend with second order accuracy (ensures continuity of the second derivative). This requires at least 3 values along each axis where padding is applied.

pad_constfloat, optional

For pad_mode == 'constant', f assumes pad_const for indices outside the domain of f

Examples

>>> data = np.array([[ 0., 0., 0.],
...                  [ 0., 1., 0.],
...                  [ 0., 0., 0.]])
>>> space = odl.uniform_discr([0, 0], [3, 3], [3, 3])
>>> f = space.element(data)
>>> lap = Laplacian(space)
>>> lap(f)
uniform_discr([ 0.,  0.], [ 3.,  3.], (3, 3)).element(
    [[ 0.,  1.,  0.],
     [ 1., -4.,  1.],
     [ 0.,  1.,  0.]]
)