lsst.obs.decam.instrument.DarkEnergyCamera Class Reference

Inheritance diagram for lsst.obs.decam.instrument.DarkEnergyCamera:

Public Member Functions
def	__init__ (self, **kwargs)
def	getName (cls)
def	getCamera (self)
def	register (self, registry)
def	getRawFormatter (self, dataId)
TranslatorFactory	makeDataIdTranslatorFactory (self)
def	filterDefinitions (self)
def	obsDataPackageDir (self)
def	fromName (cls, name, registry)
def	writeCuratedCalibrations (self, butler)
def	applyConfigOverrides (self, name, config)
def	writeCameraGeom (self, butler)
def	writeStandardTextCuratedCalibrations (self, butler)

Public Attributes
	configPaths

Static Public Attributes
	filterDefinitions = DECAM_FILTER_DEFINITIONS
string	policyName = "decam"
string	obsDataPackage = "obs_decam_data"
	standardCuratedDatasetTypes = tuple(StandardCuratedCalibrationDatasetTypes)

Detailed Description

Definition at line 38 of file instrument.py.

Constructor & Destructor Documentation

__init__()

def lsst.obs.decam.instrument.DarkEnergyCamera.__init__	(		self,
		**	kwargs
	)

Definition at line 43 of file instrument.py.

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        packageDir = getPackageDir("obs_decam")
        self.configPaths = [os.path.join(packageDir, "config")]
 

Member Function Documentation

applyConfigOverrides()

def lsst.obs.base.instrument.Instrument.applyConfigOverrides (   self,   name,   config  )

inherited

Apply instrument-specific overrides for a task config.

Parameters
----------
name : `str`
    Name of the object being configured; typically the _DefaultName
    of a Task.
config : `lsst.pex.config.Config`
    Config instance to which overrides should be applied.

Definition at line 228 of file instrument.py.

    def applyConfigOverrides(self, name, config):
        """Apply instrument-specific overrides for a task config.
 
        Parameters
        ----------
        name : `str`
            Name of the object being configured; typically the _DefaultName
            of a Task.
        config : `lsst.pex.config.Config`
            Config instance to which overrides should be applied.
        """
        for root in self.configPaths:
            path = os.path.join(root, f"{name}.py")
            if os.path.exists(path):
                config.load(path)
 

filterDefinitions()

def lsst.obs.base.instrument.Instrument.filterDefinitions (   self )

inherited

`~lsst.obs.base.FilterDefinitionCollection`, defining the filters
for this instrument.

Definition at line 82 of file instrument.py.

    def filterDefinitions(self):
        """`~lsst.obs.base.FilterDefinitionCollection`, defining the filters
        for this instrument.
        """
        return None
 

fromName()

def lsst.obs.base.instrument.Instrument.fromName (   cls,   name,   registry  )

inherited

Given an instrument name and a butler, retrieve a corresponding
instantiated instrument object.

Parameters
----------
name : `str`
    Name of the instrument (must match the return value of `getName`).
registry : `lsst.daf.butler.Registry`
    Butler registry to query to find the information.

Returns
-------
instrument : `Instrument`
    An instance of the relevant `Instrument`.

Notes
-----
The instrument must be registered in the corresponding butler.

Raises
------
LookupError
    Raised if the instrument is not known to the supplied registry.
ModuleNotFoundError
    Raised if the class could not be imported.  This could mean
    that the relevant obs package has not been setup.
TypeError
    Raised if the class name retrieved is not a string.

Definition at line 134 of file instrument.py.

    def fromName(cls, name, registry):
        """Given an instrument name and a butler, retrieve a corresponding
        instantiated instrument object.
 
        Parameters
        ----------
        name : `str`
            Name of the instrument (must match the return value of `getName`).
        registry : `lsst.daf.butler.Registry`
            Butler registry to query to find the information.
 
        Returns
        -------
        instrument : `Instrument`
            An instance of the relevant `Instrument`.
 
        Notes
        -----
        The instrument must be registered in the corresponding butler.
 
        Raises
        ------
        LookupError
            Raised if the instrument is not known to the supplied registry.
        ModuleNotFoundError
            Raised if the class could not be imported.  This could mean
            that the relevant obs package has not been setup.
        TypeError
            Raised if the class name retrieved is not a string.
        """
        dimensions = list(registry.queryDimensions("instrument", dataId={"instrument": name}))
        cls = dimensions[0].records["instrument"].class_name
        if not isinstance(cls, str):
            raise TypeError(f"Unexpected class name retrieved from {name} instrument dimension (got {cls})")
        instrument = doImport(cls)
        return instrument()
 

getCamera()

def lsst.obs.decam.instrument.DarkEnergyCamera.getCamera

(

self

)

Retrieve the cameraGeom representation of this instrument.

This is a temporary API that should go away once obs_ packages have
a standardized approach to writing versioned cameras to a Gen3 repo.

Reimplemented from lsst.obs.base.instrument.Instrument.

Definition at line 52 of file instrument.py.

    def getCamera(self):
        path = os.path.join(getPackageDir("obs_decam"), self.policyName, "camGeom")
        config = CameraConfig()
        config.load(os.path.join(path, "camera.py"))
        return makeCameraFromPath(
            cameraConfig=config,
            ampInfoPath=path,
            shortNameFunc=lambda name: name.replace(" ", "_"),
        )
 

getName()

def lsst.obs.decam.instrument.DarkEnergyCamera.getName

(

cls

)

Return the short (dimension) name for this instrument.

This is not (in general) the same as the class name - it's what is used
as the value of the "instrument" field in data IDs, and is usually an
abbreviation of the full name.

Reimplemented from lsst.obs.base.instrument.Instrument.

Definition at line 49 of file instrument.py.

    def getName(cls):
        return "DECam"
 

getRawFormatter()

def lsst.obs.decam.instrument.DarkEnergyCamera.getRawFormatter	(		self,
			dataId
	)

Return the Formatter class that should be used to read a particular
raw file.

Parameters
----------
dataId : `DataCoordinate`
    Dimension-based ID for the raw file or files being ingested.

Returns
-------
formatter : `Formatter` class
    Class to be used that reads the file into an
    `lsst.afw.image.Exposure` instance.

Reimplemented from lsst.obs.base.instrument.Instrument.

Definition at line 87 of file instrument.py.

    def getRawFormatter(self, dataId):
        # local import to prevent circular dependency
        from .rawFormatter import DarkEnergyCameraRawFormatter
        return DarkEnergyCameraRawFormatter
 

makeDataIdTranslatorFactory()

TranslatorFactory lsst.obs.decam.instrument.DarkEnergyCamera.makeDataIdTranslatorFactory

(

self

)

Return a factory for creating Gen2->Gen3 data ID translators,
specialized for this instrument.

Derived class implementations should generally call
`TranslatorFactory.addGenericInstrumentRules` with appropriate
arguments, but are not required to (and may not be able to if their
Gen2 raw data IDs are sufficiently different from the HSC/DECam/CFHT
norm).

Returns
-------
factory : `TranslatorFactory`.
    Factory for `Translator` objects.

Reimplemented from lsst.obs.base.instrument.Instrument.

Definition at line 92 of file instrument.py.

    def makeDataIdTranslatorFactory(self) -> TranslatorFactory:
        # Docstring inherited from lsst.obs.base.Instrument.
        factory = TranslatorFactory()
        factory.addGenericInstrumentRules(self.getName(), calibFilterType="abstract_filter",
                                          detectorKey="ccdnum")
        # DECam calibRegistry entries are abstract_filters, but we need physical_filter
        # in the gen3 registry.
        factory.addRule(AbstractToPhysicalFilterKeyHandler(self.filterDefinitions),
                        instrument=self.getName(),
                        gen2keys=("filter",),
                        consume=("filter",),
                        datasetTypeName="cpFlat")
        return factory

obsDataPackageDir()

def lsst.obs.base.instrument.Instrument.obsDataPackageDir (   self )

inherited

The root of the obs package that provides specializations for
this instrument (`str`).

Definition at line 121 of file instrument.py.

    def obsDataPackageDir(self):
        """The root of the obs package that provides specializations for
        this instrument (`str`).
        """
        if self.obsDataPackage is None:
            return None
        if self._obsDataPackageDir is None:
            # Defer any problems with locating the package until
            # we need to find it.
            self._obsDataPackageDir = getPackageDir(self.obsDataPackage)
        return self._obsDataPackageDir
 

register()

def lsst.obs.decam.instrument.DarkEnergyCamera.register	(		self,
			registry
	)

Insert instrument, physical_filter, and detector entries into a
`Registry`.

Reimplemented from lsst.obs.base.instrument.Instrument.

Definition at line 62 of file instrument.py.

    def register(self, registry):
        camera = self.getCamera()
        obsMax = 2**31
        registry.insertDimensionData(
            "instrument",
            {"name": self.getName(), "detector_max": 64, "visit_max": obsMax, "exposure_max": obsMax,
             "class_name": getFullTypeName(self),
             }
        )
 
        for detector in camera:
            registry.insertDimensionData(
                "detector",
                {
                    "instrument": self.getName(),
                    "id": detector.getId(),
                    "full_name": detector.getName(),
                    "name_in_raft": detector.getName()[1:],
                    "raft": detector.getName()[0],
                    "purpose": str(detector.getType()).split(".")[-1],
                }
            )
 
        self._registerFilters(registry)
 

writeCameraGeom()

def lsst.obs.base.instrument.Instrument.writeCameraGeom (   self,   butler  )

inherited

Write the default camera geometry to the butler repository
with an infinite validity range.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to receive these calibration datasets.

Definition at line 244 of file instrument.py.

    def writeCameraGeom(self, butler):
        """Write the default camera geometry to the butler repository
        with an infinite validity range.
 
        Parameters
        ----------
        butler : `lsst.daf.butler.Butler`
            Butler to receive these calibration datasets.
        """
 
        datasetType = DatasetType("camera", ("instrument", "calibration_label"), "Camera",
                                  universe=butler.registry.dimensions)
        butler.registry.registerDatasetType(datasetType)
        unboundedDataId = addUnboundedCalibrationLabel(butler.registry, self.getName())
        camera = self.getCamera()
        butler.put(camera, datasetType, unboundedDataId)
 

writeCuratedCalibrations()

def lsst.obs.base.instrument.Instrument.writeCuratedCalibrations (   self,   butler  )

inherited

Write human-curated calibration Datasets to the given Butler with
the appropriate validity ranges.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to use to store these calibrations.

Notes
-----
Expected to be called from subclasses.  The base method calls
``writeCameraGeom`` and ``writeStandardTextCuratedCalibrations``.

Definition at line 211 of file instrument.py.

    def writeCuratedCalibrations(self, butler):
        """Write human-curated calibration Datasets to the given Butler with
        the appropriate validity ranges.
 
        Parameters
        ----------
        butler : `lsst.daf.butler.Butler`
            Butler to use to store these calibrations.
 
        Notes
        -----
        Expected to be called from subclasses.  The base method calls
        ``writeCameraGeom`` and ``writeStandardTextCuratedCalibrations``.
        """
        self.writeCameraGeom(butler)
        self.writeStandardTextCuratedCalibrations(butler)
 

writeStandardTextCuratedCalibrations()

def lsst.obs.base.instrument.Instrument.writeStandardTextCuratedCalibrations (   self,   butler  )

inherited

Write the set of standardized curated text calibrations to
the repository.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to receive these calibration datasets.

Definition at line 261 of file instrument.py.

    def writeStandardTextCuratedCalibrations(self, butler):
        """Write the set of standardized curated text calibrations to
        the repository.
 
        Parameters
        ----------
        butler : `lsst.daf.butler.Butler`
            Butler to receive these calibration datasets.
        """
 
        for datasetTypeName in self.standardCuratedDatasetTypes:
            # We need to define the dataset types.
            if datasetTypeName not in StandardCuratedCalibrationDatasetTypes:
                raise ValueError(f"DatasetType {datasetTypeName} not in understood list"
                                 f" [{'.'.join(StandardCuratedCalibrationDatasetTypes)}]")
            definition = StandardCuratedCalibrationDatasetTypes[datasetTypeName]
            datasetType = DatasetType(datasetTypeName,
                                      universe=butler.registry.dimensions,
                                      **definition)
            self._writeSpecificCuratedCalibrationDatasets(butler, datasetType)
 

Member Data Documentation

configPaths

lsst.obs.decam.instrument.DarkEnergyCamera.configPaths

Definition at line 46 of file instrument.py.

filterDefinitions

lsst.obs.decam.instrument.DarkEnergyCamera.filterDefinitions = DECAM_FILTER_DEFINITIONS

static

Definition at line 39 of file instrument.py.

obsDataPackage

string lsst.obs.decam.instrument.DarkEnergyCamera.obsDataPackage = "obs_decam_data"

static

Definition at line 41 of file instrument.py.

policyName

string lsst.obs.decam.instrument.DarkEnergyCamera.policyName = "decam"

static

Definition at line 40 of file instrument.py.

standardCuratedDatasetTypes

lsst.obs.base.instrument.Instrument.standardCuratedDatasetTypes = tuple(StandardCuratedCalibrationDatasetTypes)

staticinherited

Definition at line 71 of file instrument.py.

---

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

• /j/snowflake/release/lsstsw/stack/448abc6/Linux64/obs_decam/19.0.0-28-g9b887e2/python/lsst/obs/decam/instrument.py