lsst.obs.base  20.0.0-67-g32d6278+0d86c2e7cd
Public Member Functions | Static Public Member Functions | List of all members
lsst.obs.base._instrument.Instrument Class Reference
Inheritance diagram for lsst.obs.base._instrument.Instrument:

Public Member Functions

def filterDefinitions (self)
 
def __init__ (self)
 
def getName (cls)
 
Set[str] getCuratedCalibrationNames (cls)
 
def getCamera (self)
 
def register (self, registry)
 
def getObsDataPackageDir (cls)
 
def getRawFormatter (self, dataId)
 
def applyConfigOverrides (self, name, config)
 
None writeCuratedCalibrations (self, Butler butler, Optional[str] collection=None, Sequence[str] suffixes=())
 
None writeAdditionalCuratedCalibrations (self, Butler butler, Optional[str] collection=None, Sequence[str] suffixes=())
 
None writeCameraGeom (self, Butler butler, Optional[str] collection=None, Sequence[str] suffixes=())
 
None writeStandardTextCuratedCalibrations (self, Butler butler, Optional[str] collection=None, Sequence[str] suffixes=())
 
TranslatorFactory makeDataIdTranslatorFactory (self)
 
str makeDefaultRawIngestRunName (cls)
 
str makeUnboundedCalibrationRunName (cls, *str suffixes)
 
str makeCuratedCalibrationRunName (cls, str calibDate, *str suffixes)
 
str makeCalibrationCollectionName (cls, *str suffixes)
 
str makeCollectionName (cls, *str labels)
 

Static Public Member Functions

Instrument fromName (str name, Registry registry)
 
None importAll (Registry registry)
 

Detailed Description

Base class for instrument-specific logic for the Gen3 Butler.

Concrete instrument subclasses should be directly constructable with no
arguments.

Definition at line 58 of file _instrument.py.

Constructor & Destructor Documentation

◆ __init__()

def lsst.obs.base._instrument.Instrument.__init__ (   self)

Definition at line 108 of file _instrument.py.

Member Function Documentation

◆ applyConfigOverrides()

def lsst.obs.base._instrument.Instrument.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.

Definition at line 311 of file _instrument.py.

◆ filterDefinitions()

def lsst.obs.base._instrument.Instrument.filterDefinitions (   self)
`~lsst.obs.base.FilterDefinitionCollection`, defining the filters
for this instrument.

Definition at line 102 of file _instrument.py.

◆ fromName()

Instrument lsst.obs.base._instrument.Instrument.fromName ( str  name,
Registry  registry 
)
static
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 205 of file _instrument.py.

◆ getCamera()

def lsst.obs.base._instrument.Instrument.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.

Definition at line 157 of file _instrument.py.

◆ getCuratedCalibrationNames()

Set[str] lsst.obs.base._instrument.Instrument.getCuratedCalibrationNames (   cls)
Return the names of all the curated calibration dataset types.

Returns
-------
names : `set` of `str`
    The dataset type names of all curated calibrations. This will
    include the standard curated calibrations even if the particular
    instrument does not support them.

Notes
-----
The returned list does not indicate whether a particular dataset
is present in the Butler repository, simply that these are the
dataset types that are handled by ``writeCuratedCalibrations``.

Definition at line 125 of file _instrument.py.

◆ getName()

def lsst.obs.base._instrument.Instrument.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.

Definition at line 114 of file _instrument.py.

◆ getObsDataPackageDir()

def lsst.obs.base._instrument.Instrument.getObsDataPackageDir (   cls)
The root of the obs data package that provides specializations for
this instrument.

returns
-------
dir : `str`
    The root of the relevat obs data package.

Definition at line 191 of file _instrument.py.

◆ getRawFormatter()

def lsst.obs.base._instrument.Instrument.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.

Definition at line 294 of file _instrument.py.

◆ importAll()

None lsst.obs.base._instrument.Instrument.importAll ( Registry  registry)
static
Import all the instruments known to this registry.

This will ensure that all metadata translators have been registered.

Parameters
----------
registry : `lsst.daf.butler.Registry`
    Butler registry to query to find the information.

Notes
-----
It is allowed for a particular instrument class to fail on import.
This might simply indicate that a particular obs package has
not been setup.

Definition at line 245 of file _instrument.py.

◆ makeCalibrationCollectionName()

str lsst.obs.base._instrument.Instrument.makeCalibrationCollectionName (   cls,
*str  suffixes 
)
Make a CALIBRATION collection name appropriate for associating
calibration datasets with validity ranges.

Parameters
----------
*suffixes : `str`
    Strings to be appended to the base name, using the default
    delimiter for collection names.

Returns
-------
name : `str`
    Calibration collection name.

Definition at line 666 of file _instrument.py.

◆ makeCollectionName()

str lsst.obs.base._instrument.Instrument.makeCollectionName (   cls,
*str  labels 
)
Get the instrument-specific collection string to use as derived
from the supplied labels.

Parameters
----------
*labels : `str`
    Strings to be combined with the instrument name to form a
    collection name.

Returns
-------
name : `str`
    Collection name to use that includes the instrument name.

Definition at line 684 of file _instrument.py.

◆ makeCuratedCalibrationRunName()

str lsst.obs.base._instrument.Instrument.makeCuratedCalibrationRunName (   cls,
str  calibDate,
*str  suffixes 
)
Make a RUN collection name appropriate for inserting curated
calibration datasets with the given ``CALIBDATE`` metadata value.

Parameters
----------
calibDate : `str`
    The ``CALIBDATE`` metadata value.
*suffixes : `str`
    Strings to be appended to the base name, using the default
    delimiter for collection names.

Returns
-------
name : `str`
    Run collection name.

Definition at line 646 of file _instrument.py.

◆ makeDataIdTranslatorFactory()

TranslatorFactory lsst.obs.base._instrument.Instrument.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.

Definition at line 597 of file _instrument.py.

◆ makeDefaultRawIngestRunName()

str lsst.obs.base._instrument.Instrument.makeDefaultRawIngestRunName (   cls)
Make the default instrument-specific run collection string for raw
data ingest.

Returns
-------
coll : `str`
    Run collection name to be used as the default for ingestion of
    raws.

Definition at line 615 of file _instrument.py.

◆ makeUnboundedCalibrationRunName()

str lsst.obs.base._instrument.Instrument.makeUnboundedCalibrationRunName (   cls,
*str  suffixes 
)
Make a RUN collection name appropriate for inserting calibration
datasets whose validity ranges are unbounded.

Parameters
----------
*suffixes : `str`
    Strings to be appended to the base name, using the default
    delimiter for collection names.

Returns
-------
name : `str`
    Run collection name.

Definition at line 628 of file _instrument.py.

◆ register()

def lsst.obs.base._instrument.Instrument.register (   self,
  registry 
)
Insert instrument, physical_filter, and detector entries into a
`Registry`.

Implementations should guarantee that registration is atomic (the
registry should not be modified if any error occurs) and idempotent at
the level of individual dimension entries; new detectors and filters
should be added, but changes to any existing record should not be.
This can generally be achieved via a block like::

    with registry.transaction():
registry.syncDimensionData("instrument", ...)
registry.syncDimensionData("detector", ...)
self.registerFilters(registry)

Raises
------
lsst.daf.butler.registry.ConflictingDefinitionError
    Raised if any existing record has the same key but a different
    definition as one being registered.

Definition at line 166 of file _instrument.py.

◆ writeAdditionalCuratedCalibrations()

None lsst.obs.base._instrument.Instrument.writeAdditionalCuratedCalibrations (   self,
Butler  butler,
Optional[str]   collection = None,
Sequence[str]   suffixes = () 
)
Write additional curated calibrations that might be instrument
specific and are not part of the standard set.

Default implementation does nothing.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to use to store these calibrations.
collection : `str`, optional
    Name to use for the calibration collection that associates all
    datasets with a validity range.  If this collection already exists,
    it must be a `~CollectionType.CALIBRATION` collection, and it must
    not have any datasets that would conflict with those inserted by
    this method.  If `None`, a collection name is worked out
    automatically from the instrument name and other metadata by
    calling ``makeCalibrationCollectionName``, but this
    default name may not work well for long-lived repositories unless
    one or more ``suffixes`` are also provided (and changed every time
    curated calibrations are ingested).
suffixes : `Sequence` [ `str` ], optional
    Name suffixes to append to collection names, after concatenating
    them with the standard collection name delimeter.  If provided,
    these are appended to the names of the `~CollectionType.RUN`
    collections that datasets are inserted directly into, as well the
    `~CollectionType.CALIBRATION` collection if it is generated
    automatically (i.e. if ``collection is None``).

Definition at line 371 of file _instrument.py.

◆ writeCameraGeom()

None lsst.obs.base._instrument.Instrument.writeCameraGeom (   self,
Butler  butler,
Optional[str]   collection = None,
Sequence[str]   suffixes = () 
)
Write the default camera geometry to the butler repository and
associate it with the appropriate validity range in a calibration
collection.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to use to store these calibrations.
collection : `str`, optional
    Name to use for the calibration collection that associates all
    datasets with a validity range.  If this collection already exists,
    it must be a `~CollectionType.CALIBRATION` collection, and it must
    not have any datasets that would conflict with those inserted by
    this method.  If `None`, a collection name is worked out
    automatically from the instrument name and other metadata by
    calling ``makeCalibrationCollectionName``, but this
    default name may not work well for long-lived repositories unless
    one or more ``suffixes`` are also provided (and changed every time
    curated calibrations are ingested).
suffixes : `Sequence` [ `str` ], optional
    Name suffixes to append to collection names, after concatenating
    them with the standard collection name delimeter.  If provided,
    these are appended to the names of the `~CollectionType.RUN`
    collections that datasets are inserted directly into, as well the
    `~CollectionType.CALIBRATION` collection if it is generated
    automatically (i.e. if ``collection is None``).

Definition at line 403 of file _instrument.py.

◆ writeCuratedCalibrations()

None lsst.obs.base._instrument.Instrument.writeCuratedCalibrations (   self,
Butler  butler,
Optional[str]   collection = None,
Sequence[str]   suffixes = () 
)
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.
collection : `str`, optional
    Name to use for the calibration collection that associates all
    datasets with a validity range.  If this collection already exists,
    it must be a `~CollectionType.CALIBRATION` collection, and it must
    not have any datasets that would conflict with those inserted by
    this method.  If `None`, a collection name is worked out
    automatically from the instrument name and other metadata by
    calling ``makeCalibrationCollectionName``, but this
    default name may not work well for long-lived repositories unless
    one or more ``suffixes`` are also provided (and changed every time
    curated calibrations are ingested).
suffixes : `Sequence` [ `str` ], optional
    Name suffixes to append to collection names, after concatenating
    them with the standard collection name delimeter.  If provided,
    these are appended to the names of the `~CollectionType.RUN`
    collections that datasets are inserted directly into, as well the
    `~CollectionType.CALIBRATION` collection if it is generated
    automatically (i.e. if ``collection is None``).

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

Definition at line 327 of file _instrument.py.

◆ writeStandardTextCuratedCalibrations()

None lsst.obs.base._instrument.Instrument.writeStandardTextCuratedCalibrations (   self,
Butler  butler,
Optional[str]   collection = None,
Sequence[str]   suffixes = () 
)
Write the set of standardized curated text calibrations to
the repository.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to receive these calibration datasets.
collection : `str`, optional
    Name to use for the calibration collection that associates all
    datasets with a validity range.  If this collection already exists,
    it must be a `~CollectionType.CALIBRATION` collection, and it must
    not have any datasets that would conflict with those inserted by
    this method.  If `None`, a collection name is worked out
    automatically from the instrument name and other metadata by
    calling ``makeCalibrationCollectionName``, but this
    default name may not work well for long-lived repositories unless
    one or more ``suffixes`` are also provided (and changed every time
    curated calibrations are ingested).
suffixes : `Sequence` [ `str` ], optional
    Name suffixes to append to collection names, after concatenating
    them with the standard collection name delimeter.  If provided,
    these are appended to the names of the `~CollectionType.RUN`
    collections that datasets are inserted directly into, as well the
    `~CollectionType.CALIBRATION` collection if it is generated
    automatically (i.e. if ``collection is None``).

Definition at line 444 of file _instrument.py.


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