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