Inheritance diagram for lsst.jointcal.jointcal.JointcalTask:

Public Member Functions
def	__init__ (self, butler=None, initInputs=None, **kwargs)

def	runQuantum (self, butlerQC, inputRefs, outputRefs)

def	run (self, inputSourceTableVisit, inputVisitSummary, inputCamera, tract=None)

def	loadData (self, dataRefs, associations, jointcalControl)

def	runDataRef (self, dataRefs)

Public Attributes
	astrometryRefObjLoader

	photometryRefObjLoader

	job

	focalPlaneBBox

Static Public Attributes
	ConfigClass = JointcalConfig

	RunnerClass = JointcalRunner

Detailed Description

Astrometricly and photometricly calibrate across multiple visits of the
same field.

Parameters
----------
butler : `lsst.daf.persistence.Butler`
    The butler is passed to the refObjLoader constructor in case it is
    needed. Ignored if the refObjLoader argument provides a loader directly.
    Used to initialize the astrometry and photometry refObjLoaders.
initInputs : `dict`, optional
    Dictionary used to initialize PipelineTasks (empty for jointcal).

Definition at line 654 of file jointcal.py.

Constructor & Destructor Documentation

◆ init()

def lsst.jointcal.jointcal.JointcalTask.__init__	(		self,
			butler = `None`,
			initInputs = `None`,
		**	kwargs
	)

Definition at line 672 of file jointcal.py.

     def __init__(self, butler=None, initInputs=None, **kwargs):
         super().__init__(**kwargs)
         self.makeSubtask("sourceSelector")
         if self.config.doAstrometry:
             if initInputs is None:
                 # gen3 middleware does refcat things internally (and will not have a butler here)
                 self.makeSubtask('astrometryRefObjLoader', butler=butler)
             self.makeSubtask("astrometryReferenceSelector")
         else:
             self.astrometryRefObjLoader = None
         if self.config.doPhotometry:
             if initInputs is None:
                 # gen3 middleware does refcat things internally (and will not have a butler here)
                 self.makeSubtask('photometryRefObjLoader', butler=butler)
             self.makeSubtask("photometryReferenceSelector")
         else:
             self.photometryRefObjLoader = None
  
         # To hold various computed metrics for use by tests
         self.job = Job.load_metrics_package(subset='jointcal')
  

Member Function Documentation

◆ loadData()

def lsst.jointcal.jointcal.JointcalTask.loadData	(	self,
		dataRefs,
		associations,
		jointcalControl
	)

Read the data that jointcal needs to run. (Gen2 version)

Definition at line 1135 of file jointcal.py.

     def loadData(self, dataRefs, associations, jointcalControl):
         """Read the data that jointcal needs to run. (Gen2 version)"""
         visit_ccd_to_dataRef = {}
         oldWcsList = []
         filters = []
         load_cat_prof_file = 'jointcal_loadData.prof' if self.config.detailedProfile else ''
         with pipeBase.cmdLineTask.profile(load_cat_prof_file):
             # Need the bounding-box of the focal plane (the same for all visits) for photometry visit models
             camera = dataRefs[0].get('camera', immediate=True)
             self.focalPlaneBBox = camera.getFpBBox()
             for dataRef in dataRefs:
                 data = self._readDataId(dataRef.getButler(), dataRef.dataId)
                 result = self._build_ccdImage(data, associations, jointcalControl)
                 if result is None:
                     continue
                 oldWcsList.append(result.wcs)
                 visit_ccd_to_dataRef[result.key] = dataRef
                 filters.append(data.filter)
         if len(filters) == 0:
             raise RuntimeError("No data to process: did source selector remove all sources?")
         filters = collections.Counter(filters)
  
         return oldWcsList, filters, visit_ccd_to_dataRef
  

◆ run()

def lsst.jointcal.jointcal.JointcalTask.run	(	self,
		inputSourceTableVisit,
		inputVisitSummary,
		inputCamera,
		tract = `None`
	)

Definition at line 797 of file jointcal.py.

     def run(self, inputSourceTableVisit, inputVisitSummary, inputCamera, tract=None):
         # Docstring inherited.
  
         # We take values out of the Parquet table, and put them in "flux_",
         # and the config.sourceFluxType field is used during that extraction,
         # so just use "flux" here.
         sourceFluxField = "flux"
         jointcalControl = lsst.jointcal.JointcalControl(sourceFluxField)
         associations = lsst.jointcal.Associations()
         self.focalPlaneBBox = inputCamera.getFpBBox()
         oldWcsList, bands = self._load_data(inputSourceTableVisit,
                                             inputVisitSummary,
                                             associations,
                                             jointcalControl,
                                             inputCamera)
  
         boundingCircle, center, radius, defaultFilter, epoch = self._prep_sky(associations, bands)
  
         if self.config.doAstrometry:
             astrometry = self._do_load_refcat_and_fit(associations, defaultFilter, center, radius,
                                                       name="astrometry",
                                                       refObjLoader=self.astrometryRefObjLoader,
                                                       referenceSelector=self.astrometryReferenceSelector,
                                                       fit_function=self._fit_astrometry,
                                                       tract=tract,
                                                       epoch=epoch)
             astrometry_output = self._make_output(associations.getCcdImageList(),
                                                   astrometry.model,
                                                   "makeSkyWcs")
         else:
             astrometry_output = None
  
         if self.config.doPhotometry:
             photometry = self._do_load_refcat_and_fit(associations, defaultFilter, center, radius,
                                                       name="photometry",
                                                       refObjLoader=self.photometryRefObjLoader,
                                                       referenceSelector=self.photometryReferenceSelector,
                                                       fit_function=self._fit_photometry,
                                                       tract=tract,
                                                       epoch=epoch,
                                                       reject_bad_fluxes=True)
             photometry_output = self._make_output(associations.getCcdImageList(),
                                                   photometry.model,
                                                   "toPhotoCalib")
         else:
             photometry_output = None
  
         return pipeBase.Struct(outputWcs=astrometry_output,
                                outputPhotoCalib=photometry_output,
                                job=self.job,
                                astrometryRefObjLoader=self.astrometryRefObjLoader,
                                photometryRefObjLoader=self.photometryRefObjLoader)
  

◆ runDataRef()

def lsst.jointcal.jointcal.JointcalTask.runDataRef	(	self,
		dataRefs
	)

Jointly calibrate the astrometry and photometry across a set of images.

NOTE: this is for gen2 middleware only.

Parameters
----------
dataRefs : `list` of `lsst.daf.persistence.ButlerDataRef`
    List of data references to the exposures to be fit.

Returns
-------
result : `lsst.pipe.base.Struct`
    Struct of metadata from the fit, containing:

    ``dataRefs``
        The provided data references that were fit (with updated WCSs)
    ``oldWcsList``
        The original WCS from each dataRef
    ``metrics``
        Dictionary of internally-computed metrics for testing/validation.

Definition at line 1187 of file jointcal.py.

     def runDataRef(self, dataRefs):
         """
         Jointly calibrate the astrometry and photometry across a set of images.
  
         NOTE: this is for gen2 middleware only.
  
         Parameters
         ----------
         dataRefs : `list` of `lsst.daf.persistence.ButlerDataRef`
             List of data references to the exposures to be fit.
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             Struct of metadata from the fit, containing:
  
             ``dataRefs``
                 The provided data references that were fit (with updated WCSs)
             ``oldWcsList``
                 The original WCS from each dataRef
             ``metrics``
                 Dictionary of internally-computed metrics for testing/validation.
         """
         if len(dataRefs) == 0:
             raise ValueError('Need a non-empty list of data references!')
  
         exitStatus = 0  # exit status for shell
  
         sourceFluxField = "slot_%sFlux" % (self.config.sourceFluxType,)
         jointcalControl = lsst.jointcal.JointcalControl(sourceFluxField)
         associations = lsst.jointcal.Associations()
  
         oldWcsList, filters, visit_ccd_to_dataRef = self.loadData(dataRefs,
                                                                   associations,
                                                                   jointcalControl)
  
         boundingCircle, center, radius, defaultFilter, epoch = self._prep_sky(associations, filters)
  
         tract = dataRefs[0].dataId['tract']
  
         if self.config.doAstrometry:
             astrometry = self._do_load_refcat_and_fit(associations, defaultFilter, center, radius,
                                                       name="astrometry",
                                                       refObjLoader=self.astrometryRefObjLoader,
                                                       referenceSelector=self.astrometryReferenceSelector,
                                                       fit_function=self._fit_astrometry,
                                                       tract=tract,
                                                       epoch=epoch)
             self._write_astrometry_results(associations, astrometry.model, visit_ccd_to_dataRef)
         else:
             astrometry = Astrometry(None, None, None)
  
         if self.config.doPhotometry:
             photometry = self._do_load_refcat_and_fit(associations, defaultFilter, center, radius,
                                                       name="photometry",
                                                       refObjLoader=self.photometryRefObjLoader,
                                                       referenceSelector=self.photometryReferenceSelector,
                                                       fit_function=self._fit_photometry,
                                                       tract=tract,
                                                       epoch=epoch,
                                                       reject_bad_fluxes=True)
             self._write_photometry_results(associations, photometry.model, visit_ccd_to_dataRef)
         else:
             photometry = Photometry(None, None)
  
         return pipeBase.Struct(dataRefs=dataRefs,
                                oldWcsList=oldWcsList,
                                job=self.job,
                                astrometryRefObjLoader=self.astrometryRefObjLoader,
                                photometryRefObjLoader=self.photometryRefObjLoader,
                                defaultFilter=defaultFilter,
                                epoch=epoch,
                                exitStatus=exitStatus)
  

◆ runQuantum()

def lsst.jointcal.jointcal.JointcalTask.runQuantum	(	self,
		butlerQC,
		inputRefs,
		outputRefs
	)

Definition at line 693 of file jointcal.py.

     def runQuantum(self, butlerQC, inputRefs, outputRefs):
         # We override runQuantum to set up the refObjLoaders and write the
         # outputs to the correct refs.
         inputs = butlerQC.get(inputRefs)
         # We want the tract number for writing debug files
         tract = butlerQC.quantum.dataId['tract']
         if self.config.doAstrometry:
             self.astrometryRefObjLoader = ReferenceObjectLoader(
                 dataIds=[ref.datasetRef.dataId
                          for ref in inputRefs.astrometryRefCat],
                 refCats=inputs.pop('astrometryRefCat'),
                 config=self.config.astrometryRefObjLoader,
                 log=self.log)
         if self.config.doPhotometry:
             self.photometryRefObjLoader = ReferenceObjectLoader(
                 dataIds=[ref.datasetRef.dataId
                          for ref in inputRefs.photometryRefCat],
                 refCats=inputs.pop('photometryRefCat'),
                 config=self.config.photometryRefObjLoader,
                 log=self.log)
         outputs = self.run(**inputs, tract=tract)
         self._put_metrics(butlerQC, outputs.job, outputRefs)
         if self.config.doAstrometry:
             self._put_output(butlerQC, outputs.outputWcs, outputRefs.outputWcs,
                              inputs['inputCamera'], "setWcs")
         if self.config.doPhotometry:
             self._put_output(butlerQC, outputs.outputPhotoCalib, outputRefs.outputPhotoCalib,
                              inputs['inputCamera'], "setPhotoCalib")
  

Member Data Documentation

◆ astrometryRefObjLoader

lsst.jointcal.jointcal.JointcalTask.astrometryRefObjLoader

Definition at line 681 of file jointcal.py.

◆ ConfigClass

lsst.jointcal.jointcal.JointcalTask.ConfigClass = JointcalConfig

static

Definition at line 668 of file jointcal.py.

◆ focalPlaneBBox

lsst.jointcal.jointcal.JointcalTask.focalPlaneBBox

Definition at line 806 of file jointcal.py.

◆ job

lsst.jointcal.jointcal.JointcalTask.job

Definition at line 691 of file jointcal.py.

◆ photometryRefObjLoader

lsst.jointcal.jointcal.JointcalTask.photometryRefObjLoader

Definition at line 688 of file jointcal.py.

◆ RunnerClass

lsst.jointcal.jointcal.JointcalTask.RunnerClass = JointcalRunner