lsst.fgcmcal  21.0.0-10-g8d1d15d+069596c267
fgcmCalibrateTractBase.py
Go to the documentation of this file.
1 # This file is part of fgcmcal.
2 #
3 # Developed for the LSST Data Management System.
4 # This product includes software developed by the LSST Project
5 # (https://www.lsst.org).
6 # See the COPYRIGHT file at the top-level directory of this distribution
7 # for details of code ownership.
8 #
9 # This program is free software: you can redistribute it and/or modify
10 # it under the terms of the GNU General Public License as published by
11 # the Free Software Foundation, either version 3 of the License, or
12 # (at your option) any later version.
13 #
14 # This program is distributed in the hope that it will be useful,
15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 # GNU General Public License for more details.
18 #
19 # You should have received a copy of the GNU General Public License
20 # along with this program. If not, see <https://www.gnu.org/licenses/>.
21 """Base class for running fgcmcal on a single tract using src tables
22 or sourceTable_visit tables.
23 """
24 
25 import sys
26 import traceback
27 import abc
28 
29 import numpy as np
30 
31 import lsst.daf.persistence as dafPersist
32 import lsst.pex.config as pexConfig
33 import lsst.pipe.base as pipeBase
34 
35 from .fgcmBuildStars import FgcmBuildStarsTask, FgcmBuildStarsConfig
36 from .fgcmFitCycle import FgcmFitCycleConfig
37 from .fgcmOutputProducts import FgcmOutputProductsTask
38 from .utilities import makeConfigDict, translateFgcmLut, translateVisitCatalog
39 from .utilities import computeCcdOffsets, computeApertureRadiusFromDataRef, extractReferenceMags
40 from .utilities import makeZptSchema, makeZptCat
41 from .utilities import makeAtmSchema, makeAtmCat
42 from .utilities import makeStdSchema, makeStdCat
43 
44 import fgcm
45 
46 __all__ = ['FgcmCalibrateTractConfigBase', 'FgcmCalibrateTractBaseTask', 'FgcmCalibrateTractRunner']
47 
48 
49 class FgcmCalibrateTractConfigBase(pexConfig.Config):
50  """Config for FgcmCalibrateTract"""
51 
52  fgcmBuildStars = pexConfig.ConfigurableField(
53  target=FgcmBuildStarsTask,
54  doc="Task to load and match stars for fgcm",
55  )
56  fgcmFitCycle = pexConfig.ConfigField(
57  dtype=FgcmFitCycleConfig,
58  doc="Config to run a single fgcm fit cycle",
59  )
60  fgcmOutputProducts = pexConfig.ConfigurableField(
61  target=FgcmOutputProductsTask,
62  doc="Task to output fgcm products",
63  )
64  convergenceTolerance = pexConfig.Field(
65  doc="Tolerance on repeatability convergence (per band)",
66  dtype=float,
67  default=0.005,
68  )
69  maxFitCycles = pexConfig.Field(
70  doc="Maximum number of fit cycles",
71  dtype=int,
72  default=5,
73  )
74  doDebuggingPlots = pexConfig.Field(
75  doc="Make plots for debugging purposes?",
76  dtype=bool,
77  default=False,
78  )
79 
80  def setDefaults(self):
81  pexConfig.Config.setDefaults(self)
82 
83  self.fgcmFitCyclefgcmFitCycle.quietMode = True
84  self.fgcmOutputProductsfgcmOutputProducts.doReferenceCalibration = False
85  self.fgcmOutputProductsfgcmOutputProducts.doRefcatOutput = False
86  self.fgcmOutputProductsfgcmOutputProducts.cycleNumber = 0
87  self.fgcmOutputProductsfgcmOutputProducts.photoCal.applyColorTerms = False
88 
89  def validate(self):
90  super().validate()
91 
92  for band in self.fgcmFitCyclefgcmFitCycle.bands:
93  if not self.fgcmFitCyclefgcmFitCycle.useRepeatabilityForExpGrayCutsDict[band]:
94  msg = 'Must set useRepeatabilityForExpGrayCutsDict[band]=True for all bands'
95  raise pexConfig.FieldValidationError(FgcmFitCycleConfig.useRepeatabilityForExpGrayCutsDict,
96  self, msg)
97 
98 
99 class FgcmCalibrateTractRunner(pipeBase.ButlerInitializedTaskRunner):
100  """Subclass of TaskRunner for FgcmCalibrateTractTask
101 
102  fgcmCalibrateTractTask.run() takes a number of arguments, one of which is
103  the butler (for persistence and mapper data), and a list of dataRefs
104  extracted from the command line. This task runs on a constrained set
105  of dataRefs, typically a single tract.
106  This class transforms the process arguments generated by the ArgumentParser
107  into the arguments expected by FgcmCalibrateTractTask.run().
108  This runner does not use any parallelization.
109  """
110 
111  @staticmethod
112  def getTargetList(parsedCmd):
113  """
114  Return a list with one element: a tuple with the butler and
115  list of dataRefs.
116  """
117  return [(parsedCmd.butler, parsedCmd.id.refList)]
118 
119  def __call__(self, args):
120  """
121  Parameters
122  ----------
123  args: `tuple` with (butler, dataRefList)
124 
125  Returns
126  -------
127  exitStatus: `list` with `lsst.pipe.base.Struct`
128  exitStatus (0: success; 1: failure)
129  May also contain results if `self.doReturnResults` is `True`.
130  """
131  butler, dataRefList = args
132 
133  task = self.TaskClass(config=self.config, log=self.log)
134 
135  exitStatus = 0
136  if self.doRaise:
137  results = task.runDataRef(butler, dataRefList)
138  else:
139  try:
140  results = task.runDataRef(butler, dataRefList)
141  except Exception as e:
142  exitStatus = 1
143  task.log.fatal("Failed: %s" % e)
144  if not isinstance(e, pipeBase.TaskError):
145  traceback.print_exc(file=sys.stderr)
146 
147  task.writeMetadata(butler)
148 
149  if self.doReturnResults:
150  return [pipeBase.Struct(exitStatus=exitStatus,
151  results=results)]
152  else:
153  return [pipeBase.Struct(exitStatus=exitStatus)]
154 
155  def run(self, parsedCmd):
156  """
157  Run the task, with no multiprocessing
158 
159  Parameters
160  ----------
161  parsedCmd: `lsst.pipe.base.ArgumentParser` parsed command line
162  """
163 
164  resultList = []
165 
166  if self.precall(parsedCmd):
167  targetList = self.getTargetListgetTargetList(parsedCmd)
168  resultList = self(targetList[0])
169 
170  return resultList
171 
172 
173 class FgcmCalibrateTractBaseTask(pipeBase.PipelineTask, pipeBase.CmdLineTask, abc.ABC):
174  """Base class to calibrate a single tract using fgcmcal
175  """
176  def __init__(self, butler=None, **kwargs):
177  """
178  Instantiate an `FgcmCalibrateTractTask`.
179 
180  Parameters
181  ----------
182  butler : `lsst.daf.persistence.Butler`, optional
183  """
184  super().__init__(**kwargs)
185  self.makeSubtask("fgcmBuildStars", butler=butler)
186  self.makeSubtask("fgcmOutputProducts", butler=butler)
187 
188  # no saving of metadata for now
189  def _getMetadataName(self):
190  return None
191 
192  @pipeBase.timeMethod
193  def runDataRef(self, butler, dataRefs):
194  """
195  Run full FGCM calibration on a single tract, including building star list,
196  fitting multiple cycles, and making outputs.
197 
198  Parameters
199  ----------
200  butler: `lsst.daf.persistence.Butler`
201  dataRefs: `list` of `lsst.daf.persistence.ButlerDataRef`
202  Data references for the input visits.
203  These may be either per-ccd "src" or per-visit"sourceTable_visit"
204  references.
205 
206  Raises
207  ------
208  RuntimeError: Raised if `config.fgcmBuildStars.doReferenceMatches` is
209  not True, or if fgcmLookUpTable is not available, or if
210  doSubtractLocalBackground is True and aperture radius cannot be
211  determined.
212  """
213  datasetType = dataRefs[0].butlerSubset.datasetType
214  self.log.info("Running with %d %s dataRefs" % (len(dataRefs), datasetType))
215 
216  if not butler.datasetExists('fgcmLookUpTable'):
217  raise RuntimeError("Must run FgcmCalibrateTract with an fgcmLookUpTable")
218 
219  if not self.config.fgcmBuildStars.doReferenceMatches:
220  raise RuntimeError("Must run FgcmCalibrateTract with fgcmBuildStars.doReferenceMatches")
221  if isinstance(self.config.fgcmBuildStars, FgcmBuildStarsConfig):
222  if self.config.fgcmBuildStars.checkAllCcds:
223  raise RuntimeError("Cannot run FgcmCalibrateTract with "
224  "fgcmBuildStars.checkAllCcds set to True")
225 
226  tract = int(dataRefs[0].dataId['tract'])
227  camera = butler.get('camera')
228 
229  dataRefDict = {}
230  dataRefDict['camera'] = camera
231  dataRefDict['source_catalogs'] = dataRefs
232  dataRefDict['sourceSchema'] = butler.dataRef('src_schema')
233  dataRefDict['fgcmLookUpTable'] = butler.dataRef('fgcmLookUpTable')
234 
235  struct = self.runrun(dataRefDict, tract, butler=butler, returnCatalogs=False)
236 
237  visitDataRefName = self.config.fgcmBuildStars.visitDataRefName
238  ccdDataRefName = self.config.fgcmBuildStars.ccdDataRefName
239 
240  if struct.photoCalibs is not None:
241  self.log.info("Outputting photoCalib files.")
242 
243  for visit, detector, physicalFilter, photoCalib in struct.photoCalibs:
244  butler.put(photoCalib, 'fgcm_tract_photoCalib',
245  dataId={visitDataRefName: visit,
246  ccdDataRefName: detector,
247  'filter': physicalFilter,
248  'tract': tract})
249 
250  self.log.info("Done outputting photoCalib files.")
251 
252  if struct.atmospheres is not None:
253  self.log.info("Outputting atmosphere files.")
254  for visit, atm in struct.atmospheres:
255  butler.put(atm, "transmission_atmosphere_fgcm_tract",
256  dataId={visitDataRefName: visit,
257  'tract': tract})
258  self.log.info("Done outputting atmosphere transmissions.")
259 
260  return pipeBase.Struct(repeatability=struct.repeatability)
261 
262  def run(self, dataRefDict, tract,
263  buildStarsRefObjLoader=None, returnCatalogs=True, butler=None):
264  """Run the calibrations for a single tract with fgcm.
265 
266  Parameters
267  ----------
268  dataRefDict : `dict`
269  All dataRefs are `lsst.daf.persistence.ButlerDataRef` (gen2) or
270  `lsst.daf.butler.DeferredDatasetHandle` (gen3)
271  dataRef dictionary with the following keys. Note that all
272  keys need not be set based on config parameters.
273 
274  ``"camera"``
275  Camera object (`lsst.afw.cameraGeom.Camera`)
276  ``"source_catalogs"``
277  `list` of dataRefs for input source catalogs.
278  ``"sourceSchema"``
279  Schema for the source catalogs.
280  ``"fgcmLookUpTable"``
281  dataRef for the FGCM look-up table.
282  ``"calexps"``
283  `list` of dataRefs for the input calexps (Gen3 only)
284  ``"fgcmPhotoCalibs"``
285  `dict` of output photoCalib dataRefs. Key is
286  (tract, visit, detector). (Gen3 only)
287  Present if doZeropointOutput is True.
288  ``"fgcmTransmissionAtmospheres"``
289  `dict` of output atmosphere transmission dataRefs.
290  Key is (tract, visit). (Gen3 only)
291  Present if doAtmosphereOutput is True.
292  tract : `int`
293  Tract number
294  buildStarsRefObjLoader : `lsst.meas.algorithms.ReferenceObjectLoader`, optional
295  Reference object loader object for fgcmBuildStars.
296  returnCatalogs : `bool`, optional
297  Return photoCalibs as per-visit exposure catalogs.
298  butler : `lsst.daf.persistence.Butler`, optional
299  Gen2 butler used for reference star outputs
300 
301  Returns
302  -------
303  outstruct : `lsst.pipe.base.Struct`
304  Output structure with keys:
305 
306  offsets : `np.ndarray`
307  Final reference offsets, per band.
308  repeatability : `np.ndarray`
309  Raw fgcm repeatability for bright stars, per band.
310  atmospheres : `generator` [(`int`, `lsst.afw.image.TransmissionCurve`)]
311  Generator that returns (visit, transmissionCurve) tuples.
312  photoCalibs : `generator` [(`int`, `int`, `str`, `lsst.afw.image.PhotoCalib`)]
313  Generator that returns (visit, ccd, filtername, photoCalib) tuples.
314  (returned if returnCatalogs is False).
315  photoCalibCatalogs : `generator` [(`int`, `lsst.afw.table.ExposureCatalog`)]
316  Generator that returns (visit, exposureCatalog) tuples.
317  (returned if returnCatalogs is True).
318  """
319  self.log.info("Running on tract %d", (tract))
320 
321  # Compute the aperture radius if necessary. This is useful to do now before
322  # any heavy lifting has happened (fail early).
323  calibFluxApertureRadius = None
324  if self.config.fgcmBuildStars.doSubtractLocalBackground:
325  try:
326  field = self.config.fgcmBuildStars.instFluxField
327  calibFluxApertureRadius = computeApertureRadiusFromDataRef(dataRefDict['source_catalogs'][0],
328  field)
329  except RuntimeError:
330  raise RuntimeError("Could not determine aperture radius from %s. "
331  "Cannot use doSubtractLocalBackground." %
332  (field))
333 
334  # Run the build stars tasks
335 
336  # Note that we will need visitCat at the end of the procedure for the outputs
337  if isinstance(butler, dafPersist.Butler):
338  # Gen2
339  groupedDataRefs = self.fgcmBuildStars._findAndGroupDataRefsGen2(butler, dataRefDict['camera'],
340  dataRefDict['source_catalogs'])
341  else:
342  # Gen3
343  groupedDataRefs = self.fgcmBuildStars._groupDataRefs(dataRefDict['sourceTableDataRefDict'],
344  dataRefDict['visitSummaryDataRefDict'])
345  visitCat = self.fgcmBuildStars.fgcmMakeVisitCatalog(dataRefDict['camera'], groupedDataRefs)
346  rad = calibFluxApertureRadius
347  fgcmStarObservationCat = self.fgcmBuildStars.fgcmMakeAllStarObservations(groupedDataRefs,
348  visitCat,
349  dataRefDict['sourceSchema'],
350  dataRefDict['camera'],
351  calibFluxApertureRadius=rad)
352 
353  if self.fgcmBuildStars.config.doReferenceMatches:
354  lutDataRef = dataRefDict['fgcmLookUpTable']
355  if buildStarsRefObjLoader is not None:
356  self.fgcmBuildStars.makeSubtask("fgcmLoadReferenceCatalog",
357  refObjLoader=buildStarsRefObjLoader)
358  else:
359  self.fgcmBuildStars.makeSubtask("fgcmLoadReferenceCatalog", butler=butler)
360  else:
361  lutDataRef = None
362 
363  fgcmStarIdCat, fgcmStarIndicesCat, fgcmRefCat = \
364  self.fgcmBuildStars.fgcmMatchStars(visitCat,
365  fgcmStarObservationCat,
366  lutDataRef=lutDataRef)
367 
368  # Load the LUT
369  lutCat = dataRefDict['fgcmLookUpTable'].get()
370  fgcmLut, lutIndexVals, lutStd = translateFgcmLut(lutCat,
371  dict(self.config.fgcmFitCycle.physicalFilterMap))
372  del lutCat
373 
374  # Translate the visit catalog into fgcm format
375  fgcmExpInfo = translateVisitCatalog(visitCat)
376 
377  configDict = makeConfigDict(self.config.fgcmFitCycle, self.log, dataRefDict['camera'],
378  self.config.fgcmFitCycle.maxIterBeforeFinalCycle,
379  True, False, tract=tract)
380  # Turn off plotting in tract mode
381  configDict['doPlots'] = False
382 
383  # Use the first orientation.
384  # TODO: DM-21215 will generalize to arbitrary camera orientations
385  ccdOffsets = computeCcdOffsets(dataRefDict['camera'], fgcmExpInfo['TELROT'][0])
386 
387  # Set up the fit cycle task
388 
389  noFitsDict = {'lutIndex': lutIndexVals,
390  'lutStd': lutStd,
391  'expInfo': fgcmExpInfo,
392  'ccdOffsets': ccdOffsets}
393 
394  fgcmFitCycle = fgcm.FgcmFitCycle(configDict, useFits=False,
395  noFitsDict=noFitsDict, noOutput=True)
396 
397  # We determine the conversion from the native units (typically radians) to
398  # degrees for the first star. This allows us to treat coord_ra/coord_dec as
399  # numpy arrays rather than Angles, which would we approximately 600x slower.
400  conv = fgcmStarObservationCat[0]['ra'].asDegrees() / float(fgcmStarObservationCat[0]['ra'])
401 
402  # To load the stars, we need an initial parameter object
403  fgcmPars = fgcm.FgcmParameters.newParsWithArrays(fgcmFitCycle.fgcmConfig,
404  fgcmLut,
405  fgcmExpInfo)
406 
407  # Match star observations to visits
408  # Only those star observations that match visits from fgcmExpInfo['VISIT'] will
409  # actually be transferred into fgcm using the indexing below.
410 
411  obsIndex = fgcmStarIndicesCat['obsIndex']
412  visitIndex = np.searchsorted(fgcmExpInfo['VISIT'],
413  fgcmStarObservationCat['visit'][obsIndex])
414 
415  refMag, refMagErr = extractReferenceMags(fgcmRefCat,
416  self.config.fgcmFitCycle.bands,
417  self.config.fgcmFitCycle.physicalFilterMap)
418  refId = fgcmRefCat['fgcm_id'][:]
419 
420  fgcmStars = fgcm.FgcmStars(fgcmFitCycle.fgcmConfig)
421  fgcmStars.loadStars(fgcmPars,
422  fgcmStarObservationCat['visit'][obsIndex],
423  fgcmStarObservationCat['ccd'][obsIndex],
424  fgcmStarObservationCat['ra'][obsIndex] * conv,
425  fgcmStarObservationCat['dec'][obsIndex] * conv,
426  fgcmStarObservationCat['instMag'][obsIndex],
427  fgcmStarObservationCat['instMagErr'][obsIndex],
428  fgcmExpInfo['FILTERNAME'][visitIndex],
429  fgcmStarIdCat['fgcm_id'][:],
430  fgcmStarIdCat['ra'][:],
431  fgcmStarIdCat['dec'][:],
432  fgcmStarIdCat['obsArrIndex'][:],
433  fgcmStarIdCat['nObs'][:],
434  obsX=fgcmStarObservationCat['x'][obsIndex],
435  obsY=fgcmStarObservationCat['y'][obsIndex],
436  obsDeltaMagBkg=fgcmStarObservationCat['deltaMagBkg'][obsIndex],
437  psfCandidate=fgcmStarObservationCat['psf_candidate'][obsIndex],
438  refID=refId,
439  refMag=refMag,
440  refMagErr=refMagErr,
441  flagID=None,
442  flagFlag=None,
443  computeNobs=True)
444 
445  # Clear out some memory
446  del fgcmStarIdCat
447  del fgcmStarIndicesCat
448  del fgcmRefCat
449 
450  fgcmFitCycle.setLUT(fgcmLut)
451  fgcmFitCycle.setStars(fgcmStars, fgcmPars)
452 
453  converged = False
454  cycleNumber = 0
455 
456  previousReservedRawRepeatability = np.zeros(fgcmPars.nBands) + 1000.0
457  previousParInfo = None
458  previousParams = None
459  previousSuperStar = None
460 
461  while (not converged and cycleNumber < self.config.maxFitCycles):
462 
463  fgcmFitCycle.fgcmConfig.updateCycleNumber(cycleNumber)
464 
465  if cycleNumber > 0:
466  # Use parameters from previous cycle
467  fgcmPars = fgcm.FgcmParameters.loadParsWithArrays(fgcmFitCycle.fgcmConfig,
468  fgcmExpInfo,
469  previousParInfo,
470  previousParams,
471  previousSuperStar)
472  # We need to reset the star magnitudes and errors for the next
473  # cycle
474  fgcmFitCycle.fgcmStars.reloadStarMagnitudes(fgcmStarObservationCat['instMag'][obsIndex],
475  fgcmStarObservationCat['instMagErr'][obsIndex])
476  fgcmFitCycle.initialCycle = False
477 
478  fgcmFitCycle.setPars(fgcmPars)
479  fgcmFitCycle.finishSetup()
480 
481  fgcmFitCycle.run()
482 
483  # Grab the parameters for the next cycle
484  previousParInfo, previousParams = fgcmFitCycle.fgcmPars.parsToArrays()
485  previousSuperStar = fgcmFitCycle.fgcmPars.parSuperStarFlat.copy()
486 
487  self.log.info("Raw repeatability after cycle number %d is:" % (cycleNumber))
488  for i, band in enumerate(fgcmFitCycle.fgcmPars.bands):
489  if not fgcmFitCycle.fgcmPars.hasExposuresInBand[i]:
490  continue
491  rep = fgcmFitCycle.fgcmPars.compReservedRawRepeatability[i] * 1000.0
492  self.log.info(" Band %s, repeatability: %.2f mmag" % (band, rep))
493 
494  # Check for convergence
495  if np.alltrue((previousReservedRawRepeatability
496  - fgcmFitCycle.fgcmPars.compReservedRawRepeatability)
497  < self.config.convergenceTolerance):
498  self.log.info("Raw repeatability has converged after cycle number %d." % (cycleNumber))
499  converged = True
500  else:
501  fgcmFitCycle.fgcmConfig.expGrayPhotometricCut[:] = fgcmFitCycle.updatedPhotometricCut
502  fgcmFitCycle.fgcmConfig.expGrayHighCut[:] = fgcmFitCycle.updatedHighCut
503  fgcmFitCycle.fgcmConfig.precomputeSuperStarInitialCycle = False
504  fgcmFitCycle.fgcmConfig.freezeStdAtmosphere = False
505  previousReservedRawRepeatability[:] = fgcmFitCycle.fgcmPars.compReservedRawRepeatability
506  self.log.info("Setting exposure gray photometricity cuts to:")
507  for i, band in enumerate(fgcmFitCycle.fgcmPars.bands):
508  if not fgcmFitCycle.fgcmPars.hasExposuresInBand[i]:
509  continue
510  cut = fgcmFitCycle.updatedPhotometricCut[i] * 1000.0
511  self.log.info(" Band %s, photometricity cut: %.2f mmag" % (band, cut))
512 
513  cycleNumber += 1
514 
515  # Log warning if not converged
516  if not converged:
517  self.log.warn("Maximum number of fit cycles exceeded (%d) without convergence." % (cycleNumber))
518 
519  # Do final clean-up iteration
520  fgcmFitCycle.fgcmConfig.freezeStdAtmosphere = False
521  fgcmFitCycle.fgcmConfig.resetParameters = False
522  fgcmFitCycle.fgcmConfig.maxIter = 0
523  fgcmFitCycle.fgcmConfig.outputZeropoints = True
524  fgcmFitCycle.fgcmConfig.outputStandards = True
525  fgcmFitCycle.fgcmConfig.doPlots = self.config.doDebuggingPlots
526  fgcmFitCycle.fgcmConfig.updateCycleNumber(cycleNumber)
527  fgcmFitCycle.initialCycle = False
528 
529  fgcmPars = fgcm.FgcmParameters.loadParsWithArrays(fgcmFitCycle.fgcmConfig,
530  fgcmExpInfo,
531  previousParInfo,
532  previousParams,
533  previousSuperStar)
534  fgcmFitCycle.fgcmStars.reloadStarMagnitudes(fgcmStarObservationCat['instMag'][obsIndex],
535  fgcmStarObservationCat['instMagErr'][obsIndex])
536  fgcmFitCycle.setPars(fgcmPars)
537  fgcmFitCycle.finishSetup()
538 
539  self.log.info("Running final clean-up fit cycle...")
540  fgcmFitCycle.run()
541 
542  self.log.info("Raw repeatability after clean-up cycle is:")
543  for i, band in enumerate(fgcmFitCycle.fgcmPars.bands):
544  if not fgcmFitCycle.fgcmPars.hasExposuresInBand[i]:
545  continue
546  rep = fgcmFitCycle.fgcmPars.compReservedRawRepeatability[i] * 1000.0
547  self.log.info(" Band %s, repeatability: %.2f mmag" % (band, rep))
548 
549  # Do the outputs. Need to keep track of tract.
550 
551  superStarChebSize = fgcmFitCycle.fgcmZpts.zpStruct['FGCM_FZPT_SSTAR_CHEB'].shape[1]
552  zptChebSize = fgcmFitCycle.fgcmZpts.zpStruct['FGCM_FZPT_CHEB'].shape[1]
553 
554  zptSchema = makeZptSchema(superStarChebSize, zptChebSize)
555  zptCat = makeZptCat(zptSchema, fgcmFitCycle.fgcmZpts.zpStruct)
556 
557  atmSchema = makeAtmSchema()
558  atmCat = makeAtmCat(atmSchema, fgcmFitCycle.fgcmZpts.atmStruct)
559 
560  stdStruct, goodBands = fgcmFitCycle.fgcmStars.retrieveStdStarCatalog(fgcmFitCycle.fgcmPars)
561  stdSchema = makeStdSchema(len(goodBands))
562  stdCat = makeStdCat(stdSchema, stdStruct, goodBands)
563 
564  outStruct = self.fgcmOutputProducts.generateTractOutputProducts(dataRefDict,
565  tract,
566  visitCat,
567  zptCat, atmCat, stdCat,
568  self.config.fgcmBuildStars,
569  returnCatalogs=returnCatalogs,
570  butler=butler)
571 
572  outStruct.repeatability = fgcmFitCycle.fgcmPars.compReservedRawRepeatability
573 
574  return outStruct
def run(self, dataRefDict, tract, buildStarsRefObjLoader=None, returnCatalogs=True, butler=None)
def extractReferenceMags(refStars, bands, filterMap)
Definition: utilities.py:874
def computeApertureRadiusFromDataRef(dataRef, fluxField)
Definition: utilities.py:799
def makeStdSchema(nBands)
Definition: utilities.py:729
def makeConfigDict(config, log, camera, maxIter, resetFitParameters, outputZeropoints, tract=None)
Definition: utilities.py:49
def makeAtmCat(atmSchema, atmStruct)
Definition: utilities.py:696
def translateFgcmLut(lutCat, physicalFilterMap)
Definition: utilities.py:208
def makeZptCat(zptSchema, zpStruct)
Definition: utilities.py:617
def makeStdCat(stdSchema, stdStruct, goodBands)
Definition: utilities.py:761
def makeZptSchema(superStarChebyshevSize, zptChebyshevSize)
Definition: utilities.py:531
def computeCcdOffsets(camera, defaultOrientation)
Definition: utilities.py:390
def translateVisitCatalog(visitCat)
Definition: utilities.py:339