SamplingOperator

class odl.operator.tensor_ops.SamplingOperator(*args, **kwargs)[source]

Bases: odl.operator.operator.Operator

Operator that samples coefficients.

The operator is defined by

SamplingOperator(f) == c * f[sampling_points]

with the weight c being determined by the variant. By choosing c = 1, this operator approximates point evaluations or inner products with Dirac deltas, see option variant='point_eval'. By choosing c = cell_volume, it approximates the integration of f over the indexed cells, see option variant='integrate'.

Attributes
adjoint

Adjoint of the sampling operator, a WeightedSumSamplingOperator.

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.

sampling_points

Indices where to sample the function.

variant

Weighting scheme for the sampling operator.

Methods

_call(self, x)

Return values at indices, possibly weighted.

derivative(self, point)

Return the operator derivative at point.

norm(self[, estimate])

Return the operator norm of this operator.

__init__(self, domain, sampling_points, variant='point_eval')[source]

Initialize a new instance.

Parameters
domainTensorSpace

Set of elements on which this operator acts.

sampling_points1D array-like or sequence of 1D array-likes

Indices that determine the sampling points. In n dimensions, it should be a sequence of n arrays, where each member array is of equal length N. The indexed positions are (arr1[i], arr2[i], ..., arrn[i]), in total N points. If domain is one-dimensional, a single array-like can be used. Likewise, a single point can be given as integer in 1D, and as a array-like sequence in nD.

variant{‘point_eval’, ‘integrate’}, optional

For 'point_eval' this operator performs the sampling by evaluation the function at the sampling points. The 'integrate' variant approximates integration by multiplying point evaluation with the cell volume.

Examples

Sampling in 1d can be done with a single index (an int) or a sequence of such:

>>> space = odl.uniform_discr(0, 1, 4)
>>> op = odl.SamplingOperator(space, sampling_points=1)
>>> x = space.element([1, 2, 3, 4])
>>> op(x)
rn(1).element([ 2.])
>>> op = odl.SamplingOperator(space, sampling_points=[1, 2, 1])
>>> op(x)
rn(3).element([ 2.,  3.,  2.])

There are two variants 'point_eval' (default) and 'integrate', where the latter scales values by the cell volume to approximate the integral over the cells of the points:

>>> op = odl.SamplingOperator(space, sampling_points=[1, 2, 1],
...                           variant='integrate')
>>> space.cell_volume  # the scaling constant
0.25
>>> op(x)
rn(3).element([ 0.5 ,  0.75,  0.5 ])

In higher dimensions, a sequence of index array-likes must be given, or a single sequence for a single point:

>>> space = odl.uniform_discr([0, 0], [1, 1], (2, 3))
>>> # Sample at the index (0, 2)
>>> op = odl.SamplingOperator(space, sampling_points=[0, 2])
>>> x = space.element([[1, 2, 3],
...                    [4, 5, 6]])
>>> op(x)
rn(1).element([ 3.])
>>> sampling_points = [[0, 1, 1],  # indices (0, 2), (1, 1), (1, 0)
...                    [2, 1, 0]]
>>> op = odl.SamplingOperator(space, sampling_points)
>>> op(x)
rn(3).element([ 3.,  5.,  4.])