Basis sets

class mumott.methods.basis_sets.SphericalHarmonics(probed_coordinates=None, ell_max=0, enforce_friedel_symmetry=True)

Basis set class for spherical harmonics, the canonical representation of polynomials on the unit sphere and a simple way of representing band-limited spherical functions which allows for easy computations of statistics and is suitable for analyzing certain symmetries.

Parameters

• ell_max (int) – The bandlimit of the spherical functions that you want to be able to represent. A good rule of thumb is that ell_max should not exceed the number of detector segments minus 1.

• probed_coordinates (ProbedCoordinates) – Optional. A container with the coordinates on the sphere probed at each detector segment by the experimental method. Its construction from the system geometry is method-dependent. By default, an empty instance of ProbedCoordinates is created.

• enforce_friedel_symmetry (bool) – If set to True, Friedel symmetry will be enforced, using the assumption that points on opposite sides of the sphere are equivalent. This results in only even ell being used.

property ell_indices: ndarray[Any, dtype[int]]

The ell associated with each coefficient and its corresponding spherical harmonic. Updated when ell_max changes.

Notes

The word ell is used to represent the cursive small L, also written \(\ell\), often used as an index for the degree of the Legendre polynomial in the definition of the spherical harmonics.

property ell_max: int

The maximum ell used to represent spherical functions.

Notes

The word ell is used to represent the cursive small L, also written \(\ell\), often used as an index for the degree of the Legendre polynomial in the definition of the spherical harmonics.

property emm_indices: ndarray[Any, dtype[int]]

The emm associated with each coefficient and its corresponding spherical harmonic. Updated when ell_max changes.

Notes

For consistency with ell_indices, and to avoid visual confusion with other letters, emm is used to represent the index commonly written \(m\) in mathematical notation, the frequency of the sine-cosine parts of the spherical harmonics, often called the spherical harmonic order.

forward(coefficients, indices=None)

Carries out a forward computation of projections from spherical harmonic space into detector space, for one or several tomographic projections.

Parameters

• coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients, of arbitrary shape so long as the last axis has the same size as ell_indices, and if indices is None or greater than one, the first axis should have the same length as indices

• indices (Optional[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]]) – Optional. Indices of the tomographic projections for which the forward computation is to be performed. If None, the forward computation will be performed for all projections.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

Returns

An array of values on the detector corresponding to the coefficients given. If indices contains exactly one index, the shape is (coefficients.shape[:-1], J) where J is the number of detector segments. If indices is None or contains several indices, the shape is (N, coefficients.shape[1:-1], J) where N is the number of tomographic projections for which the computation is performed.

Notes

The assumption is made in this implementation that computations over several indices act on sets of images from different projections. For special usage where multiple projections of entire fields is desired, it may be better to use projection_matrix directly. This also applies to gradient().

get_covariances(u, v, resolve_spectrum=False)

Returns the covariances of the spherical functions represented by two coefficient arrays.

Parameters

• u (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – The first coefficient array, of arbitrary shape except its last dimension must be the same length as the length of ell_indices.

• v (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – The second coefficient array, of the same shape as u.

• resolve_spectrum (bool) – Optional. Whether to resolve the product according to each frequency band, given by the coefficients of each ell in ell_indices. Default value is False.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

Returns

An array of the covariances of the spherical functions represented by u and v. Has the shape (u.shape[:-1]) if resolve_spectrum is False, and (u.shape[:-1] + (ell_max // 2 + 1,)) if resolve_spectrum is True, where ell_max is SphericalHarmonics.ell_max.

Notes

Calling this function is equivalent to calling get_inner_product() with spectral_moments=np.unique(ell_indices[ell_indices > 0]) where ell_indices is SphericalHarmonics.ell_indices. See the note to get_inner_product() for mathematical details.

get_inner_product(u, v, resolve_spectrum=False, spectral_moments=None)

Retrieves the inner product of two coefficient arrays.

Notes

The canonical inner product in a spherical harmonic representation is \(\sum_\ell N(\ell) \sum_m u_m^\ell v_m^\ell\), where \(N(\ell)\) is a normalization constant (which is unity for the \(4\pi\) normalization). This inner product is a rotational invariant. The rotational invariance also holds for any partial sums over \(\ell\). One can define a function of \(\ell\) that returns such products, namely \(S(\ell, u, v) = N(\ell)\sum_m u_m^\ell v_m^\ell\), called the spectral power function. The sum \(\sum_{\ell = 1}S(\ell)\) is equal to the covariance of the band-limited spherical functions represented by \(u\) and \(v\), and each \(S(\ell, u, v)\) is the contribution to the covariance of the band \(\ell\). See also the SHTOOLS documentation for an excellent overview of this.

Parameters

• u (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – The first coefficient array, of arbitrary shape and dimension, except the last dimension must be the same as the length of ell_indices.

• v (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – The second coefficient array, of the same shape as u.

• resolve_spectrum (bool) – Optional. Whether to resolve the product according to each frequency band, given by the coefficients of each ell in ell_indices. Defaults to False, which means that the sum of every component of the spectrum is returned. If True, components are returned in order of ascending ell. The ell included in the spectrum depends on spectral_moments.

• spectral_moments (Optional[List[int]]) – Optional. List of particular values of ell to calculate the inner product for. Defaults to None, which is identical to including all values of ell in the calculation. If spectral_moments contains all nonzero values of ell and resolve_spectrum is False, the covariance of v and u will be calculated (the sum of the inner product over all non-zero ell If resolve_spectrum is True, the covariance per ell in spectral_moments, will be calculated, i.e., the inner products will not be summed over.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

Returns

An array of the inner products of the spherical functions represented by u and v. Has the shape (u.shape[:-1]) if resolve_spectrum is False, (u.shape[:-1] + (ell_max // 2 + 1,)) if resolve_spectrum is True and spectral_moments is None, and finally the shape (u.shape[:-1] + (np.unique(spectral_moments).size,)) if resolve_spectrum is True and spectral_moments is a list of integers found in ell_indices

get_output(coefficients)

Returns a dictionary of output data for a given array of spherical harmonic coefficients.

Parameters

coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients of arbitrary shape and dimensions, except its last dimension must be the same length as ell_indices. Computations only operate over the last axis of coefficents, so derived properties in the output will have the shape (*coefficients.shape[:-1], ...).

Return type

Dict[str, Any]

Returns

A dictionary containing two sub-dictionaries, basis_set and spherical_functions. basis_set contains information particular to SphericalHarmonics, whereas spherical_functions contains information about the spherical functions represented by the coefficients which are not specific to the chosen representation.

Notes

In detail, the two sub-dictionaries basis_set and spherical_functions have the following members:

basis_set

name

The name of the basis set, i.e., 'SphericalHarmonicParameters'

coefficients

A copy of coefficients.

ell_max

A copy of ell_max.

ell_indices

A copy of ell_indices.

emm_indices

A copy of emm_indices.

projection_matrix

A copy of projection_matrix.

spherical_functions

means

The spherical means of each function represented by coefficients.

variances

The spherical variances of each function represented by coefficients. If ell_max is 0, all variances will equal zero.

r2_tensors

The traceless symmetric rank-2 tensor component of each function represented by coefficients, in 6-element form, in the order [xx, yy, zz, yz, xz, xy], i.e., by the Voigt convention. The matrix form can be recovered as r2_tensors[…, tensor_to_matrix_indices], yielding matrix elements [[xx, xy, xz], [xy, yy, yz], [xz, yz, zz]]. If ell_max is 0, all tensors have elements [1, 0, -1, 0, 0, 0].

tensor_to_matrix_indices

A list of indices to help recover the matrix from the 2-element form of the rank-2 tensors, equalling precisely [[0, 5, 4], [5, 1, 3], [4, 3, 2]]

eigenvalues

The eigenvalues of the rank-2 tensors, sorted in ascending order in the last index. If ell_max is 0, the eigenvalues will always be (1, 0, -1)

eigenvectors

The eigenvectors of the rank-2 tensors, sorted with their corresponding eigenvectors in the last index. Thus, eigenvectors[..., 0] gives the eigenvector corresponding to the smallest eigenvalue, and eigenvectors[..., 2] gives the eigenvector corresponding to the largest eigenvalue. Generally, one of these two eigenvectors is used to define the orientation of a function, depending on whether it is characterized by a minimum (0) or a maximum (2). The middle eigenvector (1) is typically only used for visualizations. If ell_max is 0, the eigenvectors will be the Cartesian basis vectors.

main_orientations

The estimated main orientations from the largest absolute eigenvalues. If ell_max is 0, the main orientation will be the x-axis.

main_orientation_symmetries

The strength or definiteness of the main orientation, calculated from the quotient of the absolute middle and signed largest eigenvalues of the rank-2 tensor. If 0, the orientation is totally ambiguous. The orientation is completely transversal if the value is -1 (orientation represents a minimum), and completely longitudinal if the value is 1 (orientation represents a maximum). If ell_max is 0, the main orientations are all totally ambiguous.

normalized_standard_deviations

A relative measure of the overall anisotropy of the spherical functions. Equals \(\sqrt{\sigma^2 / \mu}\), where \(\sigma^2\) is the variance and \(\mu\) is the mean. The places where \(\mu=0\) have been set to 0. If ell_max is 0, the normalized standard deviations will always be zero.

power_spectra

The spectral powers of each ell in ell_indices, for each spherical function, sorted in ascending ell. If ell_max is 0, each function will have only one element, equal to the mean squared.

power_spectra_ell

An array containing the corresponding ell to each of the last indices in power_spectra. Equal to np.unique(ell_indices).

gradient(coefficients, indices=None)

Carries out a gradient computation of projections from spherical harmonic space into detector space, for one or several tomographic projections.

Parameters

• coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients (or residuals) of arbitrary shape so long as the last axis has the same size as the number of detector segments.

• indices (Optional[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]]) – Optional. Indices of the tomographic projections for which the gradient computation is to be performed. If None, the gradient computation will be performed for all projections.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

Returns

An array of gradient values based on the coefficients given. If indices contains exactly one index, the shape is (coefficients.shape[:-1], J) where J is the number of detector segments. If indices is None or contains several indices, the shape is (N, coefficients.shape[1:-1], J) where N is the number of tomographic projections for which the computation is performed.

Notes

When solving an inverse problem, one should not to attempt to optimize the coefficients directly using the gradient one obtains by applying this method to the data. Instead, one must either take the gradient of the residual between the forward() computation of the coefficients and the data. Alternatively one can apply both the forward and the gradient computation to the coefficients to be optimized, and the gradient computation to the data, and treat the residual of the two as the gradient of the optimization coefficients. The approaches are algebraically equivalent, but one may be more efficient than the other in some circumstances.

property probed_coordinates: ProbedCoordinates

The instance of mumott.ProbedCoordinates attached to this object. If modified via the mumott.ProbedCoordinates.vector attribute, the mumott.methods.SphericalHarmonics instance is automatically updated when needed.

property projection_matrix: ndarray[Any, dtype[_ScalarType_co]]

The matrix used to project spherical functions from the unit sphere onto the detector. If v is a vector of spherical harmonic coefficients, and M is the projection_matrix, then M @ v gives the corresponding values on the detector segments associated with each projection. M[i] @ v gives the values on the detector segments associated with projection i.

If r is a residual between a projection from spherical to detector space and data from projection i, then M[i].T @ r gives the associated gradient in spherical harmonic space.

class mumott.methods.basis_sets.TrivialBasis(channels=1)

Basis set class for the trivial basis, i.e., the identity basis. This can be used as a scaffolding class when implementing, e.g., scalar tomography, as it implements all the necessary functionality to qualify as a BasisSet.

Parameters

channels (int) – Number of channels in the last index. Default is 1. For scalar data, the default value of 1 is appropriate. For any other use-case, where the representation on the sphere and the representation in detector space are equivalent, such as reconstructing scalars of multiple q-ranges at once, a different number of channels can be set.

property channels: int

The number of channels this basis supports.

forward(coefficients, *args, **kwargs)

Returns the provided coefficients with no modification.

Parameters

coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients, of arbitrary shape, except the last index must specify the same number of channels as was specified for this basis.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

Returns

The provided :attr`coefficients` with no modification.

Notes

The args and kwargs are ignored, but included for compatibility with methods that input other arguments.

get_inner_product(u, v)

Retrieves the inner product of two coefficient arrays, that is to say, the sum-product over the last axis.

Parameters

• u (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – The first coefficient array, of arbitrary shape and dimension.

• v (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – The second coefficient array, of the same shape as u.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

get_output(coefficients)

Returns a dictionary of output data for a given array of coefficients.

Parameters

coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients of arbitrary shape and dimension. Computations only operate over the last axis of coefficents, so derived properties in the output will have the shape (*coefficients.shape[:-1], ...).

Return type

Dict[str, Any]

Returns

A dictionary containing a dictionary with the field basis_set.

Notes

In detail, the dictionary under the key basis_set contains:

basis_set

name

The name of the basis set, i.e., 'TrivialBasis'

coefficients

A copy of coefficients.

projection_matrix

The identity matrix of the same size as the number of chanenls.

gradient(coefficients, *args, **kwargs)

Returns the provided coefficients with no modification.

Parameters

coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients of arbitrary shape except the last index must specify the same number of channels as was specified for this basis.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

Returns

The provided :attr`coefficients` with no modification.

Notes

The args and kwargs are ignored, but included for compatibility with methods that input other argumetns.

property is_dirty: bool

property probed_coordinates: ProbedCoordinates

The instance of mumott.ProbedCoordinates attached to this object. If modified via the mumott.ProbedCoordinates.vector attribute, the mumott.methods.TrivialBasis instance is automatically updated when needed.

property projection_matrix

The identity matrix of the same rank as the number of channels specified.

class mumott.methods.basis_sets.GaussianKernels(probed_coordinates=None, grid_scale=4, kernel_scale_parameter=1.0, enforce_friedel_symmetry=True)

Basis set class for gaussian kernels, a simple local representation on the sphere. The kernels follow a pseudo-even distribution similar to that described by Y. Kurihara in 1965, except with offsets added at the poles.

Notes

The Gaussian kernel at location \(\rho_i\) is given by

\[N_i \exp\left[ -\frac{1}{2} \left(\frac{d(\rho_i, r)}{\sigma}\right)^2 \right]\]

\[\sigma = \frac{\nu \pi}{2 (g + 1)}\]

where \(\nu\) is the kernel scale parameter and \(g\) is the grid scale, and

\[d(\rho, r) = \arctan_2(\Vert \rho \times r \Vert, \rho \cdot r),\]

that is, the great circle distance from the kernel location \(\rho\) to the probed location \(r\). If Friedel symmetry is assumed, the expression is instead

\[d(\rho, r) = \arctan_2(\Vert \rho \times r \Vert, \vert \rho \cdot r \vert)\]

The normalization factor \(\rho_i\) is given by

\[N_i = \sum_j \exp\left[ -\frac{1}{2} \left( \frac{d(\rho_i, \rho_j)}{\sigma} \right)^2 \right]\]

where the sum goes over the coordinates of all grid points. This leads to an approximately even spherical function, such that a set of coefficients which are all equal is approximately isotropic, to the extent possible with respect to restrictions imposed by grid resolution and scale parameter.

Parameters

• probed_coordinates (ProbedCoordinates) – Optional. A container with the coordinates on the sphere probed at each detector segment by the experimental method. Its construction from the system geometry is method-dependent. By default, an empty instance of mumott.ProbedCoordinates is created.

• grid_scale (int) – The size of the coordinate grid on the sphere. Denotes the number of azimuthal rings between the pole and the equator, where each ring has between 2 and 2 * grid_scale points along the azimuth.

• kernel_scale_parameter (float) – The scale parameter of the kernel in units of \(\frac{\pi}{2 (g + 1)}\), where \(g\) is grid_scale.

• enforce_friedel_symmetry (bool) – If set to True, Friedel symmetry will be enforced, using the assumption that points on opposite sides of the sphere are equivalent.

property enforce_friedel_symmetry: bool

If True, Friedel symmetry is enforced, i.e., the point \(-r\) is treated as equivalent to \(r\).

forward(coefficients, indices=None)

Carries out a forward computation of projections from Gaussian kernel space into detector space, for one or several tomographic projections.

Parameters

• coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients, of arbitrary shape so long as the last axis has the same size as kernel_scale_parameter, and if indices is None or greater than one, the first axis should have the same length as indices

• indices (Optional[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]]) – Optional. Indices of the tomographic projections for which the forward computation is to be performed. If None, the forward computation will be performed for all projections.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

Returns

An array of values on the detector corresponding to the coefficients given. If indices contains exactly one index, the shape is (coefficients.shape[:-1], J) where J is the number of detector segments. If indices is None or contains several indices, the shape is (N, coefficients.shape[1:-1], J) where N is the number of tomographic projections for which the computation is performed.

Notes

The assumption is made in this implementation that computations over several indices act on sets of images from different projections. For special usage where multiple projections of entire fields are desired, it may be better to use projection_matrix directly. This also applies to gradient().

get_amplitudes(coefficients, probed_coordinates=None)

Computes the amplitudes of the spherical function represented by the provided coefficients at the probed_coordinates.

Parameters

• coefficients (ndarray[Any, dtype[float]]) – An array of coefficients of arbitrary shape, provided that the last dimension contains the coefficients for one spherical function.

• probed_coordinates (Optional[ProbedCoordinates]) – An instance of mumott.core.ProbedCoordinates with its vector attribute indicating the points of the sphere for which to evaluate the amplitudes.

Return type

ndarray[Any, dtype[float]]

get_inner_product(u, v)

Retrieves the inner product of two coefficient arrays, that is to say, the sum-product over the last axis.

Parameters

• u (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – The first coefficient array, of arbitrary shape and dimension, so long as the number of coefficients equals the length of this GaussianKernels instance.

• v (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – The second coefficient array, of the same shape as u.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

get_output(coefficients)

Returns a dictionary of output data for a given array of basis set coefficients.

Parameters

coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients of arbitrary shape and dimensions, except its last dimension must be the same length as the len of this instance. Computations only operate over the last axis of coefficents, so derived properties in the output will have the shape (*coefficients.shape[:-1], ...).

Return type

Dict[str, Any]

Returns

A dictionary containing two sub-dictionaries, basis_set and spherical_harmonic_analysis. basis_set contains information particular to GaussianKernels, whereas spherical_harmonic_analysis contains an analysis of the spherical function using a spherical harmonic transform.

Notes

In detail, the two sub-dictionaries basis_set and spherical_harmonic_analysis have the following members:

basis_set

name

The name of the basis set, i.e., 'GaussianKernels'

coefficients

A copy of coefficients.

grid_scale

A copy of grid_scale.

kernel_Scale_paramter

A copy of kernel_scale_parameter.

enforce_friedel_symmetry

A copy of enforce_friedel_symmetry.

projection_matrix

A copy of projection_matrix.

spherical_harmonic_analysis

An analysis of the spherical function in terms of spherical harmonics. See SphericalHarmonics.get_output for details.

get_spherical_harmonic_coefficients(coefficients, ell_max=None)

Computes the spherical harmonic coefficients of the spherical function represented by the provided coefficients using a Driscoll-Healy grid.

For details on the Driscoll-Healy grid, see the SHTools page for a comprehensive overview.

Parameters

• coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients of arbitrary shape, provided that the last dimension contains the coefficients for one function.

• ell_max (Optional[int]) – The bandlimit of the spherical harmonic expansion. By default, it is 2 * grid_scale.

gradient(coefficients, indices=None)

Carries out a gradient computation of projections from Gaussian kernel space into detector space for one or several tomographic projections.

Parameters

• coefficients (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – An array of coefficients (or residuals) of arbitrary shape so long as the last axis has the same size as the number of detector segments.

• indices (Optional[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]]) – Optional. Indices of the tomographic projections for which the gradient computation is to be performed. If None, the gradient computation will be performed for all projections.

Return type

ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]

Returns

An array of gradient values based on the coefficients given. If indices contains exactly one index, the shape is (coefficients.shape[:-1], J) where J is the number of detector segments. If indices is None or contains several indices, the shape is (N, coefficients.shape[1:-1], J) where N is the number of tomographic projections for which the computation is performed.

Notes

When solving an inverse problem, one should not attempt to optimize the coefficients directly using the gradient one obtains by applying this method to the data. Instead, one must either take the gradient of the residual between the forward() computation of the coefficients and the data. Alternatively one can apply both the forward and the gradient computation to the coefficients to be optimized, and the gradient computation to the data, and treat the residual of the two as the gradient of the optimization coefficients. The approaches are algebraically equivalent, but one may be more efficient than the other in some circumstances. However, normally, the projection between detector and GaussianKernel space is only a small part of the overall computation, so there is typically not much to be gained from optimizing it.

property grid: Tuple[ndarray[Any, dtype[float]], ndarray[Any, dtype[float]]]

Returns the polar and azimuthal angles of the grid used by the basis.

Returns

• A Tuple with contents (polar_angle, azimuthal_angle), where the

• polar angle is defined as \(\arccos(z)\).

property grid_hash: str

Returns a hash of grid.

property grid_scale: int

The number of azimuthal rings from each pole to the equator in the spherical grid.

property is_dirty: bool

property kernel_scale_parameter: float

The scale parameter for each kernel.

property probed_coordinates: ProbedCoordinates

The instance of mumott.ProbedCoordinates attached to this object. If modified via the mumott.ProbedCoordinates.vector attribute, the mumott.methods.GaussianKernels instance is automatically updated when needed.

property projection_matrix: ndarray[Any, dtype[_ScalarType_co]]

The matrix used to project spherical functions from the unit sphere onto the detector. If v is a vector of gaussian kernel coefficients, and M is the projection_matrix, then M @ v gives the corresponding values on the detector segments associated with each projection. M[i] @ v gives the values on the detector segments associated with projection i.

If r is a residual between a projection from Gaussian kernel to detector space and data from projection i, then M[i].T @ r gives the associated gradient in Gaussian kernel space.

property projection_matrix_hash: str

Returns a hash of projection_matrix.