lsst.obs.decam.decamMapper.DecamMapper Class Reference

Inheritance diagram for lsst.obs.decam.decamMapper.DecamMapper:

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	bypass_deepCoaddId (self, datasetType, pythonType, location, dataId)
def	bypass_deepCoaddId_bits (self, *args, **kwargs)
def	bypass_deepMergedCoaddId (self, datasetType, pythonType, location, dataId)
def	bypass_deepMergedCoaddId_bits (self, *args, **kwargs)
def	bypass_dcrCoaddId (self, datasetType, pythonType, location, dataId)
def	bypass_dcrCoaddId_bits (self, *args, **kwargs)
def	bypass_dcrMergedCoaddId (self, datasetType, pythonType, location, dataId)
def	bypass_dcrMergedCoaddId_bits (self, *args, **kwargs)
def	translate_dqmask (self, dqmask)
def	translate_wtmap (self, wtmap)
def	bypass_instcal (self, datasetType, pythonType, butlerLocation, dataId)
def	std_raw (self, item, dataId)
def	std_dark (self, item, dataId)
def	std_bias (self, item, dataId)
def	std_flat (self, item, dataId)
def	std_illumcor (self, item, dataId)
def	std_cpBias (self, item, dataId)
def	std_cpFlat (self, item, dataId)
def	std_fringe (self, item, dataId)
def	std_cpIllumcor (self, item, dataId)
def	getLinearizerDir (cls)
def	map_linearizer (self, dataId, write=False)
def	getCrosstalkDir (cls)

Static Public Attributes
string	packageName = 'obs_decam'
	MakeRawVisitInfoClass = MakeDecamRawVisitInfo
dictionary	detectorNames

Detailed Description

Definition at line 45 of file decamMapper.py.

Constructor & Destructor Documentation

__init__()

def lsst.obs.decam.decamMapper.DecamMapper.__init__	(		self,
			inputPolicy = None,
		**	kwargs
	)

Definition at line 61 of file decamMapper.py.

    def __init__(self, inputPolicy=None, **kwargs):
        policyFile = Policy.defaultPolicyFile(self.packageName, "DecamMapper.yaml", "policy")
        policy = Policy(policyFile)
 
        super(DecamMapper, self).__init__(policy, os.path.dirname(policyFile), **kwargs)
 
        DECAM_FILTER_DEFINITIONS.defineFilters()
 
        # The data ID key ccdnum is not directly used in the current policy
        # template of the raw and instcal et al. datasets, so is not in its
        # keyDict automatically. Add it so the butler know about the data ID key
        # ccdnum.
        # Similarly, add "object" for raws.
        for datasetType in ("raw", "instcal", "dqmask", "wtmap", "cpIllumcor"):
            self.mappings[datasetType].keyDict.update({'ccdnum': int})
        self.mappings["raw"].keyDict.update({'object': str})
 
        # The number of bits allocated for fields in object IDs
        # TODO: This needs to be updated; also see Trac #2797
        DecamMapper._nbit_tract = 10
        DecamMapper._nbit_patch = 10
        DecamMapper._nbit_filter = 4
        DecamMapper._nbit_id = 64 - (DecamMapper._nbit_tract
                                     + 2*DecamMapper._nbit_patch
                                     + DecamMapper._nbit_filter)
 

Member Function Documentation

bypass_ccdExposureId()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_ccdExposureId	(		self,
			datasetType,
			pythonType,
			location,
			dataId
	)

Definition at line 100 of file decamMapper.py.

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

bypass_ccdExposureId_bits()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_ccdExposureId_bits	(		self,
			datasetType,
			pythonType,
			location,
			dataId
	)

Definition at line 103 of file decamMapper.py.

    def bypass_ccdExposureId_bits(self, datasetType, pythonType, location, dataId):
        return 32  # not really, but this leaves plenty of space for sources
 

bypass_dcrCoaddId()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_dcrCoaddId	(		self,
			datasetType,
			pythonType,
			location,
			dataId
	)

Definition at line 164 of file decamMapper.py.

    def bypass_dcrCoaddId(self, datasetType, pythonType, location, dataId):
        return self.bypass_deepCoaddId(datasetType, pythonType, location, dataId)
 

bypass_dcrCoaddId_bits()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_dcrCoaddId_bits	(		self,
		*	args,
		**	kwargs
	)

Definition at line 167 of file decamMapper.py.

    def bypass_dcrCoaddId_bits(self, *args, **kwargs):
        return self.bypass_deepCoaddId_bits(*args, **kwargs)
 

bypass_dcrMergedCoaddId()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_dcrMergedCoaddId	(		self,
			datasetType,
			pythonType,
			location,
			dataId
	)

Definition at line 170 of file decamMapper.py.

    def bypass_dcrMergedCoaddId(self, datasetType, pythonType, location, dataId):
        return self.bypass_deepMergedCoaddId(datasetType, pythonType, location, dataId)
 

bypass_dcrMergedCoaddId_bits()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_dcrMergedCoaddId_bits	(		self,
		*	args,
		**	kwargs
	)

Definition at line 173 of file decamMapper.py.

    def bypass_dcrMergedCoaddId_bits(self, *args, **kwargs):
        return self.bypass_deepMergedCoaddId_bits(*args, **kwargs)
 

bypass_deepCoaddId()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_deepCoaddId	(		self,
			datasetType,
			pythonType,
			location,
			dataId
	)

Definition at line 152 of file decamMapper.py.

    def bypass_deepCoaddId(self, datasetType, pythonType, location, dataId):
        return self._computeCoaddExposureId(dataId, True)
 

bypass_deepCoaddId_bits()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_deepCoaddId_bits	(		self,
		*	args,
		**	kwargs
	)

Definition at line 155 of file decamMapper.py.

    def bypass_deepCoaddId_bits(self, *args, **kwargs):
        return 64 - DecamMapper._nbit_id
 

bypass_deepMergedCoaddId()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_deepMergedCoaddId	(		self,
			datasetType,
			pythonType,
			location,
			dataId
	)

Definition at line 158 of file decamMapper.py.

    def bypass_deepMergedCoaddId(self, datasetType, pythonType, location, dataId):
        return self._computeCoaddExposureId(dataId, False)
 

bypass_deepMergedCoaddId_bits()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_deepMergedCoaddId_bits	(		self,
		*	args,
		**	kwargs
	)

Definition at line 161 of file decamMapper.py.

    def bypass_deepMergedCoaddId_bits(self, *args, **kwargs):
        return 64 - DecamMapper._nbit_id
 

bypass_instcal()

def lsst.obs.decam.decamMapper.DecamMapper.bypass_instcal	(		self,
			datasetType,
			pythonType,
			butlerLocation,
			dataId
	)

Definition at line 205 of file decamMapper.py.

    def bypass_instcal(self, datasetType, pythonType, butlerLocation, dataId):
        # Workaround until I can access the butler
        instcalMap = self.map_instcal(dataId)
        dqmaskMap = self.map_dqmask(dataId)
        wtmapMap = self.map_wtmap(dataId)
        instcalType = getattr(afwImage, instcalMap.getPythonType().split(".")[-1])
        dqmaskType = getattr(afwImage, dqmaskMap.getPythonType().split(".")[-1])
        wtmapType = getattr(afwImage, wtmapMap.getPythonType().split(".")[-1])
        instcal = instcalType(instcalMap.getLocationsWithRoot()[0])
        dqmask = dqmaskType(dqmaskMap.getLocationsWithRoot()[0])
        wtmap = wtmapType(wtmapMap.getLocationsWithRoot()[0])
 
        mask = self.translate_dqmask(dqmask)
        variance = self.translate_wtmap(wtmap)
 
        mi = afwImage.MaskedImageF(afwImage.ImageF(instcal.getImage()), mask, variance)
        md = readMetadata(instcalMap.getLocationsWithRoot()[0])
        fix_header(md, translator_class=DecamTranslator)
        wcs = makeSkyWcs(md, strip=True)
        exp = afwImage.ExposureF(mi, wcs)
 
        exp.setPhotoCalib(afwImage.makePhotoCalibFromCalibZeroPoint(10**(0.4 * md.getScalar("MAGZERO")), 0))
        visitInfo = self.makeRawVisitInfo(md=md)
        exp.getInfo().setVisitInfo(visitInfo)
        if 'EXPID' in md:
            exp.info.id = md['EXPID']
 
        for kw in ('LTV1', 'LTV2'):
            md.remove(kw)
 
        exp.setMetadata(md)
        return exp
 

getCrosstalkDir()

def lsst.obs.decam.decamMapper.DecamMapper.getCrosstalkDir

(

cls

)

Directory containing crosstalk tables.

Definition at line 377 of file decamMapper.py.

    def getCrosstalkDir(cls):
        """Directory containing crosstalk tables.
        """
        packageName = cls.getPackageName()
        packageDir = getPackageDir(packageName)
        return os.path.join(packageDir, "decam", "crosstalk")

getLinearizerDir()

def lsst.obs.decam.decamMapper.DecamMapper.getLinearizerDir

(

cls

)

Directory containing linearizers

Definition at line 356 of file decamMapper.py.

    def getLinearizerDir(cls):
        """Directory containing linearizers"""
        packageName = cls.getPackageName()
        packageDir = getPackageDir(packageName)
        return os.path.join(packageDir, "decam", "linearizer")
 

map_linearizer()

def lsst.obs.decam.decamMapper.DecamMapper.map_linearizer	(		self,
			dataId,
			write = False
	)

Map a linearizer

Definition at line 362 of file decamMapper.py.

    def map_linearizer(self, dataId, write=False):
        """Map a linearizer"""
        actualId = self._transformId(dataId)
        location = "%02d.fits" % (dataId["ccdnum"])
        return ButlerLocation(
            pythonType="lsst.ip.isr.LinearizeSquared",
            cppType="Config",
            storageName="PickleStorage",
            locationList=[location],
            dataId=actualId,
            mapper=self,
            storage=Storage.makeFromURI(self.getLinearizerDir())
        )
 

std_bias()

def lsst.obs.decam.decamMapper.DecamMapper.std_bias	(		self,
			item,
			dataId
	)

Definition at line 291 of file decamMapper.py.

    def std_bias(self, item, dataId):
        exp = afwImage.makeExposure(afwImage.makeMaskedImage(item))
        return self._standardizeExposure(self.calibrations["bias"], exp, dataId, filter=False)
 

std_cpBias()

def lsst.obs.decam.decamMapper.DecamMapper.std_cpBias	(		self,
			item,
			dataId
	)

Definition at line 342 of file decamMapper.py.

    def std_cpBias(self, item, dataId):
        return self._standardizeCpMasterCal("cpBias", item, dataId, setFilter=False)
 

std_cpFlat()

def lsst.obs.decam.decamMapper.DecamMapper.std_cpFlat	(		self,
			item,
			dataId
	)

Definition at line 345 of file decamMapper.py.

    def std_cpFlat(self, item, dataId):
        return self._standardizeCpMasterCal("cpFlat", item, dataId, setFilter=True)
 

std_cpIllumcor()

def lsst.obs.decam.decamMapper.DecamMapper.std_cpIllumcor	(		self,
			item,
			dataId
	)

Definition at line 352 of file decamMapper.py.

    def std_cpIllumcor(self, item, dataId):
        return self._standardizeCpMasterCal("cpIllumcor", item, dataId, setFilter=True)
 

std_dark()

def lsst.obs.decam.decamMapper.DecamMapper.std_dark	(		self,
			item,
			dataId
	)

Definition at line 281 of file decamMapper.py.

    def std_dark(self, item, dataId):
        exp = afwImage.makeExposure(afwImage.makeMaskedImage(item))
        rawPath = self.map_raw(dataId).getLocations()[0]
        headerPath = re.sub(r'[\[](\d+)[\]]$', "[0]", rawPath)
        md0 = readMetadata(headerPath)
        fix_header(md0, translator_class=DecamTranslator)
        visitInfo = self.makeRawVisitInfo(md0)
        exp.getInfo().setVisitInfo(visitInfo)
        return self._standardizeExposure(self.calibrations["dark"], exp, dataId, filter=False)
 

std_flat()

def lsst.obs.decam.decamMapper.DecamMapper.std_flat	(		self,
			item,
			dataId
	)

Definition at line 295 of file decamMapper.py.

    def std_flat(self, item, dataId):
        exp = afwImage.makeExposure(afwImage.makeMaskedImage(item))
        return self._standardizeExposure(self.calibrations["flat"], exp, dataId, filter=True)
 

std_fringe()

def lsst.obs.decam.decamMapper.DecamMapper.std_fringe	(		self,
			item,
			dataId
	)

Definition at line 348 of file decamMapper.py.

    def std_fringe(self, item, dataId):
        exp = afwImage.makeExposure(afwImage.makeMaskedImage(item))
        return self._standardizeExposure(self.calibrations["fringe"], exp, dataId)
 

std_illumcor()

def lsst.obs.decam.decamMapper.DecamMapper.std_illumcor	(		self,
			item,
			dataId
	)

Definition at line 299 of file decamMapper.py.

    def std_illumcor(self, item, dataId):
        exp = afwImage.makeExposure(afwImage.makeMaskedImage(item))
        return self._standardizeExposure(self.calibrations["illumcor"], exp, dataId, filter=True)
 

std_raw()

def lsst.obs.decam.decamMapper.DecamMapper.std_raw	(		self,
			item,
			dataId
	)

Standardize a raw dataset by converting it to an Exposure.

Raw images are MEF files with one HDU for each detector.

Parameters
----------
item : `lsst.afw.image.DecoratedImage`
    The image read by the butler.
dataId : data ID
    Data identifier.

Returns
-------
result : `lsst.afw.image.Exposure`
    The standardized Exposure.

Definition at line 238 of file decamMapper.py.

    def std_raw(self, item, dataId):
        """Standardize a raw dataset by converting it to an Exposure.
 
        Raw images are MEF files with one HDU for each detector.
 
        Parameters
        ----------
        item : `lsst.afw.image.DecoratedImage`
            The image read by the butler.
        dataId : data ID
            Data identifier.
 
        Returns
        -------
        result : `lsst.afw.image.Exposure`
            The standardized Exposure.
        """
        return self._standardizeExposure(self.exposures['raw'], item, dataId,
                                         trimmed=False, setExposureId=True)
 

translate_dqmask()

def lsst.obs.decam.decamMapper.DecamMapper.translate_dqmask	(		self,
			dqmask
	)

Definition at line 176 of file decamMapper.py.

    def translate_dqmask(self, dqmask):
        # TODO: make a class member variable that knows the mappings
        # below instead of hard-coding them
        dqmArr = dqmask.getArray()
        mask = afwImage.Mask(dqmask.getDimensions())
        mArr = mask.getArray()
        idxBad = np.where(dqmArr & 1)
        idxSat = np.where(dqmArr & 2)
        idxIntrp = np.where(dqmArr & 4)
        idxCr = np.where(dqmArr & 16)
        idxBleed = np.where(dqmArr & 64)
        idxEdge = np.where(dqmArr & 512)
        mArr[idxBad] |= mask.getPlaneBitMask("BAD")
        mArr[idxSat] |= mask.getPlaneBitMask("SAT")
        mArr[idxIntrp] |= mask.getPlaneBitMask("INTRP")
        mArr[idxCr] |= mask.getPlaneBitMask("CR")
        mArr[idxBleed] |= mask.getPlaneBitMask("SAT")
        mArr[idxEdge] |= mask.getPlaneBitMask("EDGE")
        return mask
 

translate_wtmap()

def lsst.obs.decam.decamMapper.DecamMapper.translate_wtmap	(		self,
			wtmap
	)

Definition at line 196 of file decamMapper.py.

    def translate_wtmap(self, wtmap):
        wtmArr = wtmap.getArray()
        idxUndefWeight = np.where(wtmArr <= 0)
        # Reassign weights to be finite but small:
        wtmArr[idxUndefWeight] = min(1e-14, np.min(wtmArr[np.where(wtmArr > 0)]))
        var = 1.0 / wtmArr
        varim = afwImage.ImageF(var)
        return varim
 

Member Data Documentation

detectorNames

dictionary lsst.obs.decam.decamMapper.DecamMapper.detectorNames

static

Initial value:

=  {
        1: 'S29', 2: 'S30', 3: 'S31', 4: 'S25', 5: 'S26', 6: 'S27', 7: 'S28', 8: 'S20', 9: 'S21',
        10: 'S22', 11: 'S23', 12: 'S24', 13: 'S14', 14: 'S15', 15: 'S16', 16: 'S17', 17: 'S18',
        18: 'S19', 19: 'S8', 20: 'S9', 21: 'S10', 22: 'S11', 23: 'S12', 24: 'S13', 25: 'S1', 26: 'S2',
        27: 'S3', 28: 'S4', 29: 'S5', 30: 'S6', 31: 'S7', 32: 'N1', 33: 'N2', 34: 'N3', 35: 'N4',
        36: 'N5', 37: 'N6', 38: 'N7', 39: 'N8', 40: 'N9', 41: 'N10', 42: 'N11', 43: 'N12', 44: 'N13',
        45: 'N14', 46: 'N15', 47: 'N16', 48: 'N17', 49: 'N18', 50: 'N19', 51: 'N20', 52: 'N21',
        53: 'N22', 54: 'N23', 55: 'N24', 56: 'N25', 57: 'N26', 58: 'N27', 59: 'N28', 60: 'N29',
        62: 'N31'}

Definition at line 51 of file decamMapper.py.

MakeRawVisitInfoClass

lsst.obs.decam.decamMapper.DecamMapper.MakeRawVisitInfoClass = MakeDecamRawVisitInfo

static

Definition at line 49 of file decamMapper.py.

packageName

string lsst.obs.decam.decamMapper.DecamMapper.packageName = 'obs_decam'

static

Definition at line 46 of file decamMapper.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/obs_decam/22.0.1-16-g9282f48+790f5f2caa/python/lsst/obs/decam/decamMapper.py