PointwiseSum

class odl.operator.tensor_ops.PointwiseSum(*args, **kwargs)

Bases: odl.operator.tensor_ops.PointwiseInner

Take the point-wise sum of a vector field.

This operator takes the (weighted) sum

sum(F(x)) = [ sum_j( w_j * F_j(x) ) ]

where F is a vector field. This implies that the Operator.domain is a power space of a discretized function space. For example, if X is a DiscretizedSpace space, then ProductSpace(X, d) is a valid domain for any positive integer d.

Attributes

adjoint

Adjoint of this 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.

is_weighted

True if weighting is not 1 or all ones.

range

Set in which the result of an evaluation of this operator lies.

vecfield

Fixed vector field G of this inner product.

weights

Weighting array of this operator.

Methods

_call(self, vf, out)	Implement self(vf, out).
derivative(self, point)	Return the operator derivative at point.
norm(self[, estimate])	Return the operator norm of this operator.

__init__(self, vfspace, weighting=None)

Initialize a new instance.

Parameters

vfspaceProductSpace

Space of vector fields on which the operator acts. It has to be a product space of identical spaces, i.e. a power space.

weightingarray-like or float, optional

Weighting array or constant for the sum. If an array is given, its length must be equal to len(domain). By default, the weights are is taken from domain.weighting. Note that this excludes unusual weightings with custom inner product, norm or dist.

Examples

We make a tiny vector field space in 2D and create the standard point-wise sum operator on that space. The operator maps a vector field to a scalar function:

>>> spc = odl.uniform_discr([-1, -1], [1, 1], (1, 2))
>>> vfspace = odl.ProductSpace(spc, 2)
>>> pw_sum = PointwiseSum(vfspace)
>>> pw_sum.range == spc
True

Now we can calculate the sum in each point:

>>> x = vfspace.element([[[1, -4]],
...                      [[0, 3]]])
>>> print(pw_sum(x))
[[ 1., -1.]]