mrpro.operators.NonUniformFastFourierOp

class mrpro.operators.NonUniformFastFourierOp[source]

Bases: LinearOperator

Non-Uniform Fast Fourier Operator class.

__init__(direction: Sequence[Literal['x', 'y', 'z', -3, -2, -1]], recon_matrix: SpatialDimension[int] | Sequence[int], encoding_matrix: SpatialDimension[int] | Sequence[int], traj: KTrajectory, oversampling: float = 2.0) → None[source]

Initialize Non-Uniform Fast Fourier Operator.

Note

Consider using FourierOp instead of this operator. It automatically detects if a non-uniform or regular fast Fourier transformation is required and can also be constructed automatically from a mrpro.data.KData object.

Note

The NUFFT is scaled such that it matches ‘orthonormal’ FFT scaling for cartesian trajectories. This is different from other packages, which apply scaling based on the size of the oversampled grid.

Parameters:

• direction (Sequence[Literal['x', 'y', 'z', -3, -2, -1]]) – direction along which non-uniform FFT is applied

• recon_matrix (Union[SpatialDimension[int], Sequence[int]]) – Dimension of the reconstructed image. If this is SpatialDimension only values of directions will be used. Otherwise, it should be a Sequence of the same length as direction.

• encoding_matrix (Union[SpatialDimension[int], Sequence[int]]) – Dimension of the encoded k-space. If this is SpatialDimension only values of directions will be used. Otherwise, it should be a Sequence of the same length as direction.

• traj (KTrajectory) – The k-space trajectories where the frequencies are sampled.

• oversampling (float, default: 2.0) – Oversampling used for interpolation in non-uniform FFTs. On GPU, 2.0 uses an optimized kernel, any value > 1.0 will work. On CPU, there are kernels for 2.0 and 1.25. The latter saves memory. Set to 0.0 for automatic selection.

property gram: LinearOperator[source]

Return the gram operator.

property H: LinearOperator[source]

Adjoint operator.

Obtains the adjoint of an instance of this operator as an AdjointLinearOperator, which itself is a an LinearOperator that can be applied to tensors.

Note: linear_operator.H.H == linear_operator

__call__(x: Tensor) → tuple[Tensor][source]

Apply Non-Uniform Fast Fourier Transform (NUFFT) from image to k-space (Type 2).

Transforms data from image space to non-uniform k-space locations.

Parameters:

x (Tensor) – Coil image data, typically with shape (..., coils, z, y, x).

Returns:

Coil k-space data at non-uniform locations, with shape (..., coils, k2, k1, k0).

adjoint(x: Tensor) → tuple[Tensor][source]

Apply adjoint NUFFT from k-space to image space (Type 1).

Transforms data from non-uniform k-space to a Cartesian image grid.

Parameters:

x (Tensor) – Coil k-space data at non-uniform locations, with shape (..., coils, k2, k1, k0).

Returns:

Coil image data on a Cartesian grid, with shape (..., coils, z, y, x).

forward(x: Tensor) → tuple[Tensor][source]

Apply forward of NonUniformFastFourierOp.

Note

Prefer calling the instance of the NonUniformFastFourierOp operator as operator(x) over directly calling this method. See this PyTorch discussion.

operator_norm(initial_value: Tensor, dim: Sequence[int] | None, max_iterations: int = 20, relative_tolerance: float = 1e-4, absolute_tolerance: float = 1e-5, callback: Callable[[Tensor], None] | None = None) → Tensor[source]

Power iteration for computing the operator norm of the operator.

Parameters:

• initial_value (Tensor) – initial value to start the iteration; must be element of the domain. if the initial value contains a zero-vector for one of the considered problems, the function throws an ValueError.

• dim (Sequence[int] | None) –

  The dimensions of the tensors on which the operator operates. The choice of dim determines how the operator norm is inperpreted. For example, for a matrix-vector multiplication with a batched matrix tensor of shape (batch1, batch2, row, column) and a batched input tensor of shape (batch1, batch2, row):

  • If dim=None, the operator is considered as a block diagonal matrix with batch1*batch2 blocks and the result is a tensor containing a single norm value (shape (1, 1, 1)).

  • If dim=(-1), batch1*batch2 matrices are considered, and for each a separate operator norm is computed.

  • If dim=(-2,-1), batch1 matrices with batch2 blocks are considered, and for each matrix a separate operator norm is computed.

  Thus, the choice of dim determines implicitly determines the domain of the operator.

• max_iterations (int, default: 20) – maximum number of iterations

• relative_tolerance (float, default: 1e-4) – absolute tolerance for the change of the operator-norm at each iteration; if set to zero, the maximal number of iterations is the only stopping criterion used to stop the power iteration.

• absolute_tolerance (float, default: 1e-5) – absolute tolerance for the change of the operator-norm at each iteration; if set to zero, the maximal number of iterations is the only stopping criterion used to stop the power iteration.

• callback (Callable[[Tensor], None] | None, default: None) – user-provided function to be called at each iteration

Returns:

An estimaton of the operator norm. Shape corresponds to the shape of the input tensor initial_value with the dimensions specified in dim reduced to a single value. The pointwise multiplication of initial_value with the result of the operator norm will always be well-defined.

__add__(other: LinearOperator | Tensor | complex) → LinearOperator[source]

__add__(other: Operator[Tensor, tuple[Tensor]]) → Operator[Tensor, tuple[Tensor]]

Operator addition.

Returns lambda x: self(x) + other(x) if other is a operator, lambda x: self(x) + other if other is a tensor

__and__(other: LinearOperator) → LinearOperatorMatrix[source]

Vertical stacking of two LinearOperators.

A&B is a LinearOperatorMatrix with two rows, with (A&B)(x) == (A(x), B(x)). See mrpro.operators.LinearOperatorMatrix for more information.

__matmul__(other: LinearOperator) → LinearOperator[source]

__matmul__(other: Operator[Unpack[Tin2], tuple[Tensor]] | Operator[Unpack[Tin2], tuple[Tensor, ...]]) → Operator[Unpack[Tin2], tuple[Tensor]]

Operator composition.

Returns lambda x: self(other(x))

__mul__(other: Tensor | complex) → LinearOperator[source]

Operator elementwise left multiplication with tensor/scalar.

Returns lambda x: self(x*other)

__or__(other: LinearOperator) → LinearOperatorMatrix[source]

Horizontal stacking of two LinearOperators.

A|B is a LinearOperatorMatrix with two columns, with (A|B)(x1,x2) == A(x1) + B(x2). See mrpro.operators.LinearOperatorMatrix for more information.

__radd__(other: Tensor | complex) → LinearOperator[source]

Operator addition.

Returns lambda x: self(x) + other*x

__rmul__(other: Tensor | complex) → LinearOperator[source]

Operator elementwise right multiplication with tensor/scalar.

Returns lambda x: other*self(x)