lsst.obs.test.testMapper.TestMapper Class Reference

Inheritance diagram for lsst.obs.test.testMapper.TestMapper:

Public Member Functions
def	__init__ (self, inputPolicy=None, **kwargs)
def	bypass_ccdExposureId (self, datasetType, pythonType, location, dataId)
def	bypass_ccdExposureId_bits (self, datasetType, pythonType, location, dataId)
def	validate (self, dataId)
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	getGen3Instrument (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)

Static Public Member Functions
def	getShortCcdName (ccdName)

Public Attributes
	doFootprints
	filterIdMap
	log
	root
	levels
	defaultLevel
	defaultSubLevels
	rootStorage
	registry
	calibRegistry
	keyDict
	cameraDataLocation
	camera
	filters
	makeRawVisitInfo
	mappings

Static Public Attributes
string	packageName = 'obs_test'
	MakeRawVisitInfoClass = MakeTestRawVisitInfo
	PupilFactoryClass = afwCameraGeom.PupilFactory
	translatorClass = None

Detailed Description

Camera mapper for the Test camera.

Definition at line 34 of file testMapper.py.

Constructor & Destructor Documentation

__init__()

def lsst.obs.test.testMapper.TestMapper.__init__	(		self,
			inputPolicy = None,
		**	kwargs
	)

Definition at line 41 of file testMapper.py.

    def __init__(self, inputPolicy=None, **kwargs):
        policyFilePath = dafPersist.Policy.defaultPolicyFile(self.packageName, "testMapper.yaml", "policy")
        policy = dafPersist.Policy(policyFilePath)
 
        self.doFootprints = False
        if inputPolicy is not None:
            for kw in inputPolicy.paramNames(True):
                if kw == "doFootprints":
                    self.doFootprints = True
                else:
                    kwargs[kw] = inputPolicy.get(kw)
 
        CameraMapper.__init__(self, policy, policyFilePath, **kwargs)
        self.filterIdMap = {
            'u': 0, 'g': 1, 'r': 2, 'i': 3, 'z': 4, 'y': 5, 'i2': 5}
 
        # The LSST Filters from L. Jones 04/07/10
        afwImageUtils.defineFilter('u', 364.59)
        afwImageUtils.defineFilter('g', 476.31)
        afwImageUtils.defineFilter('r', 619.42)
        afwImageUtils.defineFilter('i', 752.06)
        afwImageUtils.defineFilter('z', 866.85)
        afwImageUtils.defineFilter('y', 971.68, alias=['y4'])  # official y filter
 

Member Function Documentation

__getstate__()

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

inherited

Definition at line 101 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 82 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 104 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  )

inherited

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.

Reimplemented from lsst.daf.persistence.mapper.Mapper.

Definition at line 599 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  )

inherited

Return the (preloaded) camera object.

Definition at line 751 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_ccdExposureId()

def lsst.obs.test.testMapper.TestMapper.bypass_ccdExposureId	(		self,
			datasetType,
			pythonType,
			location,
			dataId
	)

Definition at line 101 of file testMapper.py.

    def bypass_ccdExposureId(self, datasetType, pythonType, location, dataId):
        return self._computeCcdExposureId(dataId)
 

bypass_ccdExposureId_bits()

def lsst.obs.test.testMapper.TestMapper.bypass_ccdExposureId_bits	(		self,
			datasetType,
			pythonType,
			location,
			dataId
	)

Definition at line 104 of file testMapper.py.

    def bypass_ccdExposureId_bits(self, datasetType, pythonType, location, dataId):
        return 41
 

bypass_expIdInfo()

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

inherited

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

Definition at line 769 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 165 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 )

inherited

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

Definition at line 694 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 126 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 )

inherited

Definition at line 685 of file cameraMapper.py.

    def getDefaultLevel(self):
        return self.defaultLevel
 

getDefaultSubLevel()

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

inherited

Definition at line 688 of file cameraMapper.py.

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

getGen3Instrument()

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

inherited

Return the gen3 Instrument class equivalent for this gen2 Mapper.

Returns
-------
instr : `type`
    A `~lsst.obs.base.Instrument` class.

Definition at line 712 of file cameraMapper.py.

    def getGen3Instrument(cls):
        """Return the gen3 Instrument class equivalent for this gen2 Mapper.
 
        Returns
        -------
        instr : `type`
            A `~lsst.obs.base.Instrument` class.
        """
        if cls._gen3instrument is None:
            raise NotImplementedError("Please provide a specific implementation for your instrument"
                                      " to enable conversion of this gen2 repository to gen3")
        if isinstance(cls._gen3instrument, str):
            # Given a string to convert to an instrument class
            cls._gen3instrument = doImport(cls._gen3instrument)
        if not issubclass(cls._gen3instrument, Instrument):
            raise ValueError(f"Mapper {cls} has declared a gen3 instrument class of {cls._gen3instrument}"
                             " but that is not an lsst.obs.base.Instrument")
        return cls._gen3instrument
 

getImageCompressionSettings()

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

inherited

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 1209 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  )

inherited

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 650 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 lev in self.levels[level]:
                if lev in keyDict:
                    del keyDict[lev]
        return keyDict
 

getPackageDir()

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

inherited

Return the base directory of this package

Reimplemented in lsst.obs.base.test.baseMapper.BaseMapper.

Definition at line 732 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 )

inherited

Return the name of the package containing this CameraMapper.

Definition at line 705 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 )

inherited

Get the registry used by this mapper.

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

Reimplemented from lsst.daf.persistence.mapper.Mapper.

Definition at line 1199 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 )

staticinherited

Convert a CCD name to a form useful as a filename

The default implementation converts spaces to underscores.

Definition at line 963 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 )

inherited

Return supported keys.

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

Reimplemented from lsst.daf.persistence.mapper.Mapper.

Definition at line 640 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 135 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  )

inherited

Map a camera dataset.

Definition at line 736 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  )

inherited

Definition at line 758 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  )

inherited

Map a sky policy.

Definition at line 791 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 112 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 171 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  )

inherited

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 775 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  )

inherited

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

Reimplemented in lsst.obs.decam.decamMapper.DecamMapper.

Definition at line 785 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  )

inherited

Standardize a sky policy by returning the one we use.

Definition at line 797 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.obs.test.testMapper.TestMapper.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.

Reimplemented from lsst.daf.persistence.mapper.Mapper.

Definition at line 107 of file testMapper.py.

    def validate(self, dataId):
        visit = dataId.get("visit")
        if visit is not None and not isinstance(visit, int):
            dataId["visit"] = int(visit)
        return dataId
 

Member Data Documentation

calibRegistry

lsst.obs.base.cameraMapper.CameraMapper.calibRegistry

inherited

Definition at line 255 of file cameraMapper.py.

camera

lsst.obs.base.cameraMapper.CameraMapper.camera

inherited

Definition at line 273 of file cameraMapper.py.

cameraDataLocation

lsst.obs.base.cameraMapper.CameraMapper.cameraDataLocation

inherited

Definition at line 272 of file cameraMapper.py.

defaultLevel

lsst.obs.base.cameraMapper.CameraMapper.defaultLevel

inherited

Definition at line 214 of file cameraMapper.py.

defaultSubLevels

lsst.obs.base.cameraMapper.CameraMapper.defaultSubLevels

inherited

Definition at line 215 of file cameraMapper.py.

doFootprints

lsst.obs.test.testMapper.TestMapper.doFootprints

Definition at line 45 of file testMapper.py.

filterIdMap

lsst.obs.test.testMapper.TestMapper.filterIdMap

Definition at line 54 of file testMapper.py.

filters

lsst.obs.base.cameraMapper.CameraMapper.filters

inherited

Definition at line 276 of file cameraMapper.py.

keyDict

lsst.obs.base.cameraMapper.CameraMapper.keyDict

inherited

Definition at line 266 of file cameraMapper.py.

levels

lsst.obs.base.cameraMapper.CameraMapper.levels

inherited

Definition at line 209 of file cameraMapper.py.

log

lsst.obs.base.cameraMapper.CameraMapper.log

inherited

Definition at line 195 of file cameraMapper.py.

makeRawVisitInfo

lsst.obs.base.cameraMapper.CameraMapper.makeRawVisitInfo

inherited

Definition at line 283 of file cameraMapper.py.

MakeRawVisitInfoClass

lsst.obs.test.testMapper.TestMapper.MakeRawVisitInfoClass = MakeTestRawVisitInfo

static

Definition at line 39 of file testMapper.py.

mappings

lsst.obs.base.cameraMapper.CameraMapper.mappings

inherited

Definition at line 336 of file cameraMapper.py.

packageName

string lsst.obs.test.testMapper.TestMapper.packageName = 'obs_test'

static

Definition at line 37 of file testMapper.py.

PupilFactoryClass

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

staticinherited

Definition at line 182 of file cameraMapper.py.

registry

lsst.obs.base.cameraMapper.CameraMapper.registry

inherited

Definition at line 247 of file cameraMapper.py.

root

lsst.obs.base.cameraMapper.CameraMapper.root

inherited

Definition at line 198 of file cameraMapper.py.

rootStorage

lsst.obs.base.cameraMapper.CameraMapper.rootStorage

inherited

Definition at line 224 of file cameraMapper.py.

translatorClass

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

staticinherited

Definition at line 185 of file cameraMapper.py.

---

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

• /j/snowflake/release/lsstsw/stack/cb4e2dc/Linux64/obs_test/20.0.0-2-g0070d88+ba3ffc8f0b/python/lsst/obs/test/testMapper.py