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	getPackageDir (cls)
def	map_camera (self, dataId, write=False)
def	bypass_camera (self, datasetType, pythonType, butlerLocation, dataId)
def	map_defects (self, dataId, write=False)
def	bypass_defects (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
	defectRegistry
	defectPath
	filters
	makeRawVisitInfo
	mappings

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

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

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.

Definition at line 566 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 697 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_defects()

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

inherited

Return a defect based on the butler location returned by map_defects

Parameters
----------
butlerLocation : `lsst.daf.persistence.ButlerLocation`
    locationList = path to defects FITS file
dataId : `dict`
    Butler data ID; "ccd" must be set.

Note: the name "bypass_XXX" means the butler makes no attempt to
convert the ButlerLocation into an object, which is what we want for
now, since that conversion is a bit tricky.

Definition at line 721 of file cameraMapper.py.

    def bypass_defects(self, datasetType, pythonType, butlerLocation, dataId):
        """Return a defect based on the butler location returned by map_defects

        Parameters
        ----------
        butlerLocation : `lsst.daf.persistence.ButlerLocation`
            locationList = path to defects FITS file
        dataId : `dict`
            Butler data ID; "ccd" must be set.

        Note: the name "bypass_XXX" means the butler makes no attempt to
        convert the ButlerLocation into an object, which is what we want for
        now, since that conversion is a bit tricky.
        """
        detectorName = self._extractDetectorName(dataId)
        defectsFitsPath = butlerLocation.locationList[0]

        with fits.open(defectsFitsPath) as hduList:
            for hdu in hduList[1:]:
                if hdu.header["name"] != detectorName:
                    continue

                defectList = []
                for data in hdu.data:
                    bbox = afwGeom.Box2I(
                        afwGeom.Point2I(int(data['x0']), int(data['y0'])),
                        afwGeom.Extent2I(int(data['width']), int(data['height'])),
                    )
                    defectList.append(afwImage.DefectBase(bbox))
                return defectList

        raise RuntimeError("No defects for ccd %s in %s" % (detectorName, defectsFitsPath))

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

inherited

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

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

inherited

Definition at line 651 of file cameraMapper.py.

    def getDefaultLevel(self):
        return self.defaultLevel

getDefaultSubLevel()

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

inherited

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

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 1212 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 617 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 )

inherited

Return the base directory of this package

Definition at line 678 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 671 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.

Definition at line 1202 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 965 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

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

inherited

Map a camera dataset.

Definition at line 682 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_defects()

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

inherited

Map defects dataset.

Returns
-------
`lsst.daf.butler.ButlerLocation`
    Minimal ButlerLocation containing just the locationList field
    (just enough information that bypass_defects can use it).

Definition at line 704 of file cameraMapper.py.

    def map_defects(self, dataId, write=False):
        """Map defects dataset.

        Returns
        -------
        `lsst.daf.butler.ButlerLocation`
            Minimal ButlerLocation containing just the locationList field
            (just enough information that bypass_defects can use it).
        """
        defectFitsPath = self._defectLookup(dataId=dataId)
        if defectFitsPath is None:
            raise RuntimeError("No defects available for dataId=%s" % (dataId,))

        return dafPersist.ButlerLocation(None, None, None, defectFitsPath,
                                         dataId, self,
                                         storage=self.rootStorage)

map_expIdInfo()

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

inherited

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

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 771 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

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

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 251 of file cameraMapper.py.

camera

lsst.obs.base.cameraMapper.CameraMapper.camera

inherited

Definition at line 270 of file cameraMapper.py.

cameraDataLocation

lsst.obs.base.cameraMapper.CameraMapper.cameraDataLocation

inherited

Definition at line 269 of file cameraMapper.py.

defaultLevel

lsst.obs.base.cameraMapper.CameraMapper.defaultLevel

inherited

Definition at line 210 of file cameraMapper.py.

defaultSubLevels

lsst.obs.base.cameraMapper.CameraMapper.defaultSubLevels

inherited

Definition at line 211 of file cameraMapper.py.

defectPath

lsst.obs.base.cameraMapper.CameraMapper.defectPath

inherited

Definition at line 276 of file cameraMapper.py.

defectRegistry

lsst.obs.base.cameraMapper.CameraMapper.defectRegistry

inherited

Definition at line 274 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 281 of file cameraMapper.py.

keyDict

lsst.obs.base.cameraMapper.CameraMapper.keyDict

inherited

Definition at line 263 of file cameraMapper.py.

levels

lsst.obs.base.cameraMapper.CameraMapper.levels

inherited

Definition at line 205 of file cameraMapper.py.

log

lsst.obs.base.cameraMapper.CameraMapper.log

inherited

Definition at line 191 of file cameraMapper.py.

makeRawVisitInfo

lsst.obs.base.cameraMapper.CameraMapper.makeRawVisitInfo

inherited

Definition at line 288 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 333 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 157 of file cameraMapper.py.

registry

lsst.obs.base.cameraMapper.CameraMapper.registry

inherited

Definition at line 243 of file cameraMapper.py.

root

lsst.obs.base.cameraMapper.CameraMapper.root

inherited

Definition at line 194 of file cameraMapper.py.

rootStorage

lsst.obs.base.cameraMapper.CameraMapper.rootStorage

inherited

Definition at line 220 of file cameraMapper.py.

---

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

• /j/snowflake/release/lsstsw/stack/Linux64/obs_test/18.1.0/python/lsst/obs/test/testMapper.py