Skip to content

Fields, Operators and Data Sets

All three kinds of object are JAX pytrees, so they can be passed through jax.jit, jax.grad and jax.vmap.

Fields

cmb_lensing.fields.FlatS0

Bases: Field

A spin-0 field on a flat nside x nside patch: temperature, or the lensing potential phi.

Supports +, -, * and / with another FlatS0 or a scalar, element by element.

Attributes:

Name Type Description
scalar_matrix ndarray

The field, an (nside, nside//2+1) rfft2 array in Fourier space or an (nside, nside) real array in map space.

basis int

Basis.FOURIER or Basis.MAP. Convert with fourier() / map().

nside int

Number of pixels on a side.

theta_pix float

Pixel width in arcmin.

pix_width float

Pixel width in radians.

fourier_weights ndarray

Weight of each rfft2 mode in inner products (2 in the bulk, 1 on the self-conjugate columns).

Source code in cmb_lensing/fields.py
@struct.dataclass
class FlatS0(Field):
    """A spin-0 field on a flat nside x nside patch: temperature, or the lensing potential phi.

    Supports +, -, * and / with another `FlatS0` or a scalar, element by element.

    Attributes:
        scalar_matrix: The field, an (nside, nside//2+1) rfft2 array in Fourier space or an
            (nside, nside) real array in map space.
        basis: `Basis.FOURIER` or `Basis.MAP`. Convert with `fourier()` / `map()`.
        nside: Number of pixels on a side.
        theta_pix: Pixel width in arcmin.
        pix_width: Pixel width in radians.
        fourier_weights: Weight of each rfft2 mode in inner products (2 in the bulk, 1 on
            the self-conjugate columns).
    """

    scalar_matrix: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    parametrization: int = flax.struct.field(default_factory = lambda: Parametrization.T)

    def _matrix_names(self):
        return ["scalar_matrix"]

cmb_lensing.fields.FlatS2

Bases: Field

A spin-2 (polarization) field on a flat patch, stored as E/B or Q/U.

Supports the same element-wise arithmetic as FlatS0. Convert between the parametrizations with qu2eb() / eb2qu().

Attributes:

Name Type Description
polar_matrix_1 ndarray

E (or Q) component.

polar_matrix_2 ndarray

B (or U) component.

parametrization int

Parametrization.EB or Parametrization.QU.

basis int

Basis.FOURIER or Basis.MAP.

nside int

Number of pixels on a side.

theta_pix float

Pixel width in arcmin.

pix_width float

Pixel width in radians.

fourier_weights ndarray

Weight of each rfft2 mode in inner products.

Source code in cmb_lensing/fields.py
@struct.dataclass
class FlatS2(Field):
    """A spin-2 (polarization) field on a flat patch, stored as E/B or Q/U.

    Supports the same element-wise arithmetic as `FlatS0`. Convert between the
    parametrizations with `qu2eb()` / `eb2qu()`.

    Attributes:
        polar_matrix_1: E (or Q) component.
        polar_matrix_2: B (or U) component.
        parametrization: `Parametrization.EB` or `Parametrization.QU`.
        basis: `Basis.FOURIER` or `Basis.MAP`.
        nside: Number of pixels on a side.
        theta_pix: Pixel width in arcmin.
        pix_width: Pixel width in radians.
        fourier_weights: Weight of each rfft2 mode in inner products.
    """

    polar_matrix_1: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    polar_matrix_2: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    parametrization: int = flax.struct.field(default_factory = lambda: Parametrization.EB)

    def _matrix_names(self):
        return ["polar_matrix_1", "polar_matrix_2"]

cmb_lensing.fields.FlatS02

Bases: Field

A temperature + polarization field on a flat patch: T together with E/B (or Q/U).

Supports the same element-wise arithmetic as FlatS0.

Attributes:

Name Type Description
scalar_matrix ndarray

T component.

polar_matrix_1 ndarray

E (or Q) component.

polar_matrix_2 ndarray

B (or U) component.

parametrization int

Parametrization.EB or Parametrization.QU.

basis int

Basis.FOURIER or Basis.MAP.

nside int

Number of pixels on a side.

theta_pix float

Pixel width in arcmin.

pix_width float

Pixel width in radians.

fourier_weights ndarray

Weight of each rfft2 mode in inner products.

Source code in cmb_lensing/fields.py
@struct.dataclass
class FlatS02(Field):
    """A temperature + polarization field on a flat patch: T together with E/B (or Q/U).

    Supports the same element-wise arithmetic as `FlatS0`.

    Attributes:
        scalar_matrix: T component.
        polar_matrix_1: E (or Q) component.
        polar_matrix_2: B (or U) component.
        parametrization: `Parametrization.EB` or `Parametrization.QU`.
        basis: `Basis.FOURIER` or `Basis.MAP`.
        nside: Number of pixels on a side.
        theta_pix: Pixel width in arcmin.
        pix_width: Pixel width in radians.
        fourier_weights: Weight of each rfft2 mode in inner products.
    """

    scalar_matrix: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    polar_matrix_1: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    polar_matrix_2: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    parametrization: int = flax.struct.field(default_factory = lambda: Parametrization.EB)

    def _matrix_names(self):
        return ["scalar_matrix", "polar_matrix_1", "polar_matrix_2"]

Operators

cmb_lensing.matrix_operators.DiagonalScalar

Bases: FieldOperator

An operator diagonal in Fourier space acting on FlatS0 fields (e.g. C_TT, C_phi).

operator * field multiplies mode by mode. Operators also combine with each other and with scalars through +, - and *; pinv and log_det are defined for them.

Attributes:

Name Type Description
scalar_matrix ndarray

The diagonal, an (nside, nside//2+1) array on the rfft2 grid.

nside int

Number of pixels on a side.

theta_pix float

Pixel width in arcmin.

pix_width float

Pixel width in radians.

fourier_weights ndarray

Weight of each rfft2 mode.

Source code in cmb_lensing/matrix_operators.py
@struct.dataclass
class DiagonalScalar(FieldOperator):
    """An operator diagonal in Fourier space acting on `FlatS0` fields (e.g. C_TT, C_phi).

    `operator * field` multiplies mode by mode. Operators also combine with each other and
    with scalars through +, - and *; `pinv` and `log_det` are defined for them.

    Attributes:
        scalar_matrix: The diagonal, an (nside, nside//2+1) array on the rfft2 grid.
        nside: Number of pixels on a side.
        theta_pix: Pixel width in arcmin.
        pix_width: Pixel width in radians.
        fourier_weights: Weight of each rfft2 mode.
    """

    scalar_matrix: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())

    def _matrix_names(self):
        return {"scalar_matrix"}

    #NOTE we must define operator-operator, operator-field, and operator scalar multiplication
    def __mul__(self, other):
        if isinstance(other, DiagonalScalar):
            return self.replace(scalar_matrix = self.scalar_matrix * other.scalar_matrix)
        elif isinstance(other, FlatS0):
            return other.replace(scalar_matrix = self.scalar_matrix * other.scalar_matrix)
        else:
            return self.replace(scalar_matrix = self.scalar_matrix * other)

    def __rmul__(self, other):
        return self.__mul__(other)

cmb_lensing.matrix_operators.DiagonalEB

Bases: FieldOperator

An operator acting on FlatS2 fields, diagonal in Fourier space with separate E and B blocks (no EB coupling).

Attributes:

Name Type Description
matrix_EE ndarray

E block, an (nside, nside//2+1) array on the rfft2 grid.

matrix_BB ndarray

B block.

nside int

Number of pixels on a side.

theta_pix float

Pixel width in arcmin.

pix_width float

Pixel width in radians.

fourier_weights ndarray

Weight of each rfft2 mode.

Source code in cmb_lensing/matrix_operators.py
@struct.dataclass
class DiagonalEB(FieldOperator):
    """An operator acting on `FlatS2` fields, diagonal in Fourier space with separate E and B
    blocks (no EB coupling).

    Attributes:
        matrix_EE: E block, an (nside, nside//2+1) array on the rfft2 grid.
        matrix_BB: B block.
        nside: Number of pixels on a side.
        theta_pix: Pixel width in arcmin.
        pix_width: Pixel width in radians.
        fourier_weights: Weight of each rfft2 mode.
    """

    #NOTE these matrices have the following 2 x 2 block diagonal format
    #[EE 0 ]
    #[0  BB]

    matrix_EE: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    matrix_BB: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())

    def _matrix_names(self):
        return {"matrix_EE", "matrix_BB"}

    def __mul__(self, other):
        if isinstance(other, DiagonalEB):
            return self.replace(matrix_EE = self.matrix_EE * other.matrix_EE,
                                matrix_BB = self.matrix_BB * other.matrix_BB)
        elif isinstance(other, FlatS2):
            return other.replace(polar_matrix_1 = self.matrix_EE * other.polar_matrix_1,
                                 polar_matrix_2 = self.matrix_BB * other.polar_matrix_2)
        else:
            return self.replace(matrix_EE = self.matrix_EE * other,
                                matrix_BB = self.matrix_BB * other)

    def __rmul__(self, other):
        return self.__mul__(other)

cmb_lensing.matrix_operators.BlockTEB

Bases: FieldOperator

An operator acting on FlatS02 fields: per Fourier mode a 2 x 2 T/E block plus an independent B block.

Products with another BlockTEB are matrix products of the T/E blocks, so they do not commute. pinv and log_det use Schur complements.

Attributes:

Name Type Description
matrix_TT ndarray

TT block, an (nside, nside//2+1) array on the rfft2 grid.

matrix_TE ndarray

TE block.

matrix_ET ndarray

ET block.

matrix_EE ndarray

EE block.

matrix_BB ndarray

BB block.

nside int

Number of pixels on a side.

theta_pix float

Pixel width in arcmin.

pix_width float

Pixel width in radians.

fourier_weights ndarray

Weight of each rfft2 mode.

Source code in cmb_lensing/matrix_operators.py
@struct.dataclass
class BlockTEB(FieldOperator):
    """An operator acting on `FlatS02` fields: per Fourier mode a 2 x 2 T/E block plus an
    independent B block.

    Products with another `BlockTEB` are matrix products of the T/E blocks, so they do not
    commute. `pinv` and `log_det` use Schur complements.

    Attributes:
        matrix_TT: TT block, an (nside, nside//2+1) array on the rfft2 grid.
        matrix_TE: TE block.
        matrix_ET: ET block.
        matrix_EE: EE block.
        matrix_BB: BB block.
        nside: Number of pixels on a side.
        theta_pix: Pixel width in arcmin.
        pix_width: Pixel width in radians.
        fourier_weights: Weight of each rfft2 mode.
    """

    #NOTE these matrices have the following 3 x 3 block diagonal format
    #[TT TE 0 ]
    #[ET EE 0 ]
    #[0  0  BB]

    matrix_TT: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    matrix_TE: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    matrix_ET: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    matrix_EE: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())
    matrix_BB: jnp.ndarray = flax.struct.field(default_factory = lambda: FOURIER_MATRIX_DEFAULT.copy())

    def _matrix_names(self):
        return {"matrix_TT", "matrix_TE", "matrix_ET", "matrix_EE", "matrix_BB"}

    #NOTE non-diagonal matrix multiplication is NOT commutative hence we need distinction
    #between multiplying on the left or right for BlockTEB matrices specifically
    def __mul__(self, other):

        #matrix-matrix multiplication, matrix-field multiplication, and matrix-scalar multiplication                                                                                                                                                               
        if isinstance(other, BlockTEB):
            #compute a non-diagonal matrix-matrix product                   
            return self.replace(matrix_TT = self.matrix_TT * other.matrix_TT + self.matrix_TE * other.matrix_ET,
                                matrix_ET = self.matrix_ET * other.matrix_TT + self.matrix_EE * other.matrix_ET,
                                matrix_TE = self.matrix_TT * other.matrix_TE + self.matrix_TE * other.matrix_EE,
                                matrix_EE = self.matrix_ET * other.matrix_TE + self.matrix_EE * other.matrix_EE,
                                matrix_BB = self.matrix_BB * other.matrix_BB)
        #matrix-field multiplication
        elif isinstance(other, FlatS02):
            return other.replace(scalar_matrix = self.matrix_TT * other.scalar_matrix + self.matrix_TE * other.polar_matrix_1,
                                 polar_matrix_1 = self.matrix_ET * other.scalar_matrix + self.matrix_EE * other.polar_matrix_1,
                                 polar_matrix_2 = self.matrix_BB * other.polar_matrix_2)
        #matrix-scalar multiplication
        return self.replace(matrix_TT = self.matrix_TT * other,
                            matrix_TE = self.matrix_TE * other,
                            matrix_ET = self.matrix_ET * other,
                            matrix_EE = self.matrix_EE * other,
                            matrix_BB = self.matrix_BB * other)                                                                                                                                         

    #NOTE we only expect to multiply a BlockTEB on the right by another BlockTEB or a scalar
    def __rmul__(self, other): 

        if isinstance(other, BlockTEB):
            #compute a non-diagonal matrix-matrix product                   
            return self.replace(matrix_TT = other.matrix_TT * self.matrix_TT + other.matrix_TE * self.matrix_ET,
                                matrix_ET = other.matrix_ET * self.matrix_TT + other.matrix_EE * self.matrix_ET,
                                matrix_TE = other.matrix_TT * self.matrix_TE + other.matrix_TE * self.matrix_EE,
                                matrix_EE = other.matrix_ET * self.matrix_TE + other.matrix_EE * self.matrix_EE,
                                matrix_BB = other.matrix_BB * self.matrix_BB)
        #matrix-scalar multiplication
        return self.replace(matrix_TT = self.matrix_TT * other,
                            matrix_TE = self.matrix_TE * other,
                            matrix_ET = self.matrix_ET * other,
                            matrix_EE = self.matrix_EE * other,
                            matrix_BB = self.matrix_BB * other) 

Data sets

cmb_lensing.dataset.DataSetT

Bases: DataSet

Temperature-only data set, returned by load_sim(..., pol = "I").

Fields (FlatS0, Fourier space): data, unlensed_field, lensed_field, phi. Operators (DiagonalScalar): field_covariance (unlensed, scalar + tensor), lensed_field_covariance, scalar_field_covariance, tensor_field_covariance, phi_covariance, unscaled_phi_covariance (before a_phi), noise_covariance, mask, beam, quadratic_estimate (the QE noise, used as N_phi), and the mixing matrices mixing_d / mixing_g.

Source code in cmb_lensing/dataset.py
@struct.dataclass
class DataSetT(DataSet):
    """Temperature-only data set, returned by `load_sim(..., pol = "I")`.

    Fields (`FlatS0`, Fourier space): `data`, `unlensed_field`, `lensed_field`, `phi`.
    Operators (`DiagonalScalar`): `field_covariance` (unlensed, scalar + tensor),
    `lensed_field_covariance`, `scalar_field_covariance`, `tensor_field_covariance`,
    `phi_covariance`, `unscaled_phi_covariance` (before `a_phi`), `noise_covariance`, `mask`,
    `beam`, `quadratic_estimate` (the QE noise, used as N_phi), and the mixing matrices
    `mixing_d` / `mixing_g`.
    """

    #diagonal matrix operators
    noise_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    mixing_d: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    mixing_g: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    field_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    lensed_field_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    scalar_field_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    tensor_field_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    phi_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    unscaled_phi_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    mask: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    beam: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    quadratic_estimate: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())

    #spin-0 fields
    data: FlatS0 = flax.struct.field(default_factory = lambda: FlatS0())
    unlensed_field: FlatS0 = flax.struct.field(default_factory = lambda: FlatS0())
    lensed_field: FlatS0 = flax.struct.field(default_factory = lambda: FlatS0())
    phi: FlatS0 = flax.struct.field(default_factory = lambda: FlatS0())

cmb_lensing.dataset.DataSetEB

Bases: DataSet

Polarization-only data set, returned by load_sim(..., pol = "P").

Same attributes as DataSetT, but the fields other than phi are FlatS2 (E/B) and the field operators are DiagonalEB. phi, phi_covariance, quadratic_estimate and mixing_g stay scalar.

Source code in cmb_lensing/dataset.py
@struct.dataclass
class DataSetEB(DataSet):
    """Polarization-only data set, returned by `load_sim(..., pol = "P")`.

    Same attributes as `DataSetT`, but the fields other than `phi` are `FlatS2` (E/B) and the
    field operators are `DiagonalEB`. `phi`, `phi_covariance`, `quadratic_estimate` and
    `mixing_g` stay scalar.
    """

    #block diagonal matrix operators
    noise_covariance: DiagonalEB = flax.struct.field(default_factory = lambda: DiagonalEB())
    mixing_d: DiagonalEB = flax.struct.field(default_factory = lambda: DiagonalEB())
    mixing_g: DiagonalEB = flax.struct.field(default_factory = lambda: DiagonalEB())
    field_covariance: DiagonalEB = flax.struct.field(default_factory = lambda: DiagonalEB())
    lensed_field_covariance: DiagonalEB = flax.struct.field(default_factory = lambda: DiagonalEB())
    scalar_field_covariance: DiagonalEB = flax.struct.field(default_factory = lambda: DiagonalEB())
    tensor_field_covariance: DiagonalEB = flax.struct.field(default_factory = lambda: DiagonalEB())
    phi_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    unscaled_phi_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    mask: DiagonalEB = flax.struct.field(default_factory = lambda: DiagonalEB())
    beam: DiagonalEB = flax.struct.field(default_factory = lambda: DiagonalEB())
    quadratic_estimate: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())

    #spin-2 fields
    data: FlatS2 = flax.struct.field(default_factory = lambda: FlatS2())
    unlensed_field: FlatS2 = flax.struct.field(default_factory = lambda: FlatS2())
    lensed_field: FlatS2 = flax.struct.field(default_factory = lambda: FlatS2())
    #the lensing potential is a scalar field in every polarization mode
    phi: FlatS0 = flax.struct.field(default_factory = lambda: FlatS0())

cmb_lensing.dataset.DataSetTEB

Bases: DataSet

Temperature + polarization data set, returned by load_sim(..., pol = "IP").

Same attributes as DataSetT, but the fields other than phi are FlatS02 (T, E, B) and the field operators are BlockTEB, carrying the TE correlation. phi, phi_covariance, quadratic_estimate and mixing_g stay scalar.

Source code in cmb_lensing/dataset.py
@struct.dataclass
class DataSetTEB(DataSet):
    """Temperature + polarization data set, returned by `load_sim(..., pol = "IP")`.

    Same attributes as `DataSetT`, but the fields other than `phi` are `FlatS02` (T, E, B)
    and the field operators are `BlockTEB`, carrying the TE correlation. `phi`,
    `phi_covariance`, `quadratic_estimate` and `mixing_g` stay scalar.
    """

    noise_covariance: BlockTEB = flax.struct.field(default_factory = lambda: BlockTEB())
    mixing_d: BlockTEB = flax.struct.field(default_factory = lambda: BlockTEB())
    mixing_g: BlockTEB = flax.struct.field(default_factory = lambda: BlockTEB())
    field_covariance: BlockTEB = flax.struct.field(default_factory = lambda: BlockTEB())
    lensed_field_covariance: BlockTEB = flax.struct.field(default_factory = lambda: BlockTEB())
    scalar_field_covariance: BlockTEB = flax.struct.field(default_factory = lambda: BlockTEB())
    tensor_field_covariance: BlockTEB = flax.struct.field(default_factory = lambda: BlockTEB())
    phi_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    unscaled_phi_covariance: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())
    mask: BlockTEB = flax.struct.field(default_factory = lambda: BlockTEB())
    beam: BlockTEB = flax.struct.field(default_factory = lambda: BlockTEB())
    quadratic_estimate: DiagonalScalar = flax.struct.field(default_factory = lambda: DiagonalScalar())

    #fields
    data: FlatS02 = flax.struct.field(default_factory = lambda: FlatS02())
    unlensed_field: FlatS02 = flax.struct.field(default_factory = lambda: FlatS02())
    lensed_field: FlatS02 = flax.struct.field(default_factory = lambda: FlatS02())
    phi: FlatS02 = flax.struct.field(default_factory = lambda: FlatS02())