Inheritance diagram for lsst.obs.base.cameraMapper.CameraMapper:

Public Member Functions
def	__init__ (self, policy, repositoryDir, root=None, registry=None, calibRoot=None, calibRegistry=None, provided=None, parentRegistry=None, repositoryCfg=None)

def	backup (self, datasetType, dataId)

def	keys (self)

def	getKeys (self, datasetType, level)

def	getDefaultLevel (self)

def	getDefaultSubLevel (self, level)

def	getCameraName (cls)

def	getPackageName (cls)

def	getPackageDir (cls)

def	map_camera (self, dataId, write=False)

def	bypass_camera (self, datasetType, pythonType, butlerLocation, dataId)

def	map_expIdInfo (self, dataId, write=False)

def	bypass_expIdInfo (self, datasetType, pythonType, location, dataId)

def	std_bfKernel (self, item, dataId)

def	std_raw (self, item, dataId)

def	map_skypolicy (self, dataId)

def	std_skypolicy (self, item, dataId)

def	getRegistry (self)

def	getImageCompressionSettings (self, datasetType, dataId)

def	__new__ (cls, args, kwargs)

def	__getstate__ (self)

def	__setstate__ (self, state)

def	queryMetadata (self, datasetType, format, dataId)

def	getDatasetTypes (self)

def	map (self, datasetType, dataId, write=False)

def	canStandardize (self, datasetType)

def	standardize (self, datasetType, item, dataId)

def	validate (self, dataId)

Static Public Member Functions
def	getShortCcdName (ccdName)

Public Attributes
	log

	root

	levels

	defaultLevel

	defaultSubLevels

	rootStorage

	registry

	calibRegistry

	keyDict

	cameraDataLocation

	camera

	filters

	makeRawVisitInfo

	mappings

Static Public Attributes
	packageName = None

	MakeRawVisitInfoClass = MakeRawVisitInfo

	PupilFactoryClass = afwCameraGeom.PupilFactory

	translatorClass = None

	category

Detailed Description

CameraMapper is a base class for mappers that handle images from a
camera and products derived from them.  This provides an abstraction layer
between the data on disk and the code.

Public methods: keys, queryMetadata, getDatasetTypes, map,
canStandardize, standardize

Mappers for specific data sources (e.g., CFHT Megacam, LSST
simulations, etc.) should inherit this class.

The CameraMapper manages datasets within a "root" directory. Note that
writing to a dataset present in the input root will hide the existing
dataset but not overwrite it.  See #2160 for design discussion.

A camera is assumed to consist of one or more rafts, each composed of
multiple CCDs.  Each CCD is in turn composed of one or more amplifiers
(amps).  A camera is also assumed to have a camera geometry description
(CameraGeom object) as a policy file, a filter description (Filter class
static configuration) as another policy file.

Information from the camera geometry and defects are inserted into all
Exposure objects returned.

The mapper uses one or two registries to retrieve metadata about the
images.  The first is a registry of all raw exposures.  This must contain
the time of the observation.  One or more tables (or the equivalent)
within the registry are used to look up data identifier components that
are not specified by the user (e.g. filter) and to return results for
metadata queries.  The second is an optional registry of all calibration
data.  This should contain validity start and end entries for each
calibration dataset in the same timescale as the observation time.

Subclasses will typically set MakeRawVisitInfoClass and optionally the
metadata translator class:

MakeRawVisitInfoClass: a class variable that points to a subclass of
MakeRawVisitInfo, a functor that creates an
lsst.afw.image.VisitInfo from the FITS metadata of a raw image.

translatorClass: The `~astro_metadata_translator.MetadataTranslator`
class to use for fixing metadata values.  If it is not set an attempt
will be made to infer the class from ``MakeRawVisitInfoClass``, failing
that the metadata fixup will try to infer the translator class from the
header itself.

Subclasses must provide the following methods:

_extractDetectorName(self, dataId): returns the detector name for a CCD
(e.g., "CFHT 21", "R:1,2 S:3,4") as used in the AFW CameraGeom class given
a dataset identifier referring to that CCD or a subcomponent of it.

_computeCcdExposureId(self, dataId): see below

_computeCoaddExposureId(self, dataId, singleFilter): see below

Subclasses may also need to override the following methods:

_transformId(self, dataId): transformation of a data identifier
from colloquial usage (e.g., "ccdname") to proper/actual usage
(e.g., "ccd"), including making suitable for path expansion (e.g. removing
commas). The default implementation does nothing.  Note that this
method should not modify its input parameter.

getShortCcdName(self, ccdName): a static method that returns a shortened
name suitable for use as a filename. The default version converts spaces
to underscores.

_mapActualToPath(self, template, actualId): convert a template path to an
actual path, using the actual dataset identifier.

The mapper's behaviors are largely specified by the policy file.
See the MapperDictionary.paf for descriptions of the available items.

The 'exposures', 'calibrations', and 'datasets' subpolicies configure
mappings (see Mappings class).

Common default mappings for all subclasses can be specified in the
"policy/{images,exposures,calibrations,datasets}.yaml" files. This
provides a simple way to add a product to all camera mappers.

Functions to map (provide a path to the data given a dataset
identifier dictionary) and standardize (convert data into some standard
format or type) may be provided in the subclass as "map_{dataset type}"
and "std_{dataset type}", respectively.

If non-Exposure datasets cannot be retrieved using standard
daf_persistence methods alone, a "bypass_{dataset type}" function may be
provided in the subclass to return the dataset instead of using the
"datasets" subpolicy.

Implementations of map_camera and bypass_camera that should typically be
sufficient are provided in this base class.

Notes
-----
.. todo::

   Instead of auto-loading the camera at construction time, load it from
   the calibration registry

Parameters
----------
policy : daf_persistence.Policy,
    Policy with per-camera defaults already merged.
repositoryDir : string
    Policy repository for the subclassing module (obtained with
    getRepositoryPath() on the per-camera default dictionary).
root : string, optional
    Path to the root directory for data.
registry : string, optional
    Path to registry with data's metadata.
calibRoot : string, optional
    Root directory for calibrations.
calibRegistry : string, optional
    Path to registry with calibrations' metadata.
provided : list of string, optional
    Keys provided by the mapper.
parentRegistry : Registry subclass, optional
    Registry from a parent repository that may be used to look up
    data's metadata.
repositoryCfg : daf_persistence.RepositoryCfg or None, optional
    The configuration information for the repository this mapper is
    being used with.

Definition at line 50 of file cameraMapper.py.

Constructor & Destructor Documentation

◆ init()

def lsst.obs.base.cameraMapper.CameraMapper.__init__	(	self,
		policy,
		repositoryDir,
		root = `None`,
		registry = `None`,
		calibRoot = `None`,
		calibRegistry = `None`,
		provided = `None`,
		parentRegistry = `None`,
		repositoryCfg = `None`
	)

Definition at line 190 of file cameraMapper.py.

                  provided=None, parentRegistry=None, repositoryCfg=None):
 
         dafPersist.Mapper.__init__(self)
 
         self.log = lsstLog.Log.getLogger("CameraMapper")
 
         if root:
             self.root = root
         elif repositoryCfg:
             self.root = repositoryCfg.root
         else:
             self.root = None
 
         repoPolicy = repositoryCfg.policy if repositoryCfg else None
         if repoPolicy is not None:
             policy.update(repoPolicy)
 
         # Levels
         self.levels = dict()
         if 'levels' in policy:
             levelsPolicy = policy['levels']
             for key in levelsPolicy.names(True):
                 self.levels[key] = set(levelsPolicy.asArray(key))
         self.defaultLevel = policy['defaultLevel']
         self.defaultSubLevels = dict()
         if 'defaultSubLevels' in policy:
             self.defaultSubLevels = policy['defaultSubLevels']
 
         # Root directories
         if root is None:
             root = "."
         root = dafPersist.LogicalLocation(root).locString()
 
         self.rootStorage = dafPersist.Storage.makeFromURI(uri=root)
 
         # If the calibRoot is passed in, use that. If not and it's indicated in
         # the policy, use that. And otherwise, the calibs are in the regular
         # root.
         # If the location indicated by the calib root does not exist, do not
         # create it.
         calibStorage = None
         if calibRoot is not None:
             calibRoot = dafPersist.Storage.absolutePath(root, calibRoot)
             calibStorage = dafPersist.Storage.makeFromURI(uri=calibRoot,
                                                           create=False)
         else:
             calibRoot = policy.get('calibRoot', None)
             if calibRoot:
                 calibStorage = dafPersist.Storage.makeFromURI(uri=calibRoot,
                                                               create=False)
         if calibStorage is None:
             calibStorage = self.rootStorage
 
         self.root = root
 
         # Registries
         self.registry = self._setupRegistry("registry", "exposure", registry, policy, "registryPath",
                                             self.rootStorage, searchParents=False,
                                             posixIfNoSql=(not parentRegistry))
         if not self.registry:
             self.registry = parentRegistry
         needCalibRegistry = policy.get('needCalibRegistry', None)
         if needCalibRegistry:
             if calibStorage:
                 self.calibRegistry = self._setupRegistry("calibRegistry", "calib", calibRegistry, policy,
                                                          "calibRegistryPath", calibStorage,
                                                          posixIfNoSql=False)  # NB never use posix for calibs
             else:
                 raise RuntimeError(
                     "'needCalibRegistry' is true in Policy, but was unable to locate a repo at " +
                     "calibRoot ivar:%s or policy['calibRoot']:%s" %
                     (calibRoot, policy.get('calibRoot', None)))
         else:
             self.calibRegistry = None
 
         # Dict of valid keys and their value types
         self.keyDict = dict()
 
         self._initMappings(policy, self.rootStorage, calibStorage, provided=None)
         self._initWriteRecipes()
 
         # Camera geometry
         self.cameraDataLocation = None  # path to camera geometry config file
         self.camera = self._makeCamera(policy=policy, repositoryDir=repositoryDir)
 
         # Filter translation table
         self.filters = None
 
         # verify that the class variable packageName is set before attempting
         # to instantiate an instance
         if self.packageName is None:
             raise ValueError('class variable packageName must not be None')
 
         self.makeRawVisitInfo = self.MakeRawVisitInfoClass(log=self.log)
 
         # Assign a metadata translator if one has not been defined by
         # subclass. We can sometimes infer one from the RawVisitInfo
         # class.
         if self.translatorClass is None and hasattr(self.makeRawVisitInfo, "metadataTranslator"):
             self.translatorClass = self.makeRawVisitInfo.metadataTranslator
 

Member Function Documentation

◆ getstate()

def lsst.daf.persistence.mapper.Mapper.__getstate__ ( self )

inherited

Definition at line 104 of file mapper.py.

     def __getstate__(self):
         return self._arguments
 

◆ new()

def lsst.daf.persistence.mapper.Mapper.__new__	(	cls,
		args,
		kwargs
	)

inherited

Create a new Mapper, saving arguments for pickling.

This is in __new__ instead of __init__ to save the user
from having to save the arguments themselves (either explicitly,
or by calling the super's __init__ with all their
*args,**kwargs.  The resulting pickling system (of __new__,
__getstate__ and __setstate__ is similar to how __reduce__
is usually used, except that we save the user from any
responsibility (except when overriding __new__, but that
is not common).

Definition at line 85 of file mapper.py.

     def __new__(cls, *args, **kwargs):
         """Create a new Mapper, saving arguments for pickling.
 
         This is in __new__ instead of __init__ to save the user
         from having to save the arguments themselves (either explicitly,
         or by calling the super's __init__ with all their
         *args,**kwargs.  The resulting pickling system (of __new__,
         __getstate__ and __setstate__ is similar to how __reduce__
         is usually used, except that we save the user from any
         responsibility (except when overriding __new__, but that
         is not common).
         """
         self = super().__new__(cls)
         self._arguments = (args, kwargs)
         return self
 

◆ setstate()

def lsst.daf.persistence.mapper.Mapper.__setstate__	(	self,
		state
	)

inherited

Definition at line 107 of file mapper.py.

     def __setstate__(self, state):
         self._arguments = state
         args, kwargs = state
         self.__init__(*args, **kwargs)
 

◆ backup()

def lsst.obs.base.cameraMapper.CameraMapper.backup	(	self,
		datasetType,
		dataId
	)

Rename any existing object with the given type and dataId.

The CameraMapper implementation saves objects in a sequence of e.g.:

- foo.fits
- foo.fits~1
- foo.fits~2

All of the backups will be placed in the output repo, however, and will
not be removed if they are found elsewhere in the _parent chain.  This
means that the same file will be stored twice if the previous version
was found in an input repo.

Definition at line 595 of file cameraMapper.py.

     def backup(self, datasetType, dataId):
         """Rename any existing object with the given type and dataId.
 
         The CameraMapper implementation saves objects in a sequence of e.g.:
 
         - foo.fits
         - foo.fits~1
         - foo.fits~2
 
         All of the backups will be placed in the output repo, however, and will
         not be removed if they are found elsewhere in the _parent chain.  This
         means that the same file will be stored twice if the previous version
         was found in an input repo.
         """
 
         # Calling PosixStorage directly is not the long term solution in this
         # function, this is work-in-progress on epic DM-6225. The plan is for
         # parentSearch to be changed to 'search', and search only the storage
         # associated with this mapper. All searching of parents will be handled
         # by traversing the container of repositories in Butler.
 
         def firstElement(list):
             """Get the first element in the list, or None if that can't be
             done.
             """
             return list[0] if list is not None and len(list) else None
 
         n = 0
         newLocation = self.map(datasetType, dataId, write=True)
         newPath = newLocation.getLocations()[0]
         path = dafPersist.PosixStorage.search(self.root, newPath, searchParents=True)
         path = firstElement(path)
         oldPaths = []
         while path is not None:
             n += 1
             oldPaths.append((n, path))
             path = dafPersist.PosixStorage.search(self.root, "%s~%d" % (newPath, n), searchParents=True)
             path = firstElement(path)
         for n, oldPath in reversed(oldPaths):
             self.rootStorage.copyFile(oldPath, "%s~%d" % (newPath, n))
 

◆ bypass_camera()

def lsst.obs.base.cameraMapper.CameraMapper.bypass_camera	(	self,
		datasetType,
		pythonType,
		butlerLocation,
		dataId
	)

Return the (preloaded) camera object.

Definition at line 726 of file cameraMapper.py.

     def bypass_camera(self, datasetType, pythonType, butlerLocation, dataId):
         """Return the (preloaded) camera object.
         """
         if self.camera is None:
             raise RuntimeError("No camera dataset available.")
         return self.camera
 

◆ bypass_expIdInfo()

def lsst.obs.base.cameraMapper.CameraMapper.bypass_expIdInfo	(	self,
		datasetType,
		pythonType,
		location,
		dataId
	)

Hook to retrieve an lsst.obs.base.ExposureIdInfo for an exposure

Definition at line 744 of file cameraMapper.py.

     def bypass_expIdInfo(self, datasetType, pythonType, location, dataId):
         """Hook to retrieve an lsst.obs.base.ExposureIdInfo for an exposure"""
         expId = self.bypass_ccdExposureId(datasetType, pythonType, location, dataId)
         expBits = self.bypass_ccdExposureId_bits(datasetType, pythonType, location, dataId)
         return ExposureIdInfo(expId=expId, expBits=expBits)
 

◆ canStandardize()

def lsst.daf.persistence.mapper.Mapper.canStandardize	(	self,
		datasetType
	)

inherited

Return true if this mapper can standardize an object of the given
dataset type.

Definition at line 168 of file mapper.py.

     def canStandardize(self, datasetType):
         """Return true if this mapper can standardize an object of the given
         dataset type."""
 
         return hasattr(self, 'std_' + datasetType)
 

◆ getCameraName()

def lsst.obs.base.cameraMapper.CameraMapper.getCameraName ( cls )

Return the name of the camera that this CameraMapper is for.

Definition at line 689 of file cameraMapper.py.

     def getCameraName(cls):
         """Return the name of the camera that this CameraMapper is for."""
         className = str(cls)
         className = className[className.find('.'):-1]
         m = re.search(r'(\w+)Mapper', className)
         if m is None:
             m = re.search(r"class '[\w.]*?(\w+)'", className)
         name = m.group(1)
         return name[:1].lower() + name[1:] if name else ''
 

◆ getDatasetTypes()

def lsst.daf.persistence.mapper.Mapper.getDatasetTypes ( self )

inherited

Return a list of the mappable dataset types.

Definition at line 129 of file mapper.py.

     def getDatasetTypes(self):
         """Return a list of the mappable dataset types."""
 
         list = []
         for attr in dir(self):
             if attr.startswith("map_"):
                 list.append(attr[4:])
         return list
 

◆ getDefaultLevel()

def lsst.obs.base.cameraMapper.CameraMapper.getDefaultLevel ( self )

Definition at line 680 of file cameraMapper.py.

     def getDefaultLevel(self):
         return self.defaultLevel
 

◆ getDefaultSubLevel()

def lsst.obs.base.cameraMapper.CameraMapper.getDefaultSubLevel	(	self,
		level
	)

Definition at line 683 of file cameraMapper.py.

     def getDefaultSubLevel(self, level):
         if level in self.defaultSubLevels:
             return self.defaultSubLevels[level]
         return None
 

◆ getImageCompressionSettings()

def lsst.obs.base.cameraMapper.CameraMapper.getImageCompressionSettings	(	self,
		datasetType,
		dataId
	)

Stuff image compression settings into a daf.base.PropertySet

This goes into the ButlerLocation's "additionalData", which gets
passed into the boost::persistence framework.

Parameters
----------
datasetType : `str`
    Type of dataset for which to get the image compression settings.
dataId : `dict`
    Dataset identifier.

Returns
-------
additionalData : `lsst.daf.base.PropertySet`
    Image compression settings.

Definition at line 1202 of file cameraMapper.py.

     def getImageCompressionSettings(self, datasetType, dataId):
         """Stuff image compression settings into a daf.base.PropertySet
 
         This goes into the ButlerLocation's "additionalData", which gets
         passed into the boost::persistence framework.
 
         Parameters
         ----------
         datasetType : `str`
             Type of dataset for which to get the image compression settings.
         dataId : `dict`
             Dataset identifier.
 
         Returns
         -------
         additionalData : `lsst.daf.base.PropertySet`
             Image compression settings.
         """
         mapping = self.mappings[datasetType]
         recipeName = mapping.recipe
         storageType = mapping.storage
         if storageType not in self._writeRecipes:
             return dafBase.PropertySet()
         if recipeName not in self._writeRecipes[storageType]:
             raise RuntimeError("Unrecognized write recipe for datasetType %s (storage type %s): %s" %
                                (datasetType, storageType, recipeName))
         recipe = self._writeRecipes[storageType][recipeName].deepCopy()
         seed = hash(tuple(dataId.items())) % 2**31
         for plane in ("image", "mask", "variance"):
             if recipe.exists(plane + ".scaling.seed") and recipe.getScalar(plane + ".scaling.seed") == 0:
                 recipe.set(plane + ".scaling.seed", seed)
         return recipe
 

◆ getKeys()

def lsst.obs.base.cameraMapper.CameraMapper.getKeys	(	self,
		datasetType,
		level
	)

Return a dict of supported keys and their value types for a given
dataset type at a given level of the key hierarchy.

Parameters
----------
datasetType :  `str`
    Dataset type or None for all dataset types.
level :  `str` or None
    Level or None for all levels or '' for the default level for the
    camera.

Returns
-------
`dict`
    Keys are strings usable in a dataset identifier, values are their
    value types.

Definition at line 646 of file cameraMapper.py.

     def getKeys(self, datasetType, level):
         """Return a dict of supported keys and their value types for a given
         dataset type at a given level of the key hierarchy.
 
         Parameters
         ----------
         datasetType :  `str`
             Dataset type or None for all dataset types.
         level :  `str` or None
             Level or None for all levels or '' for the default level for the
             camera.
 
         Returns
         -------
         `dict`
             Keys are strings usable in a dataset identifier, values are their
             value types.
         """
 
         # not sure if this is how we want to do this. what if None was intended?
         if level == '':
             level = self.getDefaultLevel()
 
         if datasetType is None:
             keyDict = copy.copy(self.keyDict)
         else:
             keyDict = self.mappings[datasetType].keys()
         if level is not None and level in self.levels:
             keyDict = copy.copy(keyDict)
             for l in self.levels[level]:
                 if l in keyDict:
                     del keyDict[l]
         return keyDict
 

◆ getPackageDir()

def lsst.obs.base.cameraMapper.CameraMapper.getPackageDir ( cls )

Return the base directory of this package

Definition at line 707 of file cameraMapper.py.

     def getPackageDir(cls):
         """Return the base directory of this package"""
         return getPackageDir(cls.getPackageName())
 

◆ getPackageName()

def lsst.obs.base.cameraMapper.CameraMapper.getPackageName ( cls )

Return the name of the package containing this CameraMapper.

Definition at line 700 of file cameraMapper.py.

     def getPackageName(cls):
         """Return the name of the package containing this CameraMapper."""
         if cls.packageName is None:
             raise ValueError('class variable packageName must not be None')
         return cls.packageName
 

◆ getRegistry()

def lsst.obs.base.cameraMapper.CameraMapper.getRegistry ( self )

Get the registry used by this mapper.

Returns
-------
Registry or None
    The registry used by this mapper for this mapper's repository.

Definition at line 1192 of file cameraMapper.py.

     def getRegistry(self):
         """Get the registry used by this mapper.
 
         Returns
         -------
         Registry or None
             The registry used by this mapper for this mapper's repository.
         """
         return self.registry
 

◆ getShortCcdName()

def lsst.obs.base.cameraMapper.CameraMapper.getShortCcdName ( ccdName )

static

Convert a CCD name to a form useful as a filename

The default implementation converts spaces to underscores.

Definition at line 936 of file cameraMapper.py.

     def getShortCcdName(ccdName):
         """Convert a CCD name to a form useful as a filename
 
         The default implementation converts spaces to underscores.
         """
         return ccdName.replace(" ", "_")
 

◆ keys()

def lsst.obs.base.cameraMapper.CameraMapper.keys ( self )

Return supported keys.

Returns
-------
iterable
    List of keys usable in a dataset identifier

Definition at line 636 of file cameraMapper.py.

     def keys(self):
         """Return supported keys.
 
         Returns
         -------
         iterable
             List of keys usable in a dataset identifier
         """
         return iter(self.keyDict.keys())
 

◆ map()

def lsst.daf.persistence.mapper.Mapper.map	(	self,
		datasetType,
		dataId,
		write = `False`
	)

inherited

Map a data id using the mapping method for its dataset type.

Parameters
----------
datasetType : string
    The datasetType to map
dataId : DataId instance
    The dataId to use when mapping
write : bool, optional
    Indicates if the map is being performed for a read operation
    (False) or a write operation (True)

Returns
-------
ButlerLocation or a list of ButlerLocation
    The location(s) found for the map operation. If write is True, a
    list is returned. If write is False a single ButlerLocation is
    returned.

Raises
------
NoResults
    If no locaiton was found for this map operation, the derived mapper
    class may raise a lsst.daf.persistence.NoResults exception. Butler
    catches this and will look in the next Repository if there is one.

Definition at line 138 of file mapper.py.

     def map(self, datasetType, dataId, write=False):
         """Map a data id using the mapping method for its dataset type.
 
         Parameters
         ----------
         datasetType : string
             The datasetType to map
         dataId : DataId instance
             The dataId to use when mapping
         write : bool, optional
             Indicates if the map is being performed for a read operation
             (False) or a write operation (True)
 
         Returns
         -------
         ButlerLocation or a list of ButlerLocation
             The location(s) found for the map operation. If write is True, a
             list is returned. If write is False a single ButlerLocation is
             returned.
 
         Raises
         ------
         NoResults
             If no locaiton was found for this map operation, the derived mapper
             class may raise a lsst.daf.persistence.NoResults exception. Butler
             catches this and will look in the next Repository if there is one.
         """
         func = getattr(self, 'map_' + datasetType)
         return func(self.validate(dataId), write)
 

◆ map_camera()

def lsst.obs.base.cameraMapper.CameraMapper.map_camera	(	self,
		dataId,
		write = `False`
	)

Map a camera dataset.

Definition at line 711 of file cameraMapper.py.

     def map_camera(self, dataId, write=False):
         """Map a camera dataset."""
         if self.camera is None:
             raise RuntimeError("No camera dataset available.")
         actualId = self._transformId(dataId)
         return dafPersist.ButlerLocation(
             pythonType="lsst.afw.cameraGeom.CameraConfig",
             cppType="Config",
             storageName="ConfigStorage",
             locationList=self.cameraDataLocation or "ignored",
             dataId=actualId,
             mapper=self,
             storage=self.rootStorage
         )
 

◆ map_expIdInfo()

def lsst.obs.base.cameraMapper.CameraMapper.map_expIdInfo	(	self,
		dataId,
		write = `False`
	)

Definition at line 733 of file cameraMapper.py.

     def map_expIdInfo(self, dataId, write=False):
         return dafPersist.ButlerLocation(
             pythonType="lsst.obs.base.ExposureIdInfo",
             cppType=None,
             storageName="Internal",
             locationList="ignored",
             dataId=dataId,
             mapper=self,
             storage=self.rootStorage
         )
 

◆ map_skypolicy()

def lsst.obs.base.cameraMapper.CameraMapper.map_skypolicy	(	self,
		dataId
	)

Map a sky policy.

Definition at line 766 of file cameraMapper.py.

     def map_skypolicy(self, dataId):
         """Map a sky policy."""
         return dafPersist.ButlerLocation("lsst.pex.policy.Policy", "Policy",
                                          "Internal", None, None, self,
                                          storage=self.rootStorage)
 

◆ queryMetadata()

def lsst.daf.persistence.mapper.Mapper.queryMetadata	(	self,
		datasetType,
		format,
		dataId
	)

inherited

Get possible values for keys given a partial data id.

:param datasetType: see documentation about the use of datasetType
:param key: this is used as the 'level' parameter
:param format:
:param dataId: see documentation about the use of dataId
:return:

Definition at line 115 of file mapper.py.

     def queryMetadata(self, datasetType, format, dataId):
         """Get possible values for keys given a partial data id.
 
         :param datasetType: see documentation about the use of datasetType
         :param key: this is used as the 'level' parameter
         :param format:
         :param dataId: see documentation about the use of dataId
         :return:
         """
         func = getattr(self, 'query_' + datasetType)
 
         val = func(format, self.validate(dataId))
         return val
 

◆ standardize()

def lsst.daf.persistence.mapper.Mapper.standardize	(	self,
		datasetType,
		item,
		dataId
	)

inherited

Standardize an object using the standardization method for its data
set type, if it exists.

Definition at line 174 of file mapper.py.

     def standardize(self, datasetType, item, dataId):
         """Standardize an object using the standardization method for its data
         set type, if it exists."""
 
         if hasattr(self, 'std_' + datasetType):
             func = getattr(self, 'std_' + datasetType)
             return func(item, self.validate(dataId))
         return item
 

◆ std_bfKernel()

def lsst.obs.base.cameraMapper.CameraMapper.std_bfKernel	(	self,
		item,
		dataId
	)

Disable standardization for bfKernel

bfKernel is a calibration product that is numpy array,
unlike other calibration products that are all images;
all calibration images are sent through _standardizeExposure
due to CalibrationMapping, but we don't want that to happen to bfKernel

Definition at line 750 of file cameraMapper.py.

     def std_bfKernel(self, item, dataId):
         """Disable standardization for bfKernel
 
         bfKernel is a calibration product that is numpy array,
         unlike other calibration products that are all images;
         all calibration images are sent through _standardizeExposure
         due to CalibrationMapping, but we don't want that to happen to bfKernel
         """
         return item
 

◆ std_raw()

def lsst.obs.base.cameraMapper.CameraMapper.std_raw	(	self,
		item,
		dataId
	)

Standardize a raw dataset by converting it to an Exposure instead
of an Image

Definition at line 760 of file cameraMapper.py.

     def std_raw(self, item, dataId):
         """Standardize a raw dataset by converting it to an Exposure instead
         of an Image"""
         return self._standardizeExposure(self.exposures['raw'], item, dataId,
                                          trimmed=False, setVisitInfo=True)
 

◆ std_skypolicy()

def lsst.obs.base.cameraMapper.CameraMapper.std_skypolicy	(	self,
		item,
		dataId
	)

Standardize a sky policy by returning the one we use.

Definition at line 772 of file cameraMapper.py.

     def std_skypolicy(self, item, dataId):
         """Standardize a sky policy by returning the one we use."""
         return self.skypolicy
 

◆ validate()

def lsst.daf.persistence.mapper.Mapper.validate	(	self,
		dataId
	)

inherited

Validate a dataId's contents.

If the dataId is valid, return it.  If an invalid component can be
transformed into a valid one, copy the dataId, fix the component, and
return the copy.  Otherwise, raise an exception.

Definition at line 183 of file mapper.py.

     def validate(self, dataId):
         """Validate a dataId's contents.
 
         If the dataId is valid, return it.  If an invalid component can be
         transformed into a valid one, copy the dataId, fix the component, and
         return the copy.  Otherwise, raise an exception."""
 
         return dataId
 

Member Data Documentation

◆ calibRegistry

lsst.obs.base.cameraMapper.CameraMapper.calibRegistry

Definition at line 254 of file cameraMapper.py.

◆ camera

lsst.obs.base.cameraMapper.CameraMapper.camera

Definition at line 273 of file cameraMapper.py.

◆ cameraDataLocation

lsst.obs.base.cameraMapper.CameraMapper.cameraDataLocation

Definition at line 272 of file cameraMapper.py.

◆ category

lsst.obs.base.cameraMapper.CameraMapper.category

static

Definition at line 960 of file cameraMapper.py.

◆ defaultLevel

lsst.obs.base.cameraMapper.CameraMapper.defaultLevel

Definition at line 213 of file cameraMapper.py.

◆ defaultSubLevels

lsst.obs.base.cameraMapper.CameraMapper.defaultSubLevels

Definition at line 214 of file cameraMapper.py.

◆ filters

lsst.obs.base.cameraMapper.CameraMapper.filters

Definition at line 276 of file cameraMapper.py.

◆ keyDict

lsst.obs.base.cameraMapper.CameraMapper.keyDict

Definition at line 266 of file cameraMapper.py.

◆ levels

lsst.obs.base.cameraMapper.CameraMapper.levels

Definition at line 208 of file cameraMapper.py.

◆ log

lsst.obs.base.cameraMapper.CameraMapper.log

Definition at line 194 of file cameraMapper.py.

◆ makeRawVisitInfo

lsst.obs.base.cameraMapper.CameraMapper.makeRawVisitInfo

Definition at line 283 of file cameraMapper.py.

◆ MakeRawVisitInfoClass

lsst.obs.base.cameraMapper.CameraMapper.MakeRawVisitInfoClass = MakeRawVisitInfo

static

Definition at line 180 of file cameraMapper.py.

◆ mappings

lsst.obs.base.cameraMapper.CameraMapper.mappings

Definition at line 334 of file cameraMapper.py.

◆ packageName

lsst.obs.base.cameraMapper.CameraMapper.packageName = None

static

Definition at line 176 of file cameraMapper.py.

◆ PupilFactoryClass

lsst.obs.base.cameraMapper.CameraMapper.PupilFactoryClass = afwCameraGeom.PupilFactory

static

Definition at line 183 of file cameraMapper.py.

◆ registry

lsst.obs.base.cameraMapper.CameraMapper.registry

Definition at line 246 of file cameraMapper.py.

◆ root

lsst.obs.base.cameraMapper.CameraMapper.root

Definition at line 197 of file cameraMapper.py.

◆ rootStorage

lsst.obs.base.cameraMapper.CameraMapper.rootStorage

Definition at line 223 of file cameraMapper.py.

◆ translatorClass

lsst.obs.base.cameraMapper.CameraMapper.translatorClass = None

static

Definition at line 186 of file cameraMapper.py.

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

/j/snowflake/release/lsstsw/stack/Linux64/obs_base/18.1.0-27-g6ff7ca9+2/python/lsst/obs/base/cameraMapper.py

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __getstate__()

◆ __new__()

◆ __setstate__()

◆ backup()

◆ bypass_camera()

◆ bypass_expIdInfo()

◆ canStandardize()

◆ getCameraName()

◆ getDatasetTypes()

◆ getDefaultLevel()

◆ getDefaultSubLevel()

◆ getImageCompressionSettings()

◆ getKeys()

◆ getPackageDir()

◆ getPackageName()

◆ getRegistry()

◆ getShortCcdName()

◆ keys()

◆ map()

◆ map_camera()

◆ map_expIdInfo()

◆ map_skypolicy()

◆ queryMetadata()

◆ standardize()

◆ std_bfKernel()

◆ std_raw()

◆ std_skypolicy()

◆ validate()

Member Data Documentation

◆ calibRegistry

◆ camera

◆ cameraDataLocation

◆ category

◆ defaultLevel

◆ defaultSubLevels

◆ filters

◆ keyDict

◆ levels

◆ log

◆ makeRawVisitInfo

◆ MakeRawVisitInfoClass

◆ mappings

◆ packageName

◆ PupilFactoryClass

◆ registry

◆ root

◆ rootStorage

◆ translatorClass

◆ init()

◆ getstate()

◆ new()

◆ setstate()