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)