Inheritance diagram for lsst.pipe.tasks.healSparseMappingProperties.BasePropertyMap:

Public Member Functions
	__init__ (self, config, name)

	initialize_tract_maps (self, nside_coverage, nside)

	initialize_values (self, n_pixels)

	accumulate_values (self, indices, ra, dec, weights, scalings, row, psf_array=None)

	finalize_mean_values (self, total_weights, total_inputs)

	set_map_values (self, pixels)

Public Attributes
	config

	name

	zeropoint

	description

	unit

	min_map

	max_map

	mean_map

	weighted_mean_map

	sum_map

	min_values

	max_values

	mean_values

	weighted_mean_values

	sum_values

Static Public Attributes
	dtype = np.float64

bool	requires_psf = False

str	description = ""

str	unit = ""

	ConfigClass = BasePropertyMapConfig

	registry = PropertyMapRegistry(BasePropertyMapConfig)

Protected Member Functions
	_compute (self, row, ra, dec, scalings, psf_array=None)

	_post_process (self, total_weights, total_inputs)

Detailed Description

Base class for property maps.

Parameters
----------
config : `BasePropertyMapConfig`
    Property map configuration.
name : `str`
    Property map name.

Definition at line 200 of file healSparseMappingProperties.py.

Constructor & Destructor Documentation

◆ init()

lsst.pipe.tasks.healSparseMappingProperties.BasePropertyMap.__init__	(	self,
		config,
		name )

Definition at line 220 of file healSparseMappingProperties.py.

    def __init__(self, config, name):
        object.__init__(self)
        self.config = config
        self.name = name
        self.zeropoint = 0.0
 

Member Function Documentation

◆ _compute()

lsst.pipe.tasks.healSparseMappingProperties.BasePropertyMap._compute	(	self,
		row,
		ra,
		dec,
		scalings,
		psf_array = None )

protected

Compute map value from a row in the visitSummary catalog.

Parameters
----------
row : `lsst.afw.table.ExposureRecord`
    Row of a visitSummary ExposureCatalog.
ra : `np.ndarray`
    Array of right ascensions
dec : `np.ndarray`
    Array of declinations
scalings : `float` or `np.ndarray`
    Scaling values to coadd zeropoint.
psf_array : `np.ndarray`, optional
    Array of approximate psf values matched to ra/dec.

Definition at line 378 of file healSparseMappingProperties.py.

    def _compute(self, row, ra, dec, scalings, psf_array=None):
        """Compute map value from a row in the visitSummary catalog.
 
        Parameters
        ----------
        row : `lsst.afw.table.ExposureRecord`
            Row of a visitSummary ExposureCatalog.
        ra : `np.ndarray`
            Array of right ascensions
        dec : `np.ndarray`
            Array of declinations
        scalings : `float` or `np.ndarray`
            Scaling values to coadd zeropoint.
        psf_array : `np.ndarray`, optional
            Array of approximate psf values matched to ra/dec.
        """
        raise NotImplementedError("All property maps must implement _compute()")
 

◆ _post_process()

lsst.pipe.tasks.healSparseMappingProperties.BasePropertyMap._post_process	(	self,
		total_weights,
		total_inputs )

protected

Perform post-processing on values.

Parameters
----------
total_weights : `np.ndarray`
    Total accumulated weights, for each value index.
total_inputs : `np.ndarray`
    Total number of inputs, for each value index.

Reimplemented in lsst.pipe.tasks.healSparseMappingProperties.PsfMaglimPropertyMap.

Definition at line 396 of file healSparseMappingProperties.py.

    def _post_process(self, total_weights, total_inputs):
        """Perform post-processing on values.
 
        Parameters
        ----------
        total_weights : `np.ndarray`
            Total accumulated weights, for each value index.
        total_inputs : `np.ndarray`
            Total number of inputs, for each value index.
        """
        # Override of this method is not required.
        pass
 
 
@register_property_map("exposure_time")

◆ accumulate_values()

lsst.pipe.tasks.healSparseMappingProperties.BasePropertyMap.accumulate_values	(	self,
		indices,
		ra,
		dec,
		weights,
		scalings,
		row,
		psf_array = None )

Accumulate values from a row of a visitSummary table.

Parameters
----------
indices : `np.ndarray`
    Indices of values that should be accumulated.
ra : `np.ndarray`
    Array of right ascension for indices
dec : `np.ndarray`
    Array of declination for indices
weights : `float` or `np.ndarray`
    Weight(s) for indices to be accumulated.
scalings : `float` or `np.ndarray`
    Scaling values to coadd zeropoint.
row : `lsst.afw.table.ExposureRecord`
    Row of a visitSummary ExposureCatalog.
psf_array : `np.ndarray`, optional
    Array of approximate psf values matched to ra/dec.

Raises
------
ValueError : Raised if requires_psf is True and psf_array is None.

Definition at line 298 of file healSparseMappingProperties.py.

                          psf_array=None):
        """Accumulate values from a row of a visitSummary table.
 
        Parameters
        ----------
        indices : `np.ndarray`
            Indices of values that should be accumulated.
        ra : `np.ndarray`
            Array of right ascension for indices
        dec : `np.ndarray`
            Array of declination for indices
        weights : `float` or `np.ndarray`
            Weight(s) for indices to be accumulated.
        scalings : `float` or `np.ndarray`
            Scaling values to coadd zeropoint.
        row : `lsst.afw.table.ExposureRecord`
            Row of a visitSummary ExposureCatalog.
        psf_array : `np.ndarray`, optional
            Array of approximate psf values matched to ra/dec.
 
        Raises
        ------
        ValueError : Raised if requires_psf is True and psf_array is None.
        """
        if self.requires_psf and psf_array is None:
            name = self.__class__.__name__
            raise ValueError(f"Cannot compute {name} without psf_array.")
 
        values = self._compute(row, ra, dec, scalings, psf_array=psf_array)
        if self.config.do_min:
            self.min_values[indices] = np.fmin(self.min_values[indices], values)
        if self.config.do_max:
            self.max_values[indices] = np.fmax(self.max_values[indices], values)
        if self.config.do_mean:
            self.mean_values[indices] += values
        if self.config.do_weighted_mean:
            self.weighted_mean_values[indices] += weights*values
        if self.config.do_sum:
            self.sum_values[indices] += values
 

◆ finalize_mean_values()

lsst.pipe.tasks.healSparseMappingProperties.BasePropertyMap.finalize_mean_values	(	self,
		total_weights,
		total_inputs )

Finalize the accumulation of the mean and weighted mean.

Parameters
----------
total_weights : `np.ndarray`
    Total accumulated weights, for each value index.
total_inputs : `np.ndarray`
    Total number of inputs, for each value index.

Definition at line 339 of file healSparseMappingProperties.py.

    def finalize_mean_values(self, total_weights, total_inputs):
        """Finalize the accumulation of the mean and weighted mean.
 
        Parameters
        ----------
        total_weights : `np.ndarray`
            Total accumulated weights, for each value index.
        total_inputs : `np.ndarray`
            Total number of inputs, for each value index.
        """
        if self.config.do_mean:
            use, = np.where(total_inputs > 0)
            self.mean_values[use] /= total_inputs[use]
        if self.config.do_weighted_mean:
            use, = np.where(total_weights > 0.0)
            self.weighted_mean_values[use] /= total_weights[use]
 
        # And perform any necessary post-processing
        self._post_process(total_weights, total_inputs)
 

◆ initialize_tract_maps()

lsst.pipe.tasks.healSparseMappingProperties.BasePropertyMap.initialize_tract_maps	(	self,
		nside_coverage,
		nside )

Initialize the tract maps.

Parameters
----------
nside_coverage : `int`
    Healpix nside of the healsparse coverage map.
nside : `int`
    Healpix nside of the property map.

Definition at line 226 of file healSparseMappingProperties.py.

    def initialize_tract_maps(self, nside_coverage, nside):
        """Initialize the tract maps.
 
        Parameters
        ----------
        nside_coverage : `int`
            Healpix nside of the healsparse coverage map.
        nside : `int`
            Healpix nside of the property map.
        """
        base_metadata = {
            "DESCRIPTION": self.description,
            "UNIT": self.unit,
        }
        if self.config.do_min:
            metadata = copy.copy(base_metadata)
            metadata["OPERATION"] = "minimum"
            self.min_map = hsp.HealSparseMap.make_empty(nside_coverage,
                                                        nside,
                                                        self.dtype,
                                                        metadata=metadata)
        if self.config.do_max:
            metadata = copy.copy(base_metadata)
            metadata["OPERATION"] = "maximum"
            self.max_map = hsp.HealSparseMap.make_empty(nside_coverage,
                                                        nside,
                                                        self.dtype,
                                                        metadata=metadata)
        if self.config.do_mean:
            metadata = copy.copy(base_metadata)
            metadata["OPERATION"] = "mean"
            self.mean_map = hsp.HealSparseMap.make_empty(nside_coverage,
                                                         nside,
                                                         self.dtype,
                                                         metadata=metadata)
        if self.config.do_weighted_mean:
            metadata = copy.copy(base_metadata)
            metadata["OPERATION"] = "weighted mean"
            self.weighted_mean_map = hsp.HealSparseMap.make_empty(nside_coverage,
                                                                  nside,
                                                                  self.dtype,
                                                                  metadata=metadata)
        if self.config.do_sum:
            metadata = copy.copy(base_metadata)
            metadata["OPERATION"] = "sum"
            self.sum_map = hsp.HealSparseMap.make_empty(nside_coverage,
                                                        nside,
                                                        self.dtype,
                                                        metadata=metadata)
 

◆ initialize_values()

lsst.pipe.tasks.healSparseMappingProperties.BasePropertyMap.initialize_values	(		self,
			n_pixels )

Initialize the value arrays for accumulation.

Parameters
----------
n_pixels : `int`
    Number of pixels in the map.

Definition at line 276 of file healSparseMappingProperties.py.

    def initialize_values(self, n_pixels):
        """Initialize the value arrays for accumulation.
 
        Parameters
        ----------
        n_pixels : `int`
            Number of pixels in the map.
        """
        if self.config.do_min:
            self.min_values = np.zeros(n_pixels, dtype=self.dtype)
            # This works for float types, need check for integers...
            self.min_values[:] = np.nan
        if self.config.do_max:
            self.max_values = np.zeros(n_pixels, dtype=self.dtype)
            self.max_values[:] = np.nan
        if self.config.do_mean:
            self.mean_values = np.zeros(n_pixels, dtype=self.dtype)
        if self.config.do_weighted_mean:
            self.weighted_mean_values = np.zeros(n_pixels, dtype=self.dtype)
        if self.config.do_sum:
            self.sum_values = np.zeros(n_pixels, dtype=self.dtype)
 

◆ set_map_values()

lsst.pipe.tasks.healSparseMappingProperties.BasePropertyMap.set_map_values	(		self,
			pixels )

Assign accumulated values to the maps.

Parameters
----------
pixels : `np.ndarray`
    Array of healpix pixels (nest scheme) to set in the map.

Definition at line 359 of file healSparseMappingProperties.py.

    def set_map_values(self, pixels):
        """Assign accumulated values to the maps.
 
        Parameters
        ----------
        pixels : `np.ndarray`
            Array of healpix pixels (nest scheme) to set in the map.
        """
        if self.config.do_min:
            self.min_map[pixels] = self.min_values
        if self.config.do_max:
            self.max_map[pixels] = self.max_values
        if self.config.do_mean:
            self.mean_map[pixels] = self.mean_values
        if self.config.do_weighted_mean:
            self.weighted_mean_map[pixels] = self.weighted_mean_values
        if self.config.do_sum:
            self.sum_map[pixels] = self.sum_values
 