dataset

Module for dataset container and protocols for defining the spec of the required functions for all datasets.

BeamConvAndPrefac dataclass

Bases: MetaData

Apply beam convolution and a prefactor (for unit conversion) to a model. Only attributes unique to this subclass are listed here. See MetaData for the rest.

Attributes:

Name	Type	Description
beam	Array	The beam to convolve both the model and gradient with.
prefactor	Array	Scalary array containing a value to multiply the model and gradients by.

Source code in witch/dataset.py

@register_pytree_node_class
@dataclass
class BeamConvAndPrefac(MetaData):
    """
    Apply beam convolution and a prefactor (for unit conversion) to a model.
    Only attributes unique to this subclass are listed here.
    See `MetaData` for the rest.

    Attributes
    ----------
    beam : jax.Array
        The beam to convolve both the model and gradient with.
    prefactor : jax.Array
        Scalary array containing a value to multiply the model and gradients by.
    """

    beam: Array
    prefactor: Array

    def apply(self, model: Array) -> Array:
        """
        Convolve the model by the beam and then multiply by the prefactor.
        See `MetaData.apply` for details on parameters and returns.
        """
        return self.prefactor * beam_conv(model, self.beam)

    def apply_grad(self, model_grad: Array) -> Array:
        r"""
        Convolve the gradient by the beam and then multiply by the prefactor.
        Here we are taking advantage of the following:

        $$
        \frac{\partial}{\partial x}(p * (b \circledast m))
         = p\frac{\partial}{\partial x}(b \circledast m)
         = p * b \circledast \frac{\partial m}{\partial x}
        $$

        Where $m$ is the model, $x$ is some parameter, $p$ is the prefactor, and $b$ is the beam.

        See `MetaData.apply_grad` for details on parameters and returns.
        """
        return self.prefactor * beam_conv_vec(model_grad, self.beam)

    # Functions for making this a pytree
    # Don't call this on your own
    def tree_flatten(self) -> tuple[tuple, tuple]:

        children = (self.beam, self.prefactor)
        aux_data = (self.include, self.exclude)

        return (children, aux_data)

    @classmethod
    def tree_unflatten(cls, aux_data, children) -> Self:
        include, exclude = aux_data

        return cls(*children, include=include, exclude=exclude)

apply(model)

Convolve the model by the beam and then multiply by the prefactor. See MetaData.apply for details on parameters and returns.

Source code in witch/dataset.py

def apply(self, model: Array) -> Array:
    """
    Convolve the model by the beam and then multiply by the prefactor.
    See `MetaData.apply` for details on parameters and returns.
    """
    return self.prefactor * beam_conv(model, self.beam)

apply_grad(model_grad)

Convolve the gradient by the beam and then multiply by the prefactor. Here we are taking advantage of the following:

\[ \frac{\partial}{\partial x}(p * (b \circledast m)) = p\frac{\partial}{\partial x}(b \circledast m) = p * b \circledast \frac{\partial m}{\partial x} \]

Where \(m\) is the model, \(x\) is some parameter, \(p\) is the prefactor, and \(b\) is the beam.

See MetaData.apply_grad for details on parameters and returns.

Source code in witch/dataset.py

def apply_grad(self, model_grad: Array) -> Array:
    r"""
    Convolve the gradient by the beam and then multiply by the prefactor.
    Here we are taking advantage of the following:

    $$
    \frac{\partial}{\partial x}(p * (b \circledast m))
     = p\frac{\partial}{\partial x}(b \circledast m)
     = p * b \circledast \frac{\partial m}{\partial x}
    $$

    Where $m$ is the model, $x$ is some parameter, $p$ is the prefactor, and $b$ is the beam.

    See `MetaData.apply_grad` for details on parameters and returns.
    """
    return self.prefactor * beam_conv_vec(model_grad, self.beam)

DataSet dataclass

Class for storing a dataset.

Attributes:

Name	Type	Description
name	str	The name of the dataset.
get_files	GetFiles	The function to get the file list for this dataset.
load	Load	The function to load data for this dataset.
get_info	GetInfo	The function to get the info dict for this dataset.
make_metadata	MakeMetadata	The function to make the metadata for this dataset.
preproc	PreProc	The function to run preprocessing for this dataset.
postproc	PostProc	The function to run postprocessing for this dataset.
postfit	PostFit	The function to run after fitting this dataset.
global_comm	Comm | Intracomm	The MPI communicator used for all datasets, not the local one just for this data.
info	dict	The info dict for this dataset. This field is not part of the initialization function.
datavec	DataVec	The data vector for this data. This will be a jitkasi container class. This field is not part of the initialization function.
metadata	tuple[MetaData]	Tuple of MetaData instances to apply to model. This field is not part of the initialization function.

Source code in witch/dataset.py

@register_pytree_node_class
@dataclass
class DataSet:
    """
    Class for storing a dataset.

    Attributes
    ----------
    name : str
        The name of the dataset.
    get_files : GetFiles
        The function to get the file list for this dataset.
    load : Load
        The function to load data for this dataset.
    get_info : GetInfo
        The function to get the info dict for this dataset.
    make_metadata : MakeMetadata
        The function to make the metadata for this dataset.
    preproc : PreProc
        The function to run preprocessing for this dataset.
    postproc : PostProc
        The function to run postprocessing for this dataset.
    postfit : PostFit
        The function to run after fitting this dataset.
    global_comm : MPI.Comm | MPI.Intracomm
        The MPI communicator used for all datasets,
        not the local one just for this data.
    info : dict
        The info dict for this dataset.
        This field is not part of the initialization function.
    datavec : DataVec
        The data vector for this data.
        This will be a `jitkasi` container class.
        This field is not part of the initialization function.
    metadata : tuple[MetaData]
        Tuple of `MetaData` instances to apply to model.
        This field is not part of the initialization function.
    """

    name: str
    get_files: GetFiles
    load: Load
    get_info: GetInfo
    make_metadata: MakeMetadata
    preproc: PreProc
    postproc: PostProc
    postfit: PostFit
    global_comm: MPI.Comm | MPI.Intracomm | wu.NullComm
    info: dict = field(init=False)
    datavec: DataVec = field(init=False)
    metadata: tuple[MetaData, ...] = field(init=False)

    def __post_init__(self: Self):
        assert isinstance(self.get_files, GetFiles)
        assert isinstance(self.load, Load)
        assert isinstance(self.get_info, GetInfo)
        assert isinstance(self.make_metadata, MakeMetadata)
        assert isinstance(self.preproc, PreProc)
        assert isinstance(self.postproc, PostProc)
        assert isinstance(self.postfit, PostFit)

    def __setattr__(self, name, value):
        if name == "info":
            if "mode" not in value:
                raise ValueError("Cannot set dataset info without a 'mode' field")
            if value["mode"] not in ["tod", "map"]:
                raise ValueError("Dataset info contained invalid mode")
            if "objective" not in value:
                raise ValueError("Cannot set dataset info without an 'objective' field")
            if not isinstance(value["objective"], ObjectiveFunc):
                raise ValueError("Dataset info contained invalid objective function")
        return super().__setattr__(name, value)

    @property
    def mode(self: Self) -> str:
        """
        Get the mode for this dataset.
        Will be `tod` or `map`.

        Returns
        -------
        mode : str
            The dataset mode.
        """
        return self.info["mode"]

    @property
    def objective(self: Self) -> ObjectiveFunc:
        """
        Get the objective function for this dataset.

        Returns
        -------
        objective : ObjectiveFunc
            The objective function.
        """
        return self.info["objective"]

    @property
    def noise_class(self: Self) -> NoiseModel:
        """
        Get the noise class for this dataset.

        Returns
        -------
        noise_class : NoiseModel
            The class of the noise model that will be used for this dataset.
            This field is not part of the initialization function.
        """
        return self.info["noise_class"]

    @property
    def noise_args(self: Self) -> tuple:
        """
        Get the noise arguments for this dataset.

        Returns
        -------
        noise_args : tuple
            Positional arguments to be used by the noise model.
            This field is not part of the initialization function.
        """
        return self.info["noise_args"]

    @property
    def noise_kwargs(self: Self) -> tuple:
        """
        Get the noise keyword arguments for this dataset.

        Returns
        -------
        noise_kwargs : dict
            Keyword arguments to be used by the noise model.
            This field is not part of the initialization function.
        """
        return self.info["noise_kwargs"]

    def check_completeness(self: Self):
        """
        Check if all fields are actually populated and raise an error if not.

        Raises
        ------
        ValueError
            If the dataset is missing some fields.
            If `self.info` is missing some required info.
            If `self.mode` is not a valid mode.
            If `self.objective` is not a valid objective function.
        """
        missing = [
            fname
            for fname in self.__dataclass_fields__.keys()
            if fname not in self.__dict__
        ]
        if len(missing) > 0:
            raise ValueError(f"Datset is missing the following fields: {missing}")

        required_info = np.array(
            ["mode", "objective", "noise_class", "noise_args", "noise_kwargs"]
        )
        contained_info = list(self.info.keys())
        missing_info = required_info[~np.isin(required_info, contained_info)]
        if len(missing_info) > 0:
            raise ValueError(
                f"(Dataset info is missing the following fields: {missing_info}"
            )

        if self.info["mode"] not in ["tod", "map"]:
            raise ValueError("Dataset info contained invalid mode")
        if not isinstance(self.info["objective"], ObjectiveFunc):
            raise ValueError("Dataset info contained invalid objective function")

    # Functions for making this a pytree
    # Don't call this on your own
    def tree_flatten(self) -> tuple[tuple, tuple]:
        if "datavec" in self.__dict__:
            children = (self.datavec,)
        else:
            children = (None,)
        if "metadata" in self.__dict__:
            children += (self.metadata,)
        else:
            children += (None,)
        aux_data = (
            self.name,
            self.get_files,
            self.load,
            self.get_info,
            self.make_metadata,
            self.preproc,
            self.postproc,
            self.postfit,
            self.global_comm,
        )
        if "info" in self.__dict__:
            aux_data += (self.info,)
        else:
            aux_data += (None,)

        return (children, aux_data)

    @classmethod
    def tree_unflatten(cls, aux_data, children) -> Self:
        datavec, metadata = children
        name = aux_data[0]
        funcs_comm = aux_data[1:9]
        info = aux_data[9]
        dataset = cls(name, *funcs_comm)
        if datavec is not None:
            dataset.datavec = datavec
        if info is not None:
            dataset.info = info
        if metadata is not None:
            dataset.metadata = metadata
        return dataset

mode property

Get the mode for this dataset. Will be tod or map.

Returns:

Name	Type	Description
mode	str	The dataset mode.

noise_args property

Get the noise arguments for this dataset.

Returns:

Name	Type	Description
noise_args	tuple	Positional arguments to be used by the noise model. This field is not part of the initialization function.

noise_class property

Get the noise class for this dataset.

Returns:

Name	Type	Description
noise_class	NoiseModel	The class of the noise model that will be used for this dataset. This field is not part of the initialization function.

noise_kwargs property

Get the noise keyword arguments for this dataset.

Returns:

Name	Type	Description
noise_kwargs	dict	Keyword arguments to be used by the noise model. This field is not part of the initialization function.

objective property

Get the objective function for this dataset.

Returns:

Name	Type	Description
objective	ObjectiveFunc	The objective function.

check_completeness()

Check if all fields are actually populated and raise an error if not.

Raises:

Type	Description
ValueError	If the dataset is missing some fields. If self.info is missing some required info. If self.mode is not a valid mode. If self.objective is not a valid objective function.

Source code in witch/dataset.py

def check_completeness(self: Self):
    """
    Check if all fields are actually populated and raise an error if not.

    Raises
    ------
    ValueError
        If the dataset is missing some fields.
        If `self.info` is missing some required info.
        If `self.mode` is not a valid mode.
        If `self.objective` is not a valid objective function.
    """
    missing = [
        fname
        for fname in self.__dataclass_fields__.keys()
        if fname not in self.__dict__
    ]
    if len(missing) > 0:
        raise ValueError(f"Datset is missing the following fields: {missing}")

    required_info = np.array(
        ["mode", "objective", "noise_class", "noise_args", "noise_kwargs"]
    )
    contained_info = list(self.info.keys())
    missing_info = required_info[~np.isin(required_info, contained_info)]
    if len(missing_info) > 0:
        raise ValueError(
            f"(Dataset info is missing the following fields: {missing_info}"
        )

    if self.info["mode"] not in ["tod", "map"]:
        raise ValueError("Dataset info contained invalid mode")
    if not isinstance(self.info["objective"], ObjectiveFunc):
        raise ValueError("Dataset info contained invalid objective function")

GetFiles

Bases: Protocol

Function that returns a list of files to be loaded for this dataset. Technically these do not have the be filepaths, just a list where each entry is the information needed to load the data. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py

@runtime_checkable
class GetFiles(Protocol):
    """
    Function that returns a list of files to be loaded for this dataset.
    Technically these do not have the be filepaths, just a list where each
    entry is the information needed to load the data.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(self: Self, dset_name: str, cfg: dict) -> list:
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.

        Returns
        -------
        file_list : list
            A list where each entry contains the information needed to load a
            discrete piece of data (ie: a TOD or map) for this dataset.
            The format of the entries are up to the dataset but the number of
            entries must match the number of things loaded for MPI planning
            purposes.
        """
        ...

__call__(dset_name, cfg)

Parameters:

Name	Type	Description	Default
dset_name	str	The name of the dataset to get file list for.	required
cfg	dict	The loaded witcher config.	required

Returns:

Name	Type	Description
file_list	list	A list where each entry contains the information needed to load a discrete piece of data (ie: a TOD or map) for this dataset. The format of the entries are up to the dataset but the number of entries must match the number of things loaded for MPI planning purposes.

Source code in witch/dataset.py

def __call__(self: Self, dset_name: str, cfg: dict) -> list:
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.

    Returns
    -------
    file_list : list
        A list where each entry contains the information needed to load a
        discrete piece of data (ie: a TOD or map) for this dataset.
        The format of the entries are up to the dataset but the number of
        entries must match the number of things loaded for MPI planning
        purposes.
    """
    ...

GetInfo

Bases: Protocol

Function that gets information that will be used by other functions for this dataset. At the minimum this should contain:

• mode: a string that is either tod or map that detemines how the dataset is treated.
• objective: a function pointer to an objective function. See witch.objective.ObjectiveFunc for details.

See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py

@runtime_checkable
class GetInfo(Protocol):
    """
    Function that gets information that will be used by other functions for this dataset.
    At the minimum this should contain:

    * `mode`: a string that is either `tod` or `map` that detemines how the dataset is treated.
    * `objective`: a function pointer to an objective function. See `witch.objective.ObjectiveFunc` for details.

    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(self: Self, dset_name: str, cfg: dict, datavec: DataVec) -> dict:
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.
        datavec : DataVec
            The `jitkasi` container for the data.
            This is going to be `TODVec` for TODs
            and `SolutionSet` for maps.


        Returns
        -------
        info : dict
            Dictionairy containing information.
            Must at least contain `mode` and `objective`.
        """
        ...

__call__(dset_name, cfg, datavec)

Parameters:

Name	Type	Description	Default
dset_name	str	The name of the dataset to get file list for.	required
cfg	dict	The loaded witcher config.	required
datavec	DataVec	The jitkasi container for the data. This is going to be TODVec for TODs and SolutionSet for maps.	required

Returns:

Name	Type	Description
info	dict	Dictionairy containing information. Must at least contain mode and objective.

Source code in witch/dataset.py

def __call__(self: Self, dset_name: str, cfg: dict, datavec: DataVec) -> dict:
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.
    datavec : DataVec
        The `jitkasi` container for the data.
        This is going to be `TODVec` for TODs
        and `SolutionSet` for maps.


    Returns
    -------
    info : dict
        Dictionairy containing information.
        Must at least contain `mode` and `objective`.
    """
    ...

Load

Bases: Protocol

Function that loads data into a jitkasi container. This function is also responsible for updating the comm object to the local one in any relevant libraries. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py

@runtime_checkable
class Load(Protocol):
    """
    Function that loads data into a `jitkasi` container.
    This function is also responsible for updating the comm object to
    the local one in any relevant libraries.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(
        self: Self, dset_name: str, cfg: dict, fnames: list, comm: MPI.Intracomm
    ) -> DataVec:
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.
        fnames : list
            Some subset of the output of `GetFiles`.
        comm : MPI.Intracomm
            The MPI communicator to pass to the `jitkasi` container.

        Returns
        -------
        datavec : DataVec
            The `jitkasi` container for the data.
            This is going to be `TODVec` for TODs
            and `SolutionSet` for maps.
        """
        ...

__call__(dset_name, cfg, fnames, comm)

Parameters:

Name	Type	Description	Default
dset_name	str	The name of the dataset to get file list for.	required
cfg	dict	The loaded witcher config.	required
fnames	list	Some subset of the output of GetFiles.	required
comm	Intracomm	The MPI communicator to pass to the jitkasi container.	required

Returns:

Name	Type	Description
datavec	DataVec	The jitkasi container for the data. This is going to be TODVec for TODs and SolutionSet for maps.

Source code in witch/dataset.py

def __call__(
    self: Self, dset_name: str, cfg: dict, fnames: list, comm: MPI.Intracomm
) -> DataVec:
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.
    fnames : list
        Some subset of the output of `GetFiles`.
    comm : MPI.Intracomm
        The MPI communicator to pass to the `jitkasi` container.

    Returns
    -------
    datavec : DataVec
        The `jitkasi` container for the data.
        This is going to be `TODVec` for TODs
        and `SolutionSet` for maps.
    """
    ...

MakeMetadata

Bases: Protocol

Function that makes the metadata. If you don't need it just write a dummy function to return an empty tuple. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py

@runtime_checkable
class MakeMetadata(Protocol):
    """
    Function that makes the metadata.
    If you don't need it just write a dummy function to return an empty tuple.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(
        self: Self, dset_name: str, cfg: dict, info: dict
    ) -> tuple[MetaData, ...]:
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.
        info : dict
            Dictionairy containing dataset information.

        Returns
        -------
        metadata : tuple[MetaData, ...]
            Tuple of MetaData instances.
        """
        ...

__call__(dset_name, cfg, info)

Parameters:

Name	Type	Description	Default
dset_name	str	The name of the dataset to get file list for.	required
cfg	dict	The loaded witcher config.	required
info	dict	Dictionairy containing dataset information.	required

Returns:

Name	Type	Description
metadata	tuple[MetaData, ...]	Tuple of MetaData instances.

Source code in witch/dataset.py

def __call__(
    self: Self, dset_name: str, cfg: dict, info: dict
) -> tuple[MetaData, ...]:
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.
    info : dict
        Dictionairy containing dataset information.

    Returns
    -------
    metadata : tuple[MetaData, ...]
        Tuple of MetaData instances.
    """
    ...

MetaData dataclass

Class for storing and applying metdata to a dataset. You should subclass this for your individual metadata implementation.

Attributes:

Name	Type	Description
include	tuple[str, ...]	Used when computing metamodel mapping. If provided only models whose names are listed will have this metadata applied. If an empty tuple is provided then all models will have this metadata applied by default.
exclude	tuple[str, ...]	Used when computing metamodel mapping. If provided models whose names are listed will not have this metadata applied. If an empty tuple is provided then no models will be excluded by default. This exclusion list is applied after the inclusion list, so a model listed in both will be excluded.

Source code in witch/dataset.py

@register_pytree_node_class
@dataclass
class MetaData:
    """
    Class for storing and applying metdata to a dataset.
    You should subclass this for your individual metadata implementation.

    Attributes
    ----------
    include : tuple[str, ...]
        Used when computing metamodel mapping.
        If provided only models whose names are listed will
        have this metadata applied. If an empty tuple is provided
        then all models will have this metadata applied by default.
    exclude : tuple[str, ...]
        Used when computing metamodel mapping.
        If provided  models whose names are listed will not
        have this metadata applied. If an empty tuple is provided
        then no models will be excluded by default.
        This exclusion list is applied after the inclusion list,
        so a model listed in both will be excluded.
    """

    include: tuple[str, ...] = field(default_factory=tuple, kw_only=True)
    exclude: tuple[str, ...] = field(default_factory=tuple, kw_only=True)

    def check_apply(self, model_name) -> bool:
        """
        Check based on `self.include` and `self.exclude` if we should
        apply this metadata to a given model.

        Parameters
        ----------
        model_name : str
            The name of the model to apply.

        Returns
        -------
        check : bool
            True if this metadata should be applied.
            False if not.
        """
        if len(self.include) != 0 and model_name not in self.include:
            return False
        return model_name not in self.exclude

    def apply(self, model: Array) -> Array:
        """
        Apply the metdata to the model.
        This is the model prior to projection into the datavector.

        Parameters
        ----------
        model : Array
            The model as defined on a grid.

        Returns
        -------
        applied : Array
            The model with the metadata applied.
        """
        return model

    def apply_grad(self, model_grad: Array) -> Array:
        """
        Apply the metdata to the model gradient.
        This is the model gradient prior to projection into the datavector.

        Parameters
        ----------
        model_gradient : Array
            The model gradient defined on a grid.

        Returns
        -------
        applied : Array
            The model gradient with the metadata applied.
        """
        return model_grad

    def apply_proj(self, model_proj: Array) -> Array:
        """
        Apply the metdata to the model.
        This is the model after projection into the datavector.

        Parameters
        ----------
        model : Array
            The model projected to the datavector.

        Returns
        -------
        applied : Array
            The model with the metadata applied.
        """
        return model_proj

    def apply_grad_proj(self, model_grad_proj: Array) -> Array:
        """
        Apply the metdata to the model gradient.
        This is the model gradient after projection into the datavector.

        Parameters
        ----------
        model_gradient_proj : Array
            The model gradient projected to the datavector.

        Returns
        -------
        applied : Array
            The model gradient with the metadata applied.
        """
        return model_grad_proj

    # Functions for making this a pytree
    # Don't call this on your own
    def tree_flatten(self) -> tuple[tuple, tuple]:

        return (tuple(), (self.include, self.exclude))

    @classmethod
    def tree_unflatten(cls, aux_data, children) -> Self:
        _ = children
        include, exclude = aux_data

        return cls(include=include, exclude=exclude)

apply(model)

Apply the metdata to the model. This is the model prior to projection into the datavector.

Parameters:

Name	Type	Description	Default
model	Array	The model as defined on a grid.	required

Returns:

Name	Type	Description
applied	Array	The model with the metadata applied.

Source code in witch/dataset.py

def apply(self, model: Array) -> Array:
    """
    Apply the metdata to the model.
    This is the model prior to projection into the datavector.

    Parameters
    ----------
    model : Array
        The model as defined on a grid.

    Returns
    -------
    applied : Array
        The model with the metadata applied.
    """
    return model

apply_grad(model_grad)

Apply the metdata to the model gradient. This is the model gradient prior to projection into the datavector.

Parameters:

Name	Type	Description	Default
model_gradient	Array	The model gradient defined on a grid.	required

Returns:

Name	Type	Description
applied	Array	The model gradient with the metadata applied.

Source code in witch/dataset.py

def apply_grad(self, model_grad: Array) -> Array:
    """
    Apply the metdata to the model gradient.
    This is the model gradient prior to projection into the datavector.

    Parameters
    ----------
    model_gradient : Array
        The model gradient defined on a grid.

    Returns
    -------
    applied : Array
        The model gradient with the metadata applied.
    """
    return model_grad

apply_grad_proj(model_grad_proj)

Apply the metdata to the model gradient. This is the model gradient after projection into the datavector.

Parameters:

Name	Type	Description	Default
model_gradient_proj	Array	The model gradient projected to the datavector.	required

Returns:

Name	Type	Description
applied	Array	The model gradient with the metadata applied.

Source code in witch/dataset.py

def apply_grad_proj(self, model_grad_proj: Array) -> Array:
    """
    Apply the metdata to the model gradient.
    This is the model gradient after projection into the datavector.

    Parameters
    ----------
    model_gradient_proj : Array
        The model gradient projected to the datavector.

    Returns
    -------
    applied : Array
        The model gradient with the metadata applied.
    """
    return model_grad_proj

apply_proj(model_proj)

Apply the metdata to the model. This is the model after projection into the datavector.

Parameters:

Name	Type	Description	Default
model	Array	The model projected to the datavector.	required

Returns:

Name	Type	Description
applied	Array	The model with the metadata applied.

Source code in witch/dataset.py

def apply_proj(self, model_proj: Array) -> Array:
    """
    Apply the metdata to the model.
    This is the model after projection into the datavector.

    Parameters
    ----------
    model : Array
        The model projected to the datavector.

    Returns
    -------
    applied : Array
        The model with the metadata applied.
    """
    return model_proj

check_apply(model_name)

Check based on self.include and self.exclude if we should apply this metadata to a given model.

Parameters:

Name	Type	Description	Default
model_name	str	The name of the model to apply.	required

Returns:

Name	Type	Description
check	bool	True if this metadata should be applied. False if not.

Source code in witch/dataset.py

def check_apply(self, model_name) -> bool:
    """
    Check based on `self.include` and `self.exclude` if we should
    apply this metadata to a given model.

    Parameters
    ----------
    model_name : str
        The name of the model to apply.

    Returns
    -------
    check : bool
        True if this metadata should be applied.
        False if not.
    """
    if len(self.include) != 0 and model_name not in self.include:
        return False
    return model_name not in self.exclude

PostFit

Bases: Protocol

Function that runs after all fitting stages are over. This is where you may want make some visualization or initial analysis of your data (ie. plot residuals, check statistical significance, etc.) You can also do nothing if you wish. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py

@runtime_checkable
class PostFit(Protocol):
    """
    Function that runs after all fitting stages are over.
    This is where you may want make some visualization or initial analysis of your data
    (ie. plot residuals, check statistical significance, etc.)
    You can also do nothing if you wish.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(
        self: Self,
        dset: "DataSet",
        cfg: dict,
        metamodel: "MetaModel",
    ):
        """
        Parameters
        ----------
        dset : str
            The dataset to process after fitting.
        cfg : dict
            The loaded `witcher` config.
        metamodel : MetaModel
            The cluster model.
            This will contain the final best fit parameters.
        """
        ...

__call__(dset, cfg, metamodel)

Parameters:

Name	Type	Description	Default
dset	str	The dataset to process after fitting.	required
cfg	dict	The loaded witcher config.	required
metamodel	MetaModel	The cluster model. This will contain the final best fit parameters.	required

Source code in witch/dataset.py

def __call__(
    self: Self,
    dset: "DataSet",
    cfg: dict,
    metamodel: "MetaModel",
):
    """
    Parameters
    ----------
    dset : str
        The dataset to process after fitting.
    cfg : dict
        The loaded `witcher` config.
    metamodel : MetaModel
        The cluster model.
        This will contain the final best fit parameters.
    """
    ...

PostProc

Bases: Protocol

Function that runs after the data vector is processed. (see witch.fitter.process_tods and witch.fitter.process_maps). This is where you may want make some visualization or initial analysis of your data (ie. make a map from your TODs, improve the noise model estimation, etc.) You can also do nothing if you wish. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py

@runtime_checkable
class PostProc(Protocol):
    """
    Function that runs after the data vector is processed.
    (see `witch.fitter.process_tods` and `witch.fitter.process_maps`).
    This is where you may want make some visualization or initial analysis of your data
    (ie. make a map from your TODs, improve the noise model estimation, etc.)
    You can also do nothing if you wish.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(
        self: Self,
        dset: "DataSet",
        cfg: dict,
        metamodel: "MetaModel",
    ):
        """
        Parameters
        ----------
        dset : str
            The dataset to postproc.
        cfg : dict
            The loaded `witcher` config.
        metamodel : MetaModel
            The cluster model.
            At this point this will just be the initial state of the model.
        """
        ...

__call__(dset, cfg, metamodel)

Parameters:

Name	Type	Description	Default
dset	str	The dataset to postproc.	required
cfg	dict	The loaded witcher config.	required
metamodel	MetaModel	The cluster model. At this point this will just be the initial state of the model.	required

Source code in witch/dataset.py

def __call__(
    self: Self,
    dset: "DataSet",
    cfg: dict,
    metamodel: "MetaModel",
):
    """
    Parameters
    ----------
    dset : str
        The dataset to postproc.
    cfg : dict
        The loaded `witcher` config.
    metamodel : MetaModel
        The cluster model.
        At this point this will just be the initial state of the model.
    """
    ...

PreProc

Bases: Protocol

Function that runs before the data vector is processed. (see witch.fitter.process_tods and witch.fitter.process_maps). This is where you may want to compute something about the data's noise properties or some other statistic that may be useful to your analysis. You can also do nothing if you wish. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py

@runtime_checkable
class PreProc(Protocol):
    """
    Function that runs before the data vector is processed.
    (see `witch.fitter.process_tods` and `witch.fitter.process_maps`).
    This is where you may want to compute something about the data's noise properties
    or some other statistic that may be useful to your analysis.
    You can also do nothing if you wish.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(
        self: Self,
        dset: "DataSet",
        cfg: dict,
        metamodel: "MetaModel",
    ):
        """
        Parameters
        ----------
        dset : str
            The dataset to preproc.
        cfg : dict
            The loaded `witcher` config.
        metamodel : MetaModel
            The cluster model.
            At this point this will just be the initial state of the model.
        info : dict
            Dictionairy containing dataset information.
        """
        ...

__call__(dset, cfg, metamodel)

Parameters:

Name	Type	Description	Default
dset	str	The dataset to preproc.	required
cfg	dict	The loaded witcher config.	required
metamodel	MetaModel	The cluster model. At this point this will just be the initial state of the model.	required
info	dict	Dictionairy containing dataset information.	required

Source code in witch/dataset.py

def __call__(
    self: Self,
    dset: "DataSet",
    cfg: dict,
    metamodel: "MetaModel",
):
    """
    Parameters
    ----------
    dset : str
        The dataset to preproc.
    cfg : dict
        The loaded `witcher` config.
    metamodel : MetaModel
        The cluster model.
        At this point this will just be the initial state of the model.
    info : dict
        Dictionairy containing dataset information.
    """
    ...