def write(self, times, deferred_charges, outfile, clobber=True):
colnames = ['TIME']
columns = [times]
units = ['s']
for amp in deferred_charges[0]:
colnames.extend(['MEDIAN%02i' % amp, 'STDEV%02i' % amp])
columns.extend([
np.array(
[deferred_charges[i][amp][0] for i in range(len(times))]),
np.array(
[deferred_charges[i][amp][1] for i in range(len(times))])
])
units.extend(['e-/pixel', 'rms e-/pixel'])
formats = ['E'] * len(columns)
HDUList = fits.HDUList()
HDUList.append(fits.PrimaryHDU())
HDUList.append(
fitsTableFactory([
fits.Column(name=colname,
format=format,
unit=unit,
array=column)
for colname, format, unit, column in zip(
colnames, formats, units, columns)
]))
HDUList[-1].name = 'IMAGE_PERSISTENCE_CURVES'
HDUList[0].header['NAMPS'] = len(deferred_charges[0])
fitsWriteto(HDUList, outfile, clobber=clobber)
def _createFitsObject(self):
self.output = fits.HDUList()
self.output.append(fits.PrimaryHDU())
self.colnames = [
"AMP", "GAIN", "GAIN_ERROR", "READ_NOISE", "FULL_WELL",
"CTI_HIGH_SERIAL", "CTI_HIGH_PARALLEL", "CTI_LOW_SERIAL",
"CTI_LOW_PARALLEL", "DARK_CURRENT_95", "NUM_BRIGHT_PIXELS",
"NUM_TRAPS"
]
formats = "IEEEEEEEEEII"
my_types = dict((("I", np.int), ("E", np.float)))
columns = [
np.zeros(self.namps, dtype=my_types[fmt]) for fmt in formats
]
units = [
"None", "Ne/DN", "Ne/DN", "rms e-/pixel", "e-/pixel", "None",
"None", "None", "None", "e-/s/pixel", "None", "None"
]
fits_cols = [
fits.Column(name=self.colnames[i],
format=formats[i],
unit=units[i],
array=columns[i]) for i in range(len(self.colnames))
]
self.output.append(fitsTableFactory(fits_cols))
self.output[-1].name = self.extname
for amp in range(1, self.namps + 1):
self.add_seg_result(amp, 'AMP', amp)
def write(self, results, outfile, clobber=True):
colnames = ['WAVELENGTH', 'STDEV', 'MEAN']
formats = 'IEE'
my_types = dict((("I", np.int), ("E", np.float)))
columns = [np.zeros(len(results), dtype=my_types[fmt])
for fmt in formats]
units = ['nm', 'rms e-', 'e-']
hdu = fitsTableFactory([fits.Column(name=colnames[i],
format=formats[i],
unit=units[i],
array=columns[i])
for i in range(len(colnames))])
hdu.name = 'PRNU_RESULTS'
for i, wl in enumerate(results.keys()):
hdu.data.field('WAVELENGTH')[i] = wl
hdu.data.field('STDEV')[i] = results[wl][0]
hdu.data.field('MEAN')[i] =results[wl][1]
if os.path.isfile(outfile):
output = fits.open(outfile)
else:
output = fits.HDUList()
output.append(fits.PrimaryHDU())
try:
output[hdu.name] = hdu
except KeyError:
output.append(hdu)
fitsWriteto(output, outfile, clobber=clobber)
def write(self, outfile, overwrite=True):
"""
Write the results as a FITS binary table.
"""
nrows = sum([len(self[amp]) for amp in self])
output = fits.HDUList()
output.append(fits.PrimaryHDU())
colnames = ['AMPLIFIER', 'XPOS', 'YPOS', 'TRAP_SIZE', 'A0', 'A1']
formats = 'IIIIEE'
units = ['None', 'pixel', 'pixel', 'electrons', 'ADU', 'ADU']
columns = ([np.zeros(nrows, dtype=int)] * 4 +
[np.zeros(nrows, dtype=float)] * 2)
hdu = fitsTableFactory([
fits.Column(name=colname, format=format, unit=unit,
array=column) for colname, format, unit, column in zip(
colnames, formats, units, columns)
])
hdu.name = 'TRAPS'
output.append(hdu)
row = 0
for amp in self:
for xpos, ypos, trap_size, a0, a1 in self[amp]:
output['TRAPS'].data[row]['AMPLIFIER'] = amp
output['TRAPS'].data[row]['XPOS'] = xpos
output['TRAPS'].data[row]['YPOS'] = ypos
output['TRAPS'].data[row]['TRAP_SIZE'] = trap_size
output['TRAPS'].data[row]['A0'] = a0
output['TRAPS'].data[row]['A1'] = a1
row += 1
fitsWriteto(output, outfile, overwrite=overwrite)
def run(self,
sensor_id,
infiles,
mask_files,
gains,
binsize=1,
bias_frame=None):
outfile = os.path.join(self.config.output_dir,
'%s_ptc.fits' % sensor_id)
all_amps = imutils.allAmps(infiles[0])
ptc_stats = dict([(amp, ([], [])) for amp in all_amps])
exposure = []
file1s = sorted([item for item in infiles if item.find('flat1') != -1])
for flat1 in file1s:
flat2 = find_flat2(flat1)
if self.config.verbose:
self.log.info("processing %s" % flat1)
exposure.append(exptime(flat1))
ccd1 = MaskedCCD(flat1,
mask_files=mask_files,
bias_frame=bias_frame)
ccd2 = MaskedCCD(flat2,
mask_files=mask_files,
bias_frame=bias_frame)
for amp in ccd1:
results = flat_pair_stats(ccd1,
ccd2,
amp,
mask_files=mask_files,
bias_frame=bias_frame)
ptc_stats[amp][0].append(results.flat_mean)
ptc_stats[amp][1].append(results.flat_var)
self._fit_curves(ptc_stats, sensor_id)
output = fits.HDUList()
output.append(fits.PrimaryHDU())
colnames = ['EXPOSURE']
units = ['seconds']
columns = [np.array(exposure, dtype=np.float)]
for amp in all_amps:
colnames.extend(['AMP%02i_MEAN' % amp, 'AMP%02i_VAR' % amp])
units.extend(['ADU', 'ADU**2'])
columns.extend([
np.array(ptc_stats[amp][0], dtype=np.float),
np.array(ptc_stats[amp][1], dtype=np.float)
])
formats = 'E' * len(colnames)
fits_cols = [
fits.Column(name=colnames[i],
format=formats[i],
unit=units[i],
array=columns[i]) for i in range(len(columns))
]
output.append(fitsTableFactory(fits_cols))
output[-1].name = 'PTC_STATS'
output[0].header['NAMPS'] = len(all_amps)
fitsWriteto(output, outfile, clobber=True)
def write_fits_tables(self, outfile, clobber=True):
amps = self.qe.keys()
colnames = ['WAVELENGTH']
colnames.extend(['AMP%02i' % i for i in amps])
colnames.append('DEVICE_MEAN')
columns = [self.wlarrs[1]]
columns.extend([self.qe[i] for i in amps])
columns.append(self.ccd_qe)
formats = ["E"] * len(columns)
units = ["nm"]
units.extend(["e-/photon %"] * (len(columns) - 1))
fits_cols = lambda coldata: [
fits.Column(name=colname, format=format, unit=unit, array=column)
for colname, format, unit, column in coldata
]
HDUList = fits.HDUList()
HDUList.append(fits.PrimaryHDU())
HDUList.append(
fitsTableFactory(fits_cols(zip(colnames, formats, units,
columns))))
HDUList[-1].name = 'QE_CURVES'
columns = [self.ccd_qe_band.keys()]
columns.extend([np.array(self.qe_band[amp].values()) for amp in amps])
columns.append(np.array(self.ccd_qe_band.values()))
colnames[0] = 'BAND'
formats[0] = '2A'
units[0] = None
HDUList.append(
fitsTableFactory(fits_cols(zip(colnames, formats, units,
columns))))
HDUList[-1].name = 'QE_BANDS'
HDUList[0].header['NAMPS'] = len(amps)
fitsWriteto(HDUList, outfile, clobber=clobber)
def write_eotest_output(self, BFResults, sensor_id, meanidx=0):
"""Write the correlation curves to a FITS file for plotting,
and the BF results to the eotest results file."""
outfile = os.path.join(self.config.output_dir,
'%s_bf.fits' % sensor_id)
output = fits.HDUList()
output.append(fits.PrimaryHDU())
colnames = []
units = []
columns = []
for amp in BFResults:
colnames.extend(['AMP%02i_XCORR' % amp, 'AMP%02i_XCORR_ERR' % amp,
'AMP%02i_YCORR' % amp, 'AMP%02i_YCORR_ERR' % amp,
'AMP%02i_MEAN' % amp])
units.extend(
['Unitless', 'Unitless', 'Unitless', 'Unitless', 'ADU'])
columns.extend([np.array(BFResults[amp][0], dtype=np.float),
np.array(BFResults[amp][1], dtype=np.float),
np.array(BFResults[amp][2], dtype=np.float),
np.array(BFResults[amp][3], dtype=np.float),
np.array(BFResults[amp][4], dtype=np.float)])
formats = 'E'*len(colnames)
fits_cols = [fits.Column(name=colnames[i], format=formats[i],
unit=units[i], array=columns[i])
for i in range(len(columns))]
output.append(fitsTools.fitsTableFactory(fits_cols))
output[-1].name = 'BF_STATS'
output[0].header['NAMPS'] = len(BFResults)
fitsTools.fitsWriteto(output, outfile, clobber=True)
# Output a file of the coefficients at a given mean, given
# as the index of the exposure in the list.
results_file = self.config.eotest_results_file
if results_file is None:
results_file = os.path.join(self.config.output_dir,
'%s_eotest_results.fits' % sensor_id)
results = EOTestResults(results_file, namps=len(BFResults))
for amp in BFResults:
results.add_seg_result(amp, 'BF_XCORR', BFResults[amp][0][meanidx])
results.add_seg_result(amp, 'BF_XCORR_ERR', BFResults[amp][1][meanidx])
results.add_seg_result(amp, 'BF_YCORR', BFResults[amp][2][meanidx])
results.add_seg_result(amp, 'BF_YCORR_ERR', BFResults[amp][3][meanidx])
results.add_seg_result(amp, 'BF_MEAN', BFResults[amp][4][meanidx])
results.write(clobber=True)
def _create_detresp_fits_output(self, nrows, infile):
self.output = fits.HDUList()
self.output.append(fits.PrimaryHDU())
all_amps = imutils.allAmps(infile)
colnames = ['flux'] + ['AMP%02i_SIGNAL' % i for i in all_amps]
formats = 'E' * len(colnames)
units = ['None'] + ['e-'] * len(all_amps)
columns = [np.zeros(nrows, dtype=np.float) for fmt in formats]
fits_cols = [
fits.Column(name=colnames[i],
format=formats[i],
unit=units[i],
array=columns[i]) for i in range(len(units))
]
hdu = fitsTableFactory(fits_cols)
hdu.name = 'DETECTOR_RESPONSE'
self.output.append(hdu)
def append_column(self, colname, dtype=np.float, unit='None', column=None):
"""
Append a new column of amplifier data to the AMPLIFIER_RESULTS table.
"""
if colname in self.colnames:
return
_types = dict(((int, 'I'), (float, 'E'), (np.float64, 'E')))
if column is None:
column = np.zeros(self.namps, dtype=dtype)
new_cols = fits.ColDefs([
fits.Column(name=colname,
format=_types[dtype],
unit=unit,
array=column)
])
new_hdu = fitsTableFactory(self.output[self.extname].data.columns +
new_cols)
new_hdu.name = self.extname
self.output[self.extname] = new_hdu
self.colnames.append(colname)
def _write_read_noise_dists(outfile, Ntot, Nsys, gains, bias, sysnoise):
output = fits.HDUList()
output.append(fits.PrimaryHDU())
output[0].header['BIASFILE'] = bias
output[0].header['SYSNFILE'] = str(sysnoise)
for amp in Ntot:
sigtot, sigsys = Ntot[amp], Nsys[amp]
nread_col = fits.Column(name="TOTAL_NOISE",
format="E",
unit="e- rms",
array=sigtot)
nsys_col = fits.Column(name="SYSTEM_NOISE",
format="E",
unit="e- rms",
array=sigsys)
output.append(fitsTableFactory((nread_col, nsys_col)))
output[amp].name = "SEGMENT%s" % imutils.channelIds[amp]
output[0].header["GAIN%s" % imutils.channelIds[amp]] = gains[amp]
output[0].header["SIGTOT%s" % imutils.channelIds[amp]] = \
imutils.median(sigtot)
output[0].header["SIGSYS%s" % imutils.channelIds[amp]] = \
imutils.median(sigsys)
fitsWriteto(output, outfile, clobber=True)
def write_to_fits(self, fits_file):
"""Write this object to a FITS file"""
output = fits.HDUList()
output.append(fits.PrimaryHDU())
col_prof_x = fits.Column(name='prof_x',
format='%iE' % self._nxbins,
unit='ADU',
array=self._prof_x)
col_prof_y = fits.Column(name='prof_y_corr',
format='%iE' % self._nxbins,
unit='ADU',
array=self._prof_y)
col_prof_yerr = fits.Column(name='prof_yerr',
format='%iE' % self._nxbins,
unit='ADU',
array=self._prof_yerr)
fits_cols = [col_prof_x, col_prof_y, col_prof_yerr]
hdu = fitsTableFactory(fits_cols)
hdu.name = 'nonlin'
output.append(hdu)
fitsWriteto(output, fits_file, overwrite=True)
def _save_ext_data(self, amp, x0, y0, sigmax, sigmay, dn, dn_fp, chiprob,
chi2s, dofs, maxDNs, xpeak, ypeak, p9_data, p9_model,
prect_data):
"""
Write results from the source detection and Gaussian fitting
to the FITS extension corresponding to the specified
amplifier.
"""
extname = 'Amp%02i' % amp
try:
#
# Append new rows if HDU for this segment already exists.
#
table_hdu = self.output[extname]
row0 = table_hdu.header['NAXIS2']
nrows = row0 + len(x0)
table_hdu = fitsTableFactory(table_hdu.data, nrows=nrows)
for i in range(len(x0)):
row = i + row0
table_hdu.data[row]['AMPLIFIER'] = amp
table_hdu.data[row]['XPOS'] = x0[i]
table_hdu.data[row]['YPOS'] = y0[i]
table_hdu.data[row]['SIGMAX'] = sigmax[i]
table_hdu.data[row]['SIGMAY'] = sigmay[i]
table_hdu.data[row]['DN'] = dn[i]
table_hdu.data[row]['DN_FP_SUM'] = dn_fp[i]
table_hdu.data[row]['CHIPROB'] = chiprob[i]
table_hdu.data[row]['CHI2'] = chi2s[i]
table_hdu.data[row]['DOF'] = dofs[i]
table_hdu.data[row]['MAXDN'] = maxDNs[i]
table_hdu.data[row]['XPEAK'] = xpeak[i]
table_hdu.data[row]['YPEAK'] = ypeak[i]
table_hdu.data[row]['P9_DATA'] = p9_data[i]
table_hdu.data[row]['P9_MODEL'] = p9_model[i]
table_hdu.data[row]['PRECT_DATA'] = prect_data[i]
table_hdu.name = extname
self.output[extname] = table_hdu
except KeyError:
#
# Extension for this segment does not yet exist, so add it.
#
colnames = [
'AMPLIFIER', 'XPOS', 'YPOS', 'SIGMAX', 'SIGMAY', 'DN',
'DN_FP_SUM', 'CHIPROB', 'CHI2', 'DOF', 'MAXDN', 'XPEAK',
'YPEAK', 'P9_DATA', 'P9_MODEL', 'PRECT_DATA'
]
columns = [
np.ones(len(x0)) * amp,
np.array(x0),
np.array(y0),
np.array(sigmax),
np.array(sigmay),
np.array(dn),
np.array(dn_fp),
np.array(chiprob),
np.array(chi2s),
np.array(dofs),
np.array(maxDNs),
np.array(xpeak),
np.array(ypeak),
np.array(p9_data),
np.array(p9_model),
np.array(prect_data)
]
formats = [
'I'
] + ['E'] * (len(columns) - 6) + ['I'] * 2 + ['9E'] * 2 + ['175E']
units = [
'None', 'pixel', 'pixel', 'pixel', 'pixel', 'ADU', 'ADU',
'None', 'None', 'None', 'ADU', 'pixel', 'pixel', 'ADU', 'ADU',
'ADU'
]
fits_cols = lambda coldata: [
fits.Column(
name=colname, format=format, unit=unit, array=column)
for colname, format, unit, column in coldata
]
self.output.append(
fitsTableFactory(
fits_cols(zip(colnames, formats, units, columns))))
self.output[-1].name = extname
def write_results(self, outfile):
"""Export results as a FITs file."""
for amp in range(1, 17):
extname = 'Amp{0:02d}'.format(amp)
nrows1 = len(self.flux[amp])
ncols = len(self.meanrow[amp][0])
meanrow_col = fits.Column('MEANROW',
format='{0}E'.format(ncols),
unit='e-',
array=self.meanrow[amp])
flux_col = fits.Column('FLUX',
format='E',
unit='e-',
array=self.flux[amp])
flux_std_col = fits.Column('FLUX_STD',
format='E',
unit='e-',
array=self.flux_std[amp])
noise_col = fits.Column('NOISE',
format='E',
unit='e-',
array=self.noise[amp])
signal_col = fits.Column('SIGNAL',
format='E',
unit='e-',
array=self.signal[amp])
signal_std_col = fits.Column('SIGNAL_STD',
format='E',
unit='e-',
array=self.signal_std[amp])
tau_col = fits.Column('TAU',
format='E',
unit='None',
array=self.tau[amp])
tau_std_col = fits.Column('TAU_STD',
format='E',
unit='None',
array=self.tau_std[amp])
cti_col = fits.Column('CTI',
format='E',
unit='None',
array=self.cti[amp])
cti_std_col = fits.Column('CTI_STD',
format='E',
unit='None',
array=self.cti_std[amp])
try:
#
# Append new rows if HDU for this segment already exists
#
table_hdu = self.output[extname]
row0 = table_hdu.header['NAXIS2']
nrows = row0 + nrows1
table_hdu = fitsTableFactory(table_hdu.data, nrows=nrows)
table_hdu.data['MEANROW'][row0:] = meanrow_col
table_hdu.data['FLUX'][row0:] = flux_col
table_hdu.data['FLUX_STD'][row0:] = flux_std_col
table_hdu.data['NOISE'][row0:] = noise_col
table_hdu.data['SIGNAL'][row0:] = signal_col
table_hdu.data['SIGNAL_STD'][row0:] = signal_std_col
table_hdu.data['TAU'][row0:] = tau_col
table_hdu.data['TAU_STD'][row0:] = tau_std_col
table_hdu.data['CTI'][row0:] = cti_col
table_hdu.data['CTI_STD'][row0:] = cti_std_col
table_hdu.name = extname
self.output[extname] = table_hdu
except KeyError:
self.output.append(
fitsTableFactory([
meanrow_col, flux_col, flux_std_col, noise_col,
signal_col, signal_std_col, tau_col, tau_std_col,
cti_col, cti_std_col
]))
self.output[-1].name = extname
self.output[0].header['NAMPS'] = 16
fitsWriteto(self.output, outfile, overwrite=True, checksum=True)
