Inheritance diagram for lsst.skymap.packers.SkyMapDimensionPacker:

Public Member Functions
	__init__ (self, DataCoordinate fixed, DimensionGroup\|DimensionGraph\|None dimensions=None, Mapping[str, int]\|None bands=None, int\|None n_bands=None, int\|None n_tracts=None, int\|None n_patches=None)

ConfigurableField	make_config_field (cls, str doc="How to pack tract, patch, and possibly band into an integer.")

SkyMapDimensionPacker	from_config (cls, DataCoordinate data_id, SkyMapDimensionPackerConfig config)

int	maxBits (self)

DataCoordinate	unpack (self, int packedId)

Static Public Attributes
tuple	SUPPORTED_FILTERS

	ConfigClass = SkyMapDimensionPackerConfig

Protected Member Functions
int	_pack (self, DataCoordinate dataId)

Protected Attributes
	_bands

	_n_bands

	_n_tracts

	_n_patches

	_bands_list

Detailed Description

A `DimensionPacker` for tract, patch and optionally band,
given a SkyMap.

Parameters
----------
fixed : `lsst.daf.butler.DataCoordinate`
    Data ID that identifies just the ``skymap`` dimension.  Must have
    dimension records attached unless ``n_tracts`` and ``n_patches`` are
    not `None`.
dimensions : `lsst.daf.butler.DimensionGraph`, or \
        `lsst.daf.butler.DimensionGroup`, optional
    The dimensions of data IDs packed by this instance.  Must include
    ``{skymap, tract, patch}``, and may include ``band``.  If not provided,
    this will be set to include ``band`` if ``n_bands != 0``.
bands : `~collections.abc.Mapping` [ `str`, `int` ] or `None`, optional
    Mapping from band name to integer to use in the packed ID.  `None` uses
    a fixed set of bands defined in this class.  When calling code can
    enumerate the bands it is likely to see, providing an explicit mapping
    is preferable.
n_bands : `int` or `None`, optional
    The number of bands to leave room for in the packed ID.  If `None`,
    this will be set to ``len(bands)``.  If ``0``, the band will not be
    included in the dimensions at all.  If ``1``, the band will be included
    in the dimensions but will not occupy any extra bits in the packed ID.
    This may be larger or smaller than ``len(bands)``, to reserve extra
    space for the future or align to byte boundaries, or support a subset
    of a larger mapping, respectively.
n_tracts : `int` or `None`, optional
    The number of tracts to leave room for in the packed ID.  If `None`,
    this will be set via the ``skymap`` dimension record in ``fixed``.
n_patches : `int` or `None`, optional
    The number of patches (per tract) to leave room for in the packed ID.
    If `None`, this will be set via the ``skymap`` dimension record in
    ``fixed``.

Notes
-----
The standard pattern for constructing instances of this class is to use
`make_config_field`::

    class SomeConfig(lsst.pex.config.Config):
        packer = ObservationDimensionPacker.make_config_field()

    class SomeTask(lsst.pipe.base.Task):
        ConfigClass = SomeConfig

        def run(self, ..., data_id: DataCoordinate):
            packer = self.config.packer.apply(data_id)
            packed_id = packer.pack(data_id)
            ...

Definition at line 67 of file packers.py.

Constructor & Destructor Documentation

◆ init()

lsst.skymap.packers.SkyMapDimensionPacker.__init__	(		self,
		DataCoordinate	fixed,
		DimensionGroup \| DimensionGraph \| None	dimensions = None,
		Mapping[str, int] \| None	bands = None,
		int \| None	n_bands = None,
		int \| None	n_tracts = None,
		int \| None	n_patches = None )

Definition at line 137 of file packers.py.

    ):
        if bands is None:
            bands = {b: i for i, b in enumerate(self.SUPPORTED_FILTERS)}
        if dimensions is None:
            if n_bands is None:
                n_bands = len(bands)
            dimension_names = ["tract", "patch"]
            if n_bands != 0:
                dimension_names.append("band")
            dimensions = fixed.universe.conform(dimension_names)
        else:
            if "band" not in dimensions.names:
                n_bands = 0
                if dimensions.names != {"tract", "patch", "skymap"}:
                    raise ValueError(
                        f"Invalid dimensions for skymap dimension packer with n_bands=0: {dimensions}."
                    )
            else:
                if dimensions.names != {"tract", "patch", "skymap", "band"}:
                    raise ValueError(
                        f"Invalid dimensions for skymap dimension packer with n_bands>0: {dimensions}."
                    )
                if n_bands is None:
                    n_bands = len(bands)
        if n_tracts is None:
            n_tracts = fixed.records["skymap"].tract_max
        if n_patches is None:
            n_patches = (
                fixed.records["skymap"].patch_nx_max
                * fixed.records["skymap"].patch_ny_max
            )
        super().__init__(fixed, dimensions)
        self._bands = bands
        self._n_bands = n_bands
        self._n_tracts = n_tracts
        self._n_patches = n_patches
        self._bands_list = None
 

Member Function Documentation

◆ _pack()

int lsst.skymap.packers.SkyMapDimensionPacker._pack	(		self,
		DataCoordinate	dataId )

protected

Definition at line 247 of file packers.py.

    def _pack(self, dataId: DataCoordinate) -> int:
        # Docstring inherited from DataIdPacker.pack
        if dataId["patch"] >= self._n_patches:
            raise ValueError(f"Patch ID {dataId['patch']} is out of bounds; expected <{self._n_patches}.")
        if dataId["tract"] >= self._n_tracts:
            raise ValueError(f"Tract ID {dataId['tract']} is out of bounds; expected <{self._n_tracts}.")
        packed = dataId["patch"] + self._n_patches * dataId["tract"]
        if self._n_bands:
            if (band_index := self._bands.get(dataId["band"])) is None:
                raise ValueError(
                    f"Band {dataId['band']!r} is not supported by SkyMapDimensionPacker "
                    f"configuration; expected one of {list(self._bands)}."
                )
            if band_index >= self._n_bands:
                raise ValueError(
                    f"Band index {band_index} for {dataId['band']!r} is out of bounds; "
                    f"expected <{self._n_bands}."
                )
            packed += self._bands[dataId["band"]] * self._n_patches * self._n_tracts
        return packed
 

◆ from_config()

SkyMapDimensionPacker lsst.skymap.packers.SkyMapDimensionPacker.from_config	(		cls,
		DataCoordinate	data_id,
		SkyMapDimensionPackerConfig	config )

Construct a dimension packer from a config object and a data ID.

Parameters
----------
data_id : `lsst.daf.butler.DataCoordinate`
    Data ID that identifies at least the ``skymap`` dimension.  Must
    have dimension records attached unless ``config.n_tracts`` and
    ``config.n_patches`` are both not `None`.
config : `SkyMapDimensionPackerConfig`
    Configuration object.

Returns
-------
packer : `SkyMapDimensionPackerConfig`
    New dimension packer.

Notes
-----
This interface is provided for consistency with the `lsst.pex.config`
"Configurable" concept, and is invoked when ``apply(data_id)`` is
called on a config instance attribute that corresponds to a field
created by `make_config_field`.  The constructor signature cannot play
this role easily for backwards compatibility reasons.

Definition at line 204 of file packers.py.

    ) -> SkyMapDimensionPacker:
        """Construct a dimension packer from a config object and a data ID.
 
        Parameters
        ----------
        data_id : `lsst.daf.butler.DataCoordinate`
            Data ID that identifies at least the ``skymap`` dimension.  Must
            have dimension records attached unless ``config.n_tracts`` and
            ``config.n_patches`` are both not `None`.
        config : `SkyMapDimensionPackerConfig`
            Configuration object.
 
        Returns
        -------
        packer : `SkyMapDimensionPackerConfig`
            New dimension packer.
 
        Notes
        -----
        This interface is provided for consistency with the `lsst.pex.config`
        "Configurable" concept, and is invoked when ``apply(data_id)`` is
        called on a config instance attribute that corresponds to a field
        created by `make_config_field`.  The constructor signature cannot play
        this role easily for backwards compatibility reasons.
        """
        return cls(
            data_id.subset(data_id.universe.conform(["skymap"])),
            n_bands=config.n_bands,
            bands=config.bands,
            n_tracts=config.n_tracts,
            n_patches=config.n_patches,
        )
 

◆ make_config_field()

ConfigurableField lsst.skymap.packers.SkyMapDimensionPacker.make_config_field	(		cls,
		str	doc = "How to pack tract, patch, and possibly band into an integer." )

Make a config field to control how skymap data IDs are packed.

Parameters
----------
doc : `str`, optional
    Documentation for the config field.

Returns
-------
field : `lsst.pex.config.ConfigurableField`
    A config field whose instance values are [wrapper proxies to]
    `SkyMapDimensionPackerConfig` instances.

Definition at line 184 of file packers.py.

    ) -> ConfigurableField:
        """Make a config field to control how skymap data IDs are packed.
 
        Parameters
        ----------
        doc : `str`, optional
            Documentation for the config field.
 
        Returns
        -------
        field : `lsst.pex.config.ConfigurableField`
            A config field whose instance values are [wrapper proxies to]
            `SkyMapDimensionPackerConfig` instances.
        """
        return ConfigurableField(doc, target=cls.from_config, ConfigClass=cls.ConfigClass)
 

◆ maxBits()

int lsst.skymap.packers.SkyMapDimensionPacker.maxBits ( self )

Definition at line 240 of file packers.py.

    def maxBits(self) -> int:
        # Docstring inherited from DataIdPacker.maxBits
        packedMax = self._n_tracts * self._n_patches
        if self._n_bands:
            packedMax *= self._n_bands
        return (packedMax - 1).bit_length()
 

◆ unpack()

DataCoordinate lsst.skymap.packers.SkyMapDimensionPacker.unpack	(		self,
		int	packedId )

Definition at line 268 of file packers.py.

    def unpack(self, packedId: int) -> DataCoordinate:
        # Docstring inherited from DataIdPacker.unpack
        d = {"skymap": self.fixed["skymap"]}
        if self._n_bands:
            index, packedId = divmod(packedId, (self._n_tracts * self._n_patches))
            if self._bands_list is None:
                self._bands_list = list(self._bands)
            d["band"] = self._bands_list[index]
        d["tract"], d["patch"] = divmod(packedId, self._n_patches)
        return DataCoordinate.standardize(d, dimensions=self.dimensions)

Member Data Documentation

◆ _bands

lsst.skymap.packers.SkyMapDimensionPacker._bands

protected

Definition at line 177 of file packers.py.

◆ _bands_list

lsst.skymap.packers.SkyMapDimensionPacker._bands_list

protected

Definition at line 181 of file packers.py.

◆ _n_bands

lsst.skymap.packers.SkyMapDimensionPacker._n_bands

protected

Definition at line 178 of file packers.py.

◆ _n_patches

lsst.skymap.packers.SkyMapDimensionPacker._n_patches

protected

Definition at line 180 of file packers.py.

◆ _n_tracts

lsst.skymap.packers.SkyMapDimensionPacker._n_tracts

protected

Definition at line 179 of file packers.py.

◆ ConfigClass

lsst.skymap.packers.SkyMapDimensionPacker.ConfigClass = SkyMapDimensionPackerConfig

static

Definition at line 135 of file packers.py.

◆ SUPPORTED_FILTERS

tuple lsst.skymap.packers.SkyMapDimensionPacker.SUPPORTED_FILTERS

static

Initial value:

=  (
        [None]
        + list("ugrizyUBGVRIZYJHK")  # split string into single chars
        + [f"N{d}" for d in (387, 515, 656, 816, 921, 1010)]  # HSC narrow-bands
        + [f"N{d}" for d in (419, 540, 708, 964)]  # DECam narrow-bands
    )

Definition at line 121 of file packers.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/skymap/ga8c6da7877+ef4e3a5875/python/lsst/skymap/packers.py

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _pack()

◆ from_config()

◆ make_config_field()

◆ maxBits()

◆ unpack()

Member Data Documentation

◆ _bands

◆ _bands_list

◆ _n_bands

◆ _n_patches

◆ _n_tracts

◆ ConfigClass

◆ SUPPORTED_FILTERS

◆ init()