kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
#config_table = get_run_config_table(kwargs.get('config_table', 'seq_list.fits'), 'seq')
config_table = get_run_config_table(kwargs.get('config_table', 'nbias_full_bot.fits'), 'nbias')
sumtable = dtables['stats']
if self.config.teststand == 'ts8':
runtable = dtables['runs']
yvals = sumtable['mean'].flatten().clip(0., 30.)
yerrs = sumtable['std'].flatten().clip(0., 10.)
runs = runtable['runs']
figs.plot_run_chart("stats", runs, yvals, yerrs=yerrs, ylabel="Superbias STD [ADU]")
elif self.config.teststand == 'bot':
rafts = np.unique(sumtable['raft'].flatten())
for raft in rafts:
mask = sumtable['raft'].flatten() == raft
subtable = sumtable[mask]
figs.plot_run_chart_by_slot("stats_%s" % raft, subtable,
"mean", #yerrs="std",
ylabel="Superbias STD [ADU]",
ymin=0., ymax=10.,
raft='nbias',
config_table=config_table)
EO_TASK_FACTORY.add_task_class('SuperbiasStats', SuperbiasStatsTask)
EO_TASK_FACTORY.add_task_class('SuperbiasSummary', SuperbiasSummaryTask)
from lsst.eo_utils.dark import SuperdarkTask
from lsst.eo_utils.sflat import SuperflatTask
class CalibStackConfig(MetaConfig):
"""Configuration for CalibStackTask"""
dataset = EOUtilOptions.clone_param('dataset')
runs = EOUtilOptions.clone_param('runs')
rafts = EOUtilOptions.clone_param('rafts')
slots = EOUtilOptions.clone_param('slots')
outdir = EOUtilOptions.clone_param('outdir')
skip = EOUtilOptions.clone_param('skip')
plot = EOUtilOptions.clone_param('plot')
stats_hist = EOUtilOptions.clone_param('stats_hist')
CalibStackConfig.add_task('_Superbias', SuperbiasTask)
CalibStackConfig.add_task('_Superdark', SuperdarkTask)
CalibStackConfig.add_task('_Superflat', SuperflatTask)
class CalibStackTask(MetaTask):
"""Construct Superbias Superdark and Superflat frames"""
ConfigClass = CalibStackConfig
_DefaultName = "CalibStack"
EO_TASK_FACTORY.add_task_class('CalibStack', CalibStackTask)
axes_nonlin_stack.legend()
def plot(self, dtables, figs, **kwargs):
"""Plot the summary data
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
tab_flatlin = dtables['flat_lin']
flux_1 = tab_flatlin['flux_1']
flux_2 = tab_flatlin['flux_2']
flux = np.hstack([flux_1, flux_2])
slit_widths = tab_flatlin['monoch_slit_b']
slit_widths = np.hstack([slit_widths, slit_widths])
self._plot_nonlinearity(flux, slit_widths, dtables, figs)
self._plot_nonlinearity(flux, slit_widths, dtables, figs, inverse=True)
EO_TASK_FACTORY.add_task_class('Nonlinearity', NonlinearityTask)
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
# Analysis goes here.
# you should use the data in dtables to make a bunch of figures in figs
fp_table = dtables['footprints']
figs.setup_amp_plots_grid(
'median',
title="Median signal at dust spot by amp median",
xlabel="amp flux",
ylabel="dust flux")
for iax, axes in enumerate(figs['dust_linearity']['axs'].ravel()):
axes.scatter(fp_table[fp_table['amp'] == iax]['amp_median'],
fp_table[fp_table['amp'] == iax]['med_flux_full'])
EO_TASK_FACTORY.add_task_class('DustLinearityAnalysis',
DustLinearityAnalysisTask)
continue
self._mask_file_dict[slot] = self.get_mask_files(slot=slot)
self._sflat_file_dict_l[slot] = basename.replace(
'.fits', '_l.fits')
self._sflat_file_dict_h[slot] = basename.replace(
'.fits', '_h.fits')
self._sflat_file_dict_r[slot] = basename.replace(
'.fits', '_r.fits')
class SuperflatMosaicConfig(CameraMosaicConfig):
"""Configuration for SuperbiasMosaicTask"""
class SuperflatMosaicTask(CameraMosaicTask):
"""Make a mosaic from a superbias frames"""
ConfigClass = SuperflatMosaicConfig
_DefaultName = "SuperflatMosaicTask"
intablename_format = SUPERFLAT_SPEC_FORMATTER
tablename_format = RUN_SUPERFLAT_FORMATTER
plotname_format = RUN_SUPERFLAT_FORMATTER
datatype = 'superflat'
EO_TASK_FACTORY.add_task_class('Superflat', SuperflatTask)
EO_TASK_FACTORY.add_task_class('SuperflatRaft', SuperflatRaftTask)
EO_TASK_FACTORY.add_task_class('SuperflatMosaic', SuperflatMosaicTask)
def main():
"""Hook for setup.py"""
EO_TASK_FACTORY.parse_and_run()
self.safe_update(**kwargs)
stat_type = self.config.stat
if stat_type in [None, DEFAULT_STAT_TYPE]:
formatter = SUPERDARK_FORMATTER
else:
formatter = SUPERDARK_STAT_FORMATTER
return self.get_filename_from_format(formatter, '', **kwargs)
def __call__(self, butler, slot_data, **kwargs):
"""Tie together analysis functions
Parameters
----------
butler : `Butler`
The data butler
data : `dict`
Dictionary (or other structure) contain the input data
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
self.make_superdark(butler, slot_data)
if self.config.plot is not None:
if self._superdark_frame is None:
self.log_info_slot_msg(self.config, "No superdark, skipping")
return
self.make_plots(None)
EO_TASK_FACTORY.add_task_class('SuperdarkStability', SuperdarkStabilityTask)
ymax=4.)
def plot(self, dtables, figs, **kwargs):
"""Plot the summary data
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
if self.config.teststand == 'ts8':
self.plot_ts8(dtables, figs, **kwargs)
elif self.config.teststand == 'bot':
sumtable = dtables['eo_results_sum']
rafts = np.unique(sumtable['raft'])
for raft in rafts:
mask = sumtable['raft'] == raft
subtable = sumtable[mask]
self.plot_by_raft(raft, subtable, figs, **kwargs)
EO_TASK_FACTORY.add_task_class('EOResultsRaft', EOResultsRaftTask)
EO_TASK_FACTORY.add_task_class('EOResultsRun', EOResultsRunTask)
EO_TASK_FACTORY.add_task_class('EOResultsSummary', EOResultsSummaryTask)
qe_curves_data_dict = qe_data.make_qe_curves_data_dict()
bands_data_dict = qe_data.make_bands_data_dict()
dtables = TableDict()
dtables.make_datatable('qe_curves', qe_curves_data_dict)
dtables.make_datatable('bands', bands_data_dict)
return dtables
def plot(self, dtables, figs, **kwargs):
"""Make plots
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
# Analysis goes here.
# you should use the data in dtables to make a bunch of figures in figs
EO_TASK_FACTORY.add_task_class('QE', QETask)
if superbias is None:
return None
self.log_info_slot_msg(self.config, "")
biasstruct_data = {}
dim_array_dict = get_dimension_arrays_from_ccd(superbias)
for key, val in dim_array_dict.items():
biasstruct_data[key] = {key: val}
self.get_ccd_data(superbias,
biasstruct_data,
slot=slot,
bias_type=None,
std=self.config.std,
superbias_frame=None)
self.log_progress("Done!")
dtables = TableDict()
dtables.make_datatable('files', make_file_dict(None, [slot]))
for key, val in biasstruct_data.items():
dtables.make_datatable('biasst-%s' % key, val)
return dtables
EO_TASK_FACTORY.add_task_class('BiasStruct', BiasStructTask)
EO_TASK_FACTORY.add_task_class('SuperbiasStruct', SuperbiasStructTask)
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
sumtable = dtables['biasoscorr_sum']
runtable = dtables['runs']
yvals_s = sumtable['s_correl_mean'].flatten().clip(0., 1.)
yvals_p = sumtable['p_correl_mean'].flatten().clip(0., 1.)
runs = runtable['runs']
figs.plot_run_chart(
"mean-s",
runs,
yvals_s,
ylabel="Correlation between serial overscan and imaging")
figs.plot_run_chart(
"mean-p",
runs,
yvals_p,
ylabel="Correlation between parallel overscan and imaging")
EO_TASK_FACTORY.add_task_class('CorrelWRTOscan', CorrelWRTOscanTask)
EO_TASK_FACTORY.add_task_class('CorrelWRTOscanStats', CorrelWRTOscanStatsTask)
EO_TASK_FACTORY.add_task_class('CorrelWRTOscanSummary',
CorrelWRTOscanSummaryTask)
value = self.median(image)
data_dict['AMP%02i_MEDIAN' % (i + 1)].append(value)
self.log_progress("Done!")
dtables = TableDict()
dtables.make_datatable('files', make_file_dict(butler, qe_files))
dtables.make_datatable('qe_med', data_dict)
return dtables
def plot(self, dtables, figs, **kwargs):
"""Make plots
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
# Analysis goes here.
# you should use the data in dtables to make a bunch of figures in figs
EO_TASK_FACTORY.add_task_class('QEMedian', QEMedianTask)
data_dict['CTI_LOW_PARALLEL_ERROR'].append(pcti_l[amp].error)
data_dict['CTI_HIGH_PARALLEL'].append(pcti_h[amp].value)
data_dict['CTI_HIGH_PARALLEL_ERROR'].append(pcti_h[amp].error)
self.log_progress("Done!")
dtables = TableDict()
dtables.make_datatable('cte', data_dict)
return dtables
def plot(self, dtables, figs, **kwargs):
"""Make plots
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
# Analysis goes here.
# you should use the data in dtables to make a bunch of figures in figs
EO_TASK_FACTORY.add_task_class('CTE', CTETask)
def plot(self, dtables, figs, **kwargs):
"""Plot the summary data from the PTC analyses
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
sumtable = dtables['ptc_sum']
runtable = dtables['runs']
yvals = sumtable['gain'].flatten().clip(0., 2.)
yerrs = sumtable['gain_error'].flatten().clip(0., 0.5)
runs = runtable['runs']
figs.plot_run_chart("ptc-gain",
runs,
yvals,
yerrs=yerrs,
ylabel="Gain")
EO_TASK_FACTORY.add_task_class('PTC', PTCTask)
EO_TASK_FACTORY.add_task_class('PTCStats', PTCStatsTask)
EO_TASK_FACTORY.add_task_class('PTCSummary', PTCSummaryTask)
class SlotAnalysisConfig(MetaConfig):
"""Configuration for SlotAnalysisTask"""
dataset = EOUtilOptions.clone_param('dataset')
runs = EOUtilOptions.clone_param('runs')
teststand = EOUtilOptions.clone_param('teststand')
overwrite = EOUtilOptions.clone_param('overwrite')
rafts = EOUtilOptions.clone_param('rafts')
slots = EOUtilOptions.clone_param('slots')
skip = EOUtilOptions.clone_param('skip')
plot = EOUtilOptions.clone_param('plot')
SlotAnalysisConfig.add_task('_BiasFFT', BiasFFTTask)
SlotAnalysisConfig.add_task('_BiasStruct', BiasStructTask)
SlotAnalysisConfig.add_task('_BiasVRow', BiasVRowTask)
SlotAnalysisConfig.add_task('_CorrelWRTOscan', CorrelWRTOscanTask)
SlotAnalysisConfig.add_task('_OscanAmpStack', OscanAmpStackTask)
SlotAnalysisConfig.add_task('_FlatOverscan', FlatOverscanTask)
SlotAnalysisConfig.add_task('_BF', BFTask)
SlotAnalysisConfig.add_task('_FlatPair', FlatPairTask)
SlotAnalysisConfig.add_task('_QEMedian', QEMedianTask)
class SlotAnalysisTask(MetaTask):
"""Chain together all the slot-based image analyses"""
ConfigClass = SlotAnalysisConfig
_DefaultName = "SlotAnalysis"
EO_TASK_FACTORY.add_task_class('SlotAnalysis', SlotAnalysisTask)
class SummaryAnalysisConfig(MetaConfig):
"""Configuration for SummaryAnalysisTask"""
dataset = EOUtilOptions.clone_param('dataset')
runs = EOUtilOptions.clone_param('runs')
plot = EOUtilOptions.clone_param('plot')
skip = EOUtilOptions.clone_param('skip')
SummaryAnalysisConfig.add_task('_BiasFFTSummary', BiasFFTSummaryTask)
SummaryAnalysisConfig.add_task('_OscanAmpStackSummary',
OscanAmpStackSummaryTask)
SummaryAnalysisConfig.add_task('_SuperbiasSummary', SuperbiasSummaryTask)
SummaryAnalysisConfig.add_task('_DarkCurrentSummary', DarkCurrentSummaryTask)
SummaryAnalysisConfig.add_task('_Fe55GainSummary', Fe55GainSummaryTask)
SummaryAnalysisConfig.add_task('_PTCSummary', PTCSummaryTask)
SummaryAnalysisConfig.add_task('_EOResultsSummary', EOResultsSummaryTask)
SummaryAnalysisConfig.add_task('_CorrelWRTOscanSummary',
CorrelWRTOscanSummaryTask)
class SummaryAnalysisTask(MetaTask):
"""Chain together all the summary-level analyses"""
ConfigClass = SummaryAnalysisConfig
_DefaultName = "SummaryAnalysis"
EO_TASK_FACTORY.add_task_class('SummaryAnalysis', SummaryAnalysisTask)
xlabel='Flux [e-]',
ylabel='Overscan Noise [e-]')
axs = f_dict['axes']
for i, amp in enumerate(range(1, 17)):
if i >= 10:
marker = 's'
else:
marker = '^'
data = dtables['amp{0:02d}'.format(amp)]
sorted_indices = np.argsort(data['FLUX'])
noise = data['NOISE'][sorted_indices]
flux = data['FLUX'][sorted_indices]
axs.semilogx(flux[flux <= self.maxflux],
noise[flux <= self.maxflux],
label="Amp {0}".format(i + 1),
marker=marker)
axs.set_ylim(0.0, 10.0)
axs.grid(True, which='major', axis='both')
leg_h, leg_l = axs.get_legend_handles_labels()
axs.legend(leg_h, leg_l, loc='lower right', ncol=4, fontsize=12)
EO_TASK_FACTORY.add_task_class('FlatOverscan', FlatOverscanTask)
tablename_format = RUN_SUPERDARK_FORMATTER
plotname_format = RUN_SUPERDARK_FORMATTER
datatype = 'superdark'
class SuperdarkStatMosaicConfig(CameraMosaicConfig):
"""Configuration for SuperdarkMosaicTask"""
stat = EOUtilOptions.clone_param('stat', default='stdevclip')
class SuperdarkStatMosaicTask(CameraMosaicTask):
"""Make a mosaic from a superbias frames"""
ConfigClass = SuperdarkStatMosaicConfig
_DefaultName = "SuperdarkMosaicTask"
intablename_format = SUPERDARK_STAT_FORMATTER
tablename_format = RUN_SUPERDARK_STAT_FORMATTER
plotname_format = RUN_SUPERDARK_STAT_FORMATTER
datatype = 'superdark'
EO_TASK_FACTORY.add_task_class('Superdark', SuperdarkTask)
EO_TASK_FACTORY.add_task_class('SuperdarkRaft', SuperdarkRaftTask)
EO_TASK_FACTORY.add_task_class('SuperdarkOutlierSummary',
SuperdarkOutlierSummaryTask)
EO_TASK_FACTORY.add_task_class('SuperdarkMosaic', SuperdarkMosaicTask)
EO_TASK_FACTORY.add_task_class('SuperdarkStatMosaic', SuperdarkStatMosaicTask)
sys.stdout.flush()
dtables = TableDict()
dtables.make_datatable('files', make_file_dict(butler, qe_files))
#dtables.make_datatable('dust_color', data_dict)
dtables.make_datatable('dust_color_hack', data_dict)
return dtables
def plot(self, dtables, figs, **kwargs):
"""Make plots
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
# Analysis goes here.
# you should use the data in dtables to make a bunch of figures in figs
EO_TASK_FACTORY.add_task_class('DustColor', DustColorTask)
Used to override default configuration
"""
self.safe_update(**kwargs)
sumtable = dtables['stats']
runtable = dtables['runs']
config_table = get_run_config_table(kwargs.get('config_table', 'dark_config.fits'), 'config')
if self.config.teststand == 'ts8':
yvals = sumtable['current']
yerrs = (sumtable['stdev'] / sumtable['exptime']).clip(0., 0.05)
runs = runtable['runs']
figs.plot_run_chart("val", runs, yvals, yerrs=yerrs, ylabel="Dark Current [ADU/s]")
elif self.config.teststand == 'bot':
rafts = np.unique(sumtable['raft'])
#nrun = sumtable['irun'].max() + 1
runs = np.unique(sumtable['run'])
for raft in rafts:
mask = sumtable['raft'] == raft
subtable = sumtable[mask]
figs.plot_run_chart_by_slot("val_%s" % raft, subtable,
"current", #yerrs="std",
ylabel="Dark Current [ADU/s]",
ymin=0., ymax=0.05,
raft='config',
config_table=config_table)
EO_TASK_FACTORY.add_task_class('DarkCurrent', DarkCurrentTask)
EO_TASK_FACTORY.add_task_class('DarkCurrentSummary', DarkCurrentSummaryTask)
norm_frac_resid -= np.median(norm_frac_resid)
figs.plot_hist('delta-hist', amp-1, norm_delta[20:-20], xmin=-10, xmax=10., nbins=100)
figs.plot('delta', amp-1, xvals, norm_delta)
figs.plot('mean-ref', amp-1, xvals, norm_frac_resid)
figs.plot('mean', amp-1, xvals, frac_resid)
figs.plot('std', amp-1, xvals, std_delta)
rows = ((tab_stab['AMP%02i_FLAT_ROWMEAN' % amp].T - refs) / flux).T
cols = ((tab_stab['AMP%02i_FLAT_COLMEAN' % amp].T - refs) / flux).T
axes_scat = figs.get_amp_axes('delta-v-std', amp-1)
axes_scat.set_xlim(-5., 5.)
axes_scat.set_ylim(-0.005, 0.005)
axes_scat.scatter(norm_delta, std_delta)
#nrow = len(rows[0])
#xrow = np.linspace(0, nrow-1, nrow)
#ncol = len(cols[0])
#xcol = np.linspace(0, ncol-1, ncol)
med_row = np.median(rows, axis=0)
med_col = np.median(cols, axis=0)
figs.plot_2d_color("row", amp-1, rows-med_row,
origin='low', interpolation='none')
figs.plot_2d_color("col", amp-1, cols-med_col,
origin='low', interpolation='none')
EO_TASK_FACTORY.add_task_class('Stability', StabilityTask)
data_dict['full_well'].append(full_well_data[0])
data_dict['max_dev'].append(linearity_data[0])
self.log_progress("Done!")
outtables = TableDict()
outtables.make_datatable("flat_lin", data_dict)
return outtables
def plot(self, dtables, figs, **kwargs):
"""Plot the summary data
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
# Analysis goes here.
# you should use the data in dtables to make a bunch of figures in figs
EO_TASK_FACTORY.add_task_class('FlatLinearity', FlatLinearityTask)
primary_hdu = fits.PrimaryHDU()
primary_hdu.header['NAMPS'] = 16
dtables = TableDict(primary=primary_hdu)
dtables.make_datatable('files', make_file_dict(butler, flat1_files + flat2_files))
dtables.make_datatable('flat', data_dict)
return dtables
def plot(self, dtables, figs, **kwargs):
"""Make plots
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
# Analysis goes here.
# you should use the data in dtables to make a bunch of figures in figs
EO_TASK_FACTORY.add_task_class('FlatPair', FlatPairTask)
data_dict = my_traps.make_data_dict()
self.log_progress("Done!")
dtables = TableDict()
dtables.make_datatable('files', make_file_dict(butler, ppump_files))
dtables.make_datatable('traps', data_dict)
return dtables
def plot(self, dtables, figs, **kwargs):
"""Make plots
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
# Analysis goes here.
# you should use the data in dtables to make a bunch of figures in figs
EO_TASK_FACTORY.add_task_class('Trap', TrapTask)
yvals_p_min_mean = sumtable['p_col_min_mean']
yvals_p_min_std = sumtable['p_col_min_std']
yvals_p_max_mean = sumtable['p_col_max_mean']
yvals_p_max_std = sumtable['p_col_max_std']
runs = runtable['runs']
yvals_s_diff = (yvals_s_max_mean - yvals_s_min_mean).clip(0, 100)
yvals_s_err = np.sqrt(yvals_s_min_std**2 + yvals_s_max_std**2).clip(
0, 10)
yvals_p_diff = (yvals_p_max_mean - yvals_p_min_mean).clip(0, 100)
yvals_p_err = np.sqrt(yvals_p_min_std**2 + yvals_p_max_std**2).clip(
0, 10)
figs.plot_run_chart("s-row",
runs,
yvals_s_diff,
yerrs=yvals_s_err,
ylabel="Amplitude of Row-wise amp stack [ADU]")
figs.plot_run_chart("p-col",
runs,
yvals_p_diff,
yerrs=yvals_p_err,
ylabel="Amplitude of Col-wise amp stack [ADU]")
EO_TASK_FACTORY.add_task_class('OscanAmpStack', OscanAmpStackTask)
EO_TASK_FACTORY.add_task_class('OscanAmpStackStats', OscanAmpStackStatsTask)
EO_TASK_FACTORY.add_task_class('OscanAmpStackSummary',
OscanAmpStackSummaryTask)
class RaftAnalysisConfig(MetaConfig):
"""Configuration for RaftAnalysisTask"""
dataset = EOUtilOptions.clone_param('dataset')
runs = EOUtilOptions.clone_param('runs')
rafts = EOUtilOptions.clone_param('rafts')
skip = EOUtilOptions.clone_param('skip')
plot = EOUtilOptions.clone_param('plot')
RaftAnalysisConfig.add_task('_OscanCorrel', OscanCorrelTask)
RaftAnalysisConfig.add_task('_SuperbiasStats', SuperbiasStatsTask)
RaftAnalysisConfig.add_task('_OscanAmpStackStats', OscanAmpStackStatsTask)
RaftAnalysisConfig.add_task('_BiasFFTStats', BiasFFTStatsTask)
RaftAnalysisConfig.add_task('_DarkCurrent', DarkCurrentTask)
RaftAnalysisConfig.add_task('_Fe55GainStats', Fe55GainStatsTask)
RaftAnalysisConfig.add_task('_FlatLinearity', FlatLinearityTask)
RaftAnalysisConfig.add_task('_PTC', PTCTask)
RaftAnalysisConfig.add_task('_CorrelWRTOscanStats', CorrelWRTOscanStatsTask)
RaftAnalysisConfig.add_task('_EOResultsRaft', EOResultsRaftTask)
class RaftAnalysisTask(MetaTask):
"""Chain together all the raft-based analyses"""
ConfigClass = RaftAnalysisConfig
_DefaultName = "RaftAnalysis"
EO_TASK_FACTORY.add_task_class('RaftAnalysis', RaftAnalysisTask)
# data_dict
data_dict['slot'].append(islot)
data_dict['amp'].append(amp)
self.log_progress("Done!")
outtables = TableDict()
outtables.make_datatable("tmplsuffix", data_dict)
return outtables
def plot(self, dtables, figs, **kwargs):
"""Plot the summary data
Parameters
----------
dtables : `TableDict`
The data produced by this task
figs : `FigureDict`
The resulting figures
kwargs
Used to override default configuration
"""
self.safe_update(**kwargs)
# Analysis goes here.
# you should use the data in dtables to make a bunch of figures in figs
EO_TASK_FACTORY.add_task_class('Template', TemplateTask)
superbias_frame : `MaskedCCD`
The superbias frame to subtract away
boundry : `int`
Size of buffer around edge of overscan region
Returns
-------
overscans : `list`
The overscan data
"""
amps = get_amp_list(ccd)
superbias_frame = kwargs.get('superbias_frame', None)
overscans = []
for amp in amps:
superbias_im = self.get_superbias_amp_image(butler, superbias_frame, amp)
regions = get_geom_regions(ccd, amp)
serial_oscan = regions['serial_overscan']
img = get_raw_image(ccd, amp)
image = unbias_amp(img, serial_oscan, bias_type=None, superbias_im=superbias_im).image
oscan_copy = copy.deepcopy(serial_oscan)
oscan_copy.grow(-self.boundry)
oscan_data = image[oscan_copy]
step_x = regions['step_x']
step_y = regions['step_y']
overscans.append(oscan_data.getArray()[::step_x, ::step_y])
return overscans
EO_TASK_FACTORY.add_task_class('OscanCorrel', OscanCorrelTask)