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