Inheritance diagram for lsst.obs.base.butler_tests.ButlerGetTests:

Public Member Functions
def	setUp_butler_get (self, ccdExposureId_bits=None, exposureIds=None, filters=None, exptimes=None, detectorIds=None, detector_names=None, detector_serials=None, dimensions=None, sky_origin=None, raw_subsets=None, good_detectorIds=None, bad_detectorIds=None, linearizer_type=None, raw_header_wcs=None)

def	test_exposureId_bits (self)

def	test_raw (self)

def	test_bias (self)

def	test_dark (self)

def	test_flat (self)

def	test_raw_header_wcs (self)

def	test_raw_sub_bbox (self)

def	test_subset_raw (self)

def	test_get_linearizer (self)

def	test_get_linearizer_bad_detectorIds (self)

Public Attributes
	butler_get_data

Detailed Description

Tests of obs_* Butler get() functionality.

In the subclasses's setUp():
    * Call setUp_butler_get() to fill in required parameters.

Definition at line 30 of file butler_tests.py.

Member Function Documentation

◆ setUp_butler_get()

def lsst.obs.base.butler_tests.ButlerGetTests.setUp_butler_get	(	self,
		ccdExposureId_bits = `None`,
		exposureIds = `None`,
		filters = `None`,
		exptimes = `None`,
		detectorIds = `None`,
		detector_names = `None`,
		detector_serials = `None`,
		dimensions = `None`,
		sky_origin = `None`,
		raw_subsets = `None`,
		good_detectorIds = `None`,
		bad_detectorIds = `None`,
		linearizer_type = `None`,
		raw_header_wcs = `None`
	)

Set up the necessary variables for butlerGet tests.

All "exposure name" entries below should correspond to an entry in
self.dataIds.

Parameters
----------

ccdExposureId_bits : `int`
    expected value of ccdExposureId_bits
exposureIds : `dict`
    dict of exposure name : ccdExposureId (the number as returned by
    the butler)
filters : `dict`
    dict of exposure name : filter name
exptimes : `dict`
    dict of exposure name : exposure time
detector_names : `dict`
    dict of exposure name : detector name
detectorIds : `dict`
    dict of exposure name : detectorId
detector_serials : `dict`
    dict of exposure name : detector serial
dimensions : `dict`
    dict of exposure name : dimensions (as a geom.Extent2I)
sky_origin : `tuple` of `float`
    Longitude, Latitude of 'raw' exposure
raw_subsets : `tuple` of (kwargs, `int`)
    keyword args and expected number of subsets for
    ``butler.subset('raw', **kwargs)``
good_detectorIds : `list` of `int`
    list of valid ccd numbers
bad_detectorIds : `list` of `int`
    list of invalid ccd numbers
linearizer_type : `dict`
    dict of detectorId (usually `int`): LinearizerType
    (e.g. lsst.ip.isr.LinearizeLookupTable.LinearityType),
    or unittest.SkipTest to skip all linearizer tests.
raw_header_wcs : `lsst.afw.geom.SkyWcs`
    The SkyWcs object that should be returned by
    ``butler.get("raw_header_wcs", dataId=self.dataIds["raw"])``

Definition at line 37 of file butler_tests.py.

                          ):
         """
         Set up the necessary variables for butlerGet tests.
  
         All "exposure name" entries below should correspond to an entry in
         self.dataIds.
  
         Parameters
         ----------
  
         ccdExposureId_bits : `int`
             expected value of ccdExposureId_bits
         exposureIds : `dict`
             dict of exposure name : ccdExposureId (the number as returned by
             the butler)
         filters : `dict`
             dict of exposure name : filter name
         exptimes : `dict`
             dict of exposure name : exposure time
         detector_names : `dict`
             dict of exposure name : detector name
         detectorIds : `dict`
             dict of exposure name : detectorId
         detector_serials : `dict`
             dict of exposure name : detector serial
         dimensions : `dict`
             dict of exposure name : dimensions (as a geom.Extent2I)
         sky_origin : `tuple` of `float`
             Longitude, Latitude of 'raw' exposure
         raw_subsets : `tuple` of (kwargs, `int`)
             keyword args and expected number of subsets for
             ``butler.subset('raw', **kwargs)``
         good_detectorIds : `list` of `int`
             list of valid ccd numbers
         bad_detectorIds : `list` of `int`
             list of invalid ccd numbers
         linearizer_type : `dict`
             dict of detectorId (usually `int`): LinearizerType
             (e.g. lsst.ip.isr.LinearizeLookupTable.LinearityType),
             or unittest.SkipTest to skip all linearizer tests.
         raw_header_wcs : `lsst.afw.geom.SkyWcs`
             The SkyWcs object that should be returned by
             ``butler.get("raw_header_wcs", dataId=self.dataIds["raw"])``
         """
  
         fields = ['ccdExposureId_bits',
                   'exposureIds',
                   'filters',
                   'exptimes',
                   'detector_names',
                   'detectorIds',
                   'detector_serials',
                   'dimensions',
                   'sky_origin',
                   'raw_subsets',
                   'good_detectorIds',
                   'bad_detectorIds',
                   'linearizer_type',
                   'raw_header_wcs'
                   ]
         ButlerGet = collections.namedtuple("ButlerGetData", fields)
  
         self.butler_get_data = ButlerGet(ccdExposureId_bits=ccdExposureId_bits,
                                          exposureIds=exposureIds,
                                          filters=filters,
                                          exptimes=exptimes,
                                          detectorIds=detectorIds,
                                          detector_names=detector_names,
                                          detector_serials=detector_serials,
                                          dimensions=dimensions,
                                          sky_origin=sky_origin,
                                          raw_subsets=raw_subsets,
                                          good_detectorIds=good_detectorIds,
                                          bad_detectorIds=bad_detectorIds,
                                          linearizer_type=linearizer_type,
                                          raw_header_wcs=raw_header_wcs
                                          )
  

◆ test_bias()

def lsst.obs.base.butler_tests.ButlerGetTests.test_bias ( self )

Definition at line 174 of file butler_tests.py.

     def test_bias(self):
         self._test_exposure('bias')
  

◆ test_dark()

def lsst.obs.base.butler_tests.ButlerGetTests.test_dark ( self )

Definition at line 177 of file butler_tests.py.

     def test_dark(self):
         self._test_exposure('dark')
  

◆ test_exposureId_bits()

def lsst.obs.base.butler_tests.ButlerGetTests.test_exposureId_bits ( self )

Definition at line 130 of file butler_tests.py.

     def test_exposureId_bits(self):
         bits = self.butler.get('ccdExposureId_bits')
         self.assertEqual(bits, self.butler_get_data.ccdExposureId_bits)
  

◆ test_flat()

def lsst.obs.base.butler_tests.ButlerGetTests.test_flat ( self )

Definition at line 180 of file butler_tests.py.

     def test_flat(self):
         self._test_exposure('flat')
  

◆ test_get_linearizer()

def lsst.obs.base.butler_tests.ButlerGetTests.test_get_linearizer ( self )

Test that we can get a linearizer for good detectorIds.

Definition at line 204 of file butler_tests.py.

     def test_get_linearizer(self):
         """Test that we can get a linearizer for good detectorIds."""
         if self.butler_get_data.linearizer_type is unittest.SkipTest:
             self.skipTest('Skipping %s as requested' % (inspect.currentframe().f_code.co_name))
  
         camera = self.butler.get("camera")
         for detectorId in self.butler_get_data.good_detectorIds:
             detector = camera[detectorId]
             linearizer = self.butler.get("linearizer", dataId=dict(ccd=detectorId), immediate=True)
             self.assertEqual(linearizer.LinearityType, self.butler_get_data.linearizer_type[detectorId])
             linearizer.checkDetector(detector)
  

◆ test_get_linearizer_bad_detectorIds()

def lsst.obs.base.butler_tests.ButlerGetTests.test_get_linearizer_bad_detectorIds ( self )

Do bad detectorIds raise?

Definition at line 216 of file butler_tests.py.

     def test_get_linearizer_bad_detectorIds(self):
         """Do bad detectorIds raise?"""
         if self.butler_get_data.linearizer_type is unittest.SkipTest:
             self.skipTest('Skipping %s as requested' % (inspect.currentframe().f_code.co_name))
  
         for badccd in self.butler_get_data.bad_detectorIds:
             with self.assertRaises(RuntimeError):
                 self.butler.get("linearizer", dataId=dict(ccd=badccd), immediate=True)

◆ test_raw()

def lsst.obs.base.butler_tests.ButlerGetTests.test_raw ( self )

Definition at line 161 of file butler_tests.py.

     def test_raw(self):
         exp = self._test_exposure('raw')
         # We only test the existence of WCS in the raw files, since it's only
         # well-defined  for raw, and other exposure types could have or not
         # have a WCS depending on various implementation details.
         # Even for raw, there are data that do not have a WCS, e.g. teststand
         # data
         if self.butler_get_data.sky_origin is not unittest.SkipTest:
             self.assertEqual(exp.hasWcs(), True)
             origin = exp.getWcs().getSkyOrigin()
             self.assertAlmostEqual(origin.getLongitude().asDegrees(), self.butler_get_data.sky_origin[0])
             self.assertAlmostEqual(origin.getLatitude().asDegrees(), self.butler_get_data.sky_origin[1])
  

◆ test_raw_header_wcs()

def lsst.obs.base.butler_tests.ButlerGetTests.test_raw_header_wcs ( self )

Test that `raw_header_wcs` returns the unmodified raw image header.

Definition at line 183 of file butler_tests.py.

     def test_raw_header_wcs(self):
         """Test that `raw_header_wcs` returns the unmodified raw image header.
         """
         if self.butler_get_data.raw_header_wcs is not None:
             wcs = self.butler.get('raw_header_wcs', self.dataIds['raw'])
             self.assertEqual(wcs, self.butler_get_data.raw_header_wcs)
  

◆ test_raw_sub_bbox()

def lsst.obs.base.butler_tests.ButlerGetTests.test_raw_sub_bbox ( self )

Definition at line 191 of file butler_tests.py.

     def test_raw_sub_bbox(self):
         exp = self.butler.get('raw', self.dataIds['raw'], immediate=True)
         bbox = exp.getBBox()
         bbox.grow(-1)
         sub = self.butler.get("raw_sub", self.dataIds['raw'], bbox=bbox, immediate=True)
         self.assertEqual(sub.getImage().getBBox(), bbox)
         self.assertImagesEqual(sub, exp.Factory(exp, bbox))
  

◆ test_subset_raw()

def lsst.obs.base.butler_tests.ButlerGetTests.test_subset_raw ( self )

Definition at line 199 of file butler_tests.py.

     def test_subset_raw(self):
         for kwargs, expect in self.butler_get_data.raw_subsets:
             subset = self.butler.subset("raw", **kwargs)
             self.assertEqual(len(subset), expect, msg="Failed for kwargs: {}".format(kwargs))
  

Member Data Documentation

◆ butler_get_data

lsst.obs.base.butler_tests.ButlerGetTests.butler_get_data

Definition at line 114 of file butler_tests.py.

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

/j/snowflake/release/lsstsw/stack/0.2.1/Linux64/obs_base/21.0.0-27-gbbd0d29+ae871e0f33/python/lsst/obs/base/butler_tests.py

Public Member Functions

Public Attributes