def write_fits(self, filename, hdr=None, primhdr=None): tt = type(self) sky_type = '%s.%s' % (tt.__module__, tt.__name__) if hdr is None: import fitsio hdr = fitsio.FITSHDR() if primhdr is None: import fitsio primhdr = fitsio.FITSHDR() hdr.add_record(dict(name='SKY', value=sky_type, comment='Sky class')) primhdr.add_record( dict(name='SKY', value=sky_type, comment='Sky class')) #hdr.add_record(dict(name='SPL_ORD', value=self.order, # comment='Spline sky order')) # this writes all params as header cards #self.toFitsHeader(hdr, prefix='SKY_') #fits = fitsio.FITS(filename, 'rw') #fits.write(None, header=primhdr, clobber=True) #fits.write(self.c, header=hdr) #fits.close() from astrometry.util.fits import fits_table T = fits_table() T.xgrid = np.atleast_2d(self.xgrid).astype(np.int32) T.ygrid = np.atleast_2d(self.ygrid).astype(np.int32) T.x0 = np.atleast_1d(self.x0).astype(np.int32) T.y0 = np.atleast_1d(self.y0).astype(np.int32) gridvals = self.spl(self.xgrid, self.ygrid).T T.gridvals = np.array([gridvals]).astype(np.float32) T.order = np.atleast_1d(self.order).astype(np.uint8) assert (len(T) == 1) T.writeto(filename, header=hdr, primheader=primhdr)
def writeImageFile(self, im, filepath, visit, addCards=None, comment=None, cmd=None): """ Actually write the FITS file. Args ---- im : `numpy.ndarray` The image. filepath : `str` or `pathlib.Path` The full pathname of the file to write. visit : `int` The PFS visit number addCards : sequence of fitsio card dicts FITS cards to add. comment : `str` A comment to put at the start of the headeer. cmd : `actorcore.Command` Where to dribble info Returns ------- filepath : `str` the input filepath The file is saved with RICE compression. """ self.logger.info('creating fits file: %s', filepath) cmd.debug('text="creating fits file %s' % (filepath)) cards = [] if comment is not None: cards.append(dict(name='comment', value=comment)) if addCards is not None: cards.extend(addCards) cards.extend(self.headerCards) try: hdr = fitsio.FITSHDR(cards) fitsFile = fitsio.FITS(str(filepath), 'rw') fitsFile.write(None, header=hdr) fitsFile[-1].write_checksum() imHdr = fitsio.FITSHDR(self.getImageCards(cmd)) fitsFile.write(im, extname="image", header=imHdr, compress='RICE') fitsFile[-1].write_checksum() fitsFile.close() except Exception as e: cmd.warn('text="failed to write fits file %s: %s"' % (filepath, e)) self.logger.warn('failed to write fits file %s: %s', filepath, e) self.logger.warn('hdr : %s', hdr) return filepath
def getFitsHeader(self, header=None, prefix=''): psf = self.getPsf() wcs = self.getWcs() sky = self.getSky() pcal = self.getPhotoCal() if header is None: import fitsio hdr = fitsio.FITSHDR() else: hdr = header tt = type(psf) psf_type = '%s.%s' % (tt.__module__, tt.__name__) tt = type(wcs) wcs_type = '%s.%s' % (tt.__module__, tt.__name__) tt = type(sky) sky_type = '%s.%s' % (tt.__module__, tt.__name__) tt = type(pcal) pcal_type = '%s.%s' % (tt.__module__, tt.__name__) hdr.add_record( dict(name=prefix + 'PSF', value=psf_type, comment='PSF class')) hdr.add_record( dict(name=prefix + 'WCS', value=wcs_type, comment='WCS class')) hdr.add_record( dict(name=prefix + 'SKY', value=sky_type, comment='Sky class')) hdr.add_record( dict(name=prefix + 'PHO', value=pcal_type, comment='PhotoCal class')) psf.toFitsHeader(hdr, prefix + 'PSF_') wcs.toFitsHeader(hdr, prefix + 'WCS_') sky.toFitsHeader(hdr, prefix + 'SKY_') pcal.toFitsHeader(hdr, prefix + 'PHO_') return hdr
def __init__(self, d, detpos, header=None): """ A sky pc is a 3d array with index 0 enumerating 2d principal components of sky. """ self.d = np.array(d) self.detpos = detpos self.header = fitsio.FITSHDR(header)
def _write_hpx_fits(pixlist): """from files that touch a pixel, write out objects in each pixel""" pixnum, files = pixlist # ADM only proceed if some files touch a pixel. if len(files) > 0: # ADM track if it's our first time through the files loop. first = True # ADM Read in files that touch a pixel. for file in files: filename = os.path.join(fitsdir, file) objs = fitsio.read(filename) # ADM only retain objects in the correct pixel. pix = radec2pix(nside, objs["RA"], objs["DEC"]) if first: done = objs[pix == pixnum] first = False else: done = np.hstack([done, objs[pix == pixnum]]) # ADM construct the name of the output file. outfilename = 'healpix-{:05d}.fits'.format(pixnum) outfile = os.path.join(hpxdir, outfilename) # ADM write out the file. hdr = fitsio.FITSHDR() hdr['HPXNSIDE'] = nside hdr['HPXNEST'] = True fitsio.write(outfile, done, extname='URATHPX', header=hdr) return
def save_pars(self, filename, clobber=False): """ Save the parameters to a fits file. Parameters ---------- filename: `str` Filename to save to. clobber: `bool`, optional Clobber any existing file? Default is False. """ hdr = fitsio.FITSHDR() hdr['NCOL'] = self.config.nmag - 1 hdr['MSTARSUR'] = self.config.mstar_survey hdr['MSTARBAN'] = self.config.mstar_band hdr['LIMMAG'] = self.config.limmag_catalog # Saved with arbitrary cushion that seems to work well hdr['ZRANGE0'] = np.clip(self.config.zrange[0] - 0.07, 0.01, None) hdr['ZRANGE1'] = self.config.zrange[1] + 0.07 hdr['ALPHA'] = self.config.calib_lumfunc_alpha hdr['ZBINFINE'] = self.config.zredc_binsize_fine hdr['ZBINCOAR'] = self.config.zredc_binsize_coarse hdr['LOWZMODE'] = 0 hdr['REF_IND'] = self.config.ref_ind # Only save the b values if they're > 0 (that means we have # luptitudes). if self.config.b[0] > 0.0: for j, b in enumerate(self.config.b): hdr['BVALUE%d' % (j + 1)] = b self.pars.to_fits_file(filename, header=hdr, clobber=clobber)
def saveAtm(self, filename, clobber=False): """ Save the atmosphere to a fits file parameters ---------- filename: string output filename clobber: bool, optional clobber existing output file. Default is False """ import fitsio hdr = fitsio.FITSHDR() hdr['PMB'] = self.pmb hdr['PWV'] = self.pwv hdr['O3'] = self.o3 hdr['TAU'] = self.tau hdr['LAMNORM'] = self.lambdaNorm hdr['ALPHA'] = self.alpha hdr['ZENITH'] = self.zenith hdr['CO2MX'] = self.co2MX hdr['ELEV'] = self.elevation fitsio.write(filename, self.atm, header=hdr, clobber=clobber)
def _consumeRead(self, path, cmd, header=None): # /home/data/wincharis/H2RG-C17206-ASIC-104/UpTheRamp/20160712210126/H2RG_R01_M01_N01.fits dirName, fileName = os.path.split(path) cmd.diag('text="checking %s"' % (fileName)) match = re.match('^H2RG_R0*(\d+)_M0*(\d+)_N0*(\d+)\.fits', fileName) if match is None: cmd.warn("failed to split up filename: %s" % (file)) return rampN, groupN, readN = [int(m) for m in match.group(1, 2, 3)] cmd.diag('text="new read %d %d %d"' % (rampN, groupN, readN)) if readN == 1: if header is not None: cmd.diag('text="getting header"') subaruHdr = header else: subaruHdr = pyfits.Header() cards = [dict(name='IDLPATH', value=dirName)] for c in subaruHdr.cards: cards.append( dict(name=c.keyword, value=c.value, comment=c.comment)) phdu = fitsio.FITSHDR(cards) fitsio.write(self.outfile, None, header=phdu, clobber=True) cmd.diag('text="new file %s"' % (self.outfile)) inData, inHdr = fitsio.read(path, header=True) stackFile = fitsio.FITS(self.outfile, mode='rw') stackFile.write(inData, header=inHdr) stackFile[-1].write_checksum() stackFile.close() cmd.inform('readN=%d,%d,%d,%s' % (rampN, groupN, readN, self.outfile))
def write_targets(filename, data, indir=None, qso_selection=None, sandboxcuts=False, nside=None): """Write a target catalogue. Parameters ---------- filename : output target selection file data : numpy structured array of targets to save nside: :class:`int` If passed, add a column to the targets array popluated with HEALPix pixels at resolution nside """ # FIXME: assert data and tsbits schema #ADM set up the default logger from lvmutil.log import get_logger log = get_logger() #ADM use RELEASE to determine the release string for the input targets if len(data) == 0: #ADM if there are no targets, then we don't know the Data Release drstring = 'unknowndr' else: drint = np.max(data['RELEASE'] // 1000) drstring = 'dr' + str(drint) #- Create header to include versions, etc. hdr = fitsio.FITSHDR() depend.setdep(hdr, 'lvmtarget', lvmtarget_version) depend.setdep(hdr, 'lvmtarget-git', gitversion()) depend.setdep(hdr, 'sandboxcuts', sandboxcuts) depend.setdep(hdr, 'photcat', drstring) if indir is not None: depend.setdep(hdr, 'tractor-files', indir) if qso_selection is None: log.warning('qso_selection method not specified for output file') depend.setdep(hdr, 'qso-selection', 'unknown') else: depend.setdep(hdr, 'qso-selection', qso_selection) #ADM add HEALPix column, if requested by input if nside is not None: theta, phi = np.radians(90 - data["DEC"]), np.radians(data["RA"]) hppix = hp.ang2pix(nside, theta, phi, nest=True) data = rfn.append_fields(data, 'HPXPIXEL', hppix, usemask=False) hdr['HPXNSIDE'] = nside hdr['HPXNEST'] = True #ADM add PHOTSYS column, mapped from RELEASE photsys = release_to_photsys(data["RELEASE"]) data = rfn.append_fields(data, 'PHOTSYS', photsys, usemask=False) fitsio.write(filename, data, extname='TARGETS', header=hdr, clobber=True)
def load_templates(self): """ Load in all of the header templates """ self.header = fitsio.FITSHDR() for hdrname in self.hdrlist: hdrfile = os.path.join(HEADERSERVICE_DIR,'etc','SciCamera',"%s.header" % hdrname) # We read and append at the same time, but we might want # to de-couple these two actions, if we want to keept the # sections separated so they can be streamed independently self.header = fitsio.read_scamp_head(hdrfile,header=self.header)
def sim_stuck_sky(dirnm, hw, tiles): from desiutil.brick import Bricks bricks = Bricks(bricksize=1) tab = bricks.to_table() skybricks_dir = os.path.join(dirnm, 'skybricks') os.makedirs(skybricks_dir) skyfn = os.path.join(skybricks_dir, 'skybricks-exist.fits') tab.write(skyfn) # create bricks touched by 'tiles'. rad = hw.focalplane_radius_deg def radec2xyz(r, d): r = np.deg2rad(r) d = np.deg2rad(d) x = np.cos(r) * np.cos(d) y = np.sin(r) * np.cos(d) z = np.sin(d) return np.vstack((x, y, z)).T skyxyz = radec2xyz(tab['RA'], tab['DEC']) ns = skyxyz.shape[0] tilexyz = radec2xyz(tiles.ra, tiles.dec) nt = tilexyz.shape[0] maxr2 = (np.deg2rad(rad + np.sqrt(2) / 2.))**2 skybricks = set() for i in range(nt): r2 = np.sum((tilexyz[i, :] - skyxyz)**2, axis=1) J = np.flatnonzero(r2 < maxr2) skybricks.update(J) for i in skybricks: print('Writing fake SKYBRICK', tab['BRICKNAME'][i]) # skybrick size in pixels sz = 3672 # fraction of pixels to say are good sky goodsky_frac = 0.75 randsky = (16 * (np.random.uniform(size=(sz, sz)) > goodsky_frac)).astype( np.uint8) # Add WCS header hdr = fitsio.FITSHDR() hdr['CTYPE1'] = 'RA---TAN' hdr['CTYPE2'] = 'DEC--TAN' hdr['CRVAL1'] = tab['RA'][i] hdr['CRVAL2'] = tab['DEC'][i] hdr['CRPIX1'] = (sz + 1) / 2. hdr['CRPIX2'] = (sz + 1) / 2. hdr['CD1_1'] = -1. / 3600. hdr['CD1_2'] = 0. hdr['CD2_1'] = 0. hdr['CD2_2'] = 1. / 3600. outfn = os.path.join(skybricks_dir, 'sky-%s.fits.gz' % tab['BRICKNAME'][i]) fitsio.write(outfn, randsky, header=hdr) os.environ['SKYBRICKS_DIR'] = skybricks_dir
def write_gfas(filename, data, indir=None, nside=None, survey="?", gaiaepoch=None): """Write a catalogue of Guide/Focus/Alignment targets. Parameters ---------- filename : :class:`str` Output file name. data : :class:`~numpy.ndarray` Array of GFAs to write to file. indir : :class:`str`, optional, defaults to None. Name of input Legacy Survey Data Release directory, write to header of output file if passed (and if not None). nside: :class:`int`, defaults to None. If passed, add a column to the GFAs array popluated with HEALPixels at resolution `nside`. survey : :class:`str`, optional, defaults to "?" Written to output file header as the keyword `SURVEY`. gaiaepoch: :class:`float`, defaults to None Gaia proper motion reference epoch. If not None, write to header of output file. If None, default to an epoch of 2015.5. """ # ADM rename 'TYPE' to 'MORPHTYPE'. data = rfn.rename_fields(data, {'TYPE': 'MORPHTYPE'}) # ADM create header to include versions, etc. hdr = fitsio.FITSHDR() depend.setdep(hdr, 'desitarget', desitarget_version) depend.setdep(hdr, 'desitarget-git', gitversion()) if indir is not None: depend.setdep(hdr, 'input-data-release', indir) # ADM note that if 'dr' is not in the indir DR # ADM directory structure, garbage will # ADM be rewritten gracefully in the header. drstring = 'dr'+indir.split('dr')[-1][0] depend.setdep(hdr, 'photcat', drstring) # ADM add HEALPix column, if requested by input. if nside is not None: theta, phi = np.radians(90-data["DEC"]), np.radians(data["RA"]) hppix = hp.ang2pix(nside, theta, phi, nest=True) data = rfn.append_fields(data, 'HPXPIXEL', hppix, usemask=False) hdr['HPXNSIDE'] = nside hdr['HPXNEST'] = True # ADM add the type of survey (main, or commissioning "cmx") to the header. hdr["SURVEY"] = survey # ADM add the Gaia reference epoch, or pass 2015.5 if not included. hdr['REFEPOCH'] = {'name': 'REFEPOCH', 'value': 2015.5, 'comment': "Gaia Proper Motion Reference Epoch"} if gaiaepoch is not None: hdr['REFEPOCH'] = gaiaepoch fitsio.write(filename, data, extname='GFA_TARGETS', header=hdr, clobber=True)
def writeCatalog(outname, nrows, ncols, dtype='f8'): # Names of the columns and dtypes dtypes = [("VAR%s" % (k + 1), dtype) for k in range(ncols)] data = numpy.zeros(nrows, dtypes) for var, vartype in dtypes: data[var] = numpy.random.random((nrows)) header = fitsio.FITSHDR() fitsio.write(outname, data, extname='OBJECTS', clobber=True, header=header)
def write_fits(self, filename, hdr=None): import fitsio tt = type(self) sky_type = '%s.%s' % (tt.__module__, tt.__name__) if hdr is None: hdr = fitsio.FITSHDR() hdr.add_record(dict(name='SKY', value=sky_type, comment='Sky class')) self.toFitsHeader(hdr, prefix='SKY_') fitsio.write(filename, None, header=hdr, clobber=True)
def convert_depthfile_to_healsparse(depthfile, healsparsefile, nsideCoverage, clobber=False): """ Convert an old depthfile to a new healsparsefile Parameters ---------- depthfile: `str` Input depth file healsparsefile: `str` Output healsparse file nsideCoverage: `int` Nside for sparse coverage map clobber: `bool`, optional Clobber existing healsparse file? Default is False. """ old_depth, old_hdr = fitsio.read(depthfile, ext=1, header=True, lower=True) nside = old_hdr['nside'] # Need to remove the HPIX from the dtype dtype_new = [] names = [] for d in old_depth.dtype.descr: if d[0] != 'hpix': dtype_new.append(d) names.append(d[0]) sparseMap = healsparse.HealSparseMap.makeEmpty(nsideCoverage, nside, dtype_new, primary='fracgood') old_depth_sub = np.zeros(old_depth.size, dtype=dtype_new) for name in names: old_depth_sub[name] = old_depth[name] sparseMap.updateValues(old_depth['hpix'], old_depth_sub, nest=old_hdr['nest']) hdr = fitsio.FITSHDR() hdr['NSIG'] = old_hdr['NSIG'] hdr['ZP'] = old_hdr['ZP'] hdr['NBAND'] = old_hdr['NBAND'] hdr['W'] = old_hdr['W'] hdr['EFF'] = old_hdr['EFF'] sparseMap.write(healsparsefile, clobber=clobber, header=hdr)
def copy_header_with_wcs(source_header, wcs): import fitsio hdr = fitsio.FITSHDR() if source_header is not None: for r in source_header.records(): hdr.add_record(r) # Plug the WCS header cards into these images wcs.add_to_header(hdr) hdr.add_record(dict(name='EQUINOX', value=2000., comment='WCS epoch')) hdr.delete('IMAGEW') hdr.delete('IMAGEH') return hdr
def get_version_header(program_name, decals_dir, git_version=None): ''' Creates a fitsio header describing a DECaLS data product. ''' import datetime if program_name is None: import sys program_name = sys.argv[0] if git_version is None: git_version = get_git_version() #print('Version:', git_version) hdr = fitsio.FITSHDR() for s in [ 'Data product of the DECam Legacy Survey (DECaLS)', 'Full documentation at http://legacysurvey.org', ]: hdr.add_record(dict(name='COMMENT', value=s, comment=s)) hdr.add_record(dict(name='LEGPIPEV', value=git_version, comment='legacypipe git version')) hdr.add_record(dict(name='DECALSV', value=decals_dir, comment='DECaLS version')) hdr.add_record(dict(name='DECALSDR', value='DR2', comment='DECaLS release name')) decalsdir_ver = get_git_version(decals_dir) hdr.add_record(dict(name='DECALSDV', value=decalsdir_ver, comment='legacypipe-dir git version')) hdr.add_record(dict(name='DECALSDT', value=datetime.datetime.now().isoformat(), comment='%s run time' % program_name)) hdr.add_record(dict(name='SURVEY', value='DECaLS', comment='DECam Legacy Survey')) # Requested by NOAO hdr.add_record(dict(name='SURVEYID', value='DECam Legacy Survey (DECaLS)', comment='Survey name')) hdr.add_record(dict(name='DRVERSIO', value='DR2', comment='Survey data release number')) hdr.add_record(dict(name='OBSTYPE', value='object', comment='Observation type')) hdr.add_record(dict(name='PROCTYPE', value='tile', comment='Processing type')) import socket hdr.add_record(dict(name='HOSTNAME', value=socket.gethostname(), comment='Machine where runbrick.py was run')) hdr.add_record(dict(name='HOSTFQDN', value=socket.getfqdn(), comment='Machine where runbrick.py was run')) hdr.add_record(dict(name='NERSC', value=os.environ.get('NERSC_HOST', 'none'), comment='NERSC machine where runbrick.py was run')) return hdr
def write_partial_map(filename, data, nside, coord=None, nest=False, header=None, dtype=None, **kwargs): """ Partial HEALPix maps are used to efficiently store maps of the sky by only writing out the pixels that contain data. Three-dimensional data can be saved by supplying a distance modulus array which is stored in a separate extension. Parameters: ----------- filename : output file name data : dictionary or recarray of data to write (must contain 'PIXEL') nside : healpix nside of data coord : 'G'alactic, 'C'elestial, 'E'cliptic ordering : 'RING' or 'NEST' kwargs : Passed to fitsio.write Returns: -------- None """ import fitsio # ADW: Do we want to make everything uppercase? if isinstance(data, dict): names = list(data.keys()) else: names = data.dtype.names if 'PIXEL' not in names: msg = "'PIXEL' column not found." raise ValueError(msg) hdr = header_odict(nside=nside, coord=coord, nest=nest) fitshdr = fitsio.FITSHDR(list(hdr.values())) if header is not None: for k, v in header.items(): fitshdr.add_record({'name': k, 'value': v}) # ADW: Should this be a debug? logger.info("Writing %s..." % filename) fitsio.write(filename, data, extname='PIX_DATA', header=fitshdr, clobber=True)
def make_zred_table(self, indices_and_filenames): """ Make a zred table from a list of indices and filenames Saves to self.config.zredfile. Parameters ---------- indices_and_filenames: `list` List of (index, outfile) tuples describing zred files. """ # figure out longest filename maxlen = 0 for index, filename in indices_and_filenames: if len(os.path.basename(filename)) > maxlen: maxlen = len(os.path.basename(filename)) gal_dtype = self.galtable.dtype zred_dtype = [] for dt in gal_dtype.descr: if dt[0].lower() == 'filenames': dt = ('filenames', 'S%d' % (maxlen + 1), dt[2]) zred_dtype.append(dt) zredtable = Entry(np.zeros(1, dtype=zred_dtype)) for name in gal_dtype.names: zredtable._ndarray[name] = self.galtable._ndarray[name] zredtable.filenames = '' zredtable.ngals = 0 for index, filename in indices_and_filenames: # Make sure file exists if not os.path.isfile(filename): raise ValueError("Could not find zredfile: %s" % (filename)) # check size of file hdr = fitsio.read_header(filename, ext=1) if hdr['NAXIS2'] != self.galtable.ngals[index]: raise ValueError("Length mismatch for zredfile: %s" % (filename)) zredtable.filenames[index] = os.path.basename(filename) zredtable.ngals[index] = self.galtable.ngals[index] hdr = fitsio.FITSHDR() hdr['PIXELS'] = 1 zredtable.to_fits_file(self.config.zredfile, header=hdr, clobber=True)
def getStandardFitsHeader(self, header=None): if header is None: import fitsio hdr = fitsio.FITSHDR() else: hdr = header psf = self.getPsf() wcs = self.getWcs() sky = self.getSky() pcal = self.getPhotoCal() psf.toStandardFitsHeader(hdr) wcs.toStandardFitsHeader(hdr) sky.toStandardFitsHeader(hdr) pcal.toStandardFitsHeader(hdr) return hdr
def finish(self, survey, brickname, version_header): from legacypipe.survey import imsave_jpeg for band, co, n, com, coiv in zip([1, 2, 3, 4], self.unwise_co, self.unwise_con, self.unwise_com, self.unwise_coiv): hdr = fitsio.FITSHDR() for r in version_header.records(): hdr.add_record(r) hdr.add_record(dict(name='TELESCOP', value='WISE')) hdr.add_record( dict(name='FILTER', value='W%i' % band, comment='WISE band')) self.unwise_wcs.add_to_header(hdr) hdr.delete('IMAGEW') hdr.delete('IMAGEH') hdr.add_record(dict(name='EQUINOX', value=2000.)) hdr.add_record( dict(name='MAGZERO', value=22.5, comment='Magnitude zeropoint')) hdr.add_record( dict(name='MAGSYS', value='Vega', comment='This WISE image is in Vega fluxes')) co /= np.maximum(n, 1) com /= np.maximum(n, 1) with survey.write_output('image', brick=brickname, band='W%i' % band, shape=co.shape) as out: out.fits.write(co, header=hdr) with survey.write_output('model', brick=brickname, band='W%i' % band, shape=com.shape) as out: out.fits.write(com, header=hdr) with survey.write_output('invvar', brick=brickname, band='W%i' % band, shape=co.shape) as out: out.fits.write(coiv, header=hdr) # W1/W2 color jpeg rgb = _unwise_to_rgb(self.unwise_co[:2]) with survey.write_output('wise-jpeg', brick=brickname) as out: imsave_jpeg(out.fn, rgb, origin='lower') info('Wrote', out.fn) rgb = _unwise_to_rgb(self.unwise_com[:2]) with survey.write_output('wisemodel-jpeg', brick=brickname) as out: imsave_jpeg(out.fn, rgb, origin='lower') info('Wrote', out.fn)
def read_head_template(fname, header=None): """ Function to read in the templates used for the HeaderService. This function is based on fitsio.read_scamp_head() and has been modified to treat comments (when the KEYWORD field is blank) according to the definition of Pence et al. 2010 (section 4.4.2.4) read a template header file as a fits header FITSHDR object parameters ---------- fname: string The path to the header file header: FITSHDR, optional Optionally combine the header with the input one. The input can be any object convertable to a FITSHDR object returns ------- header: FITSHDR A fits header object of type FITSHDR """ with open(fname) as fobj: lines = fobj.readlines() lines = [line.rstrip() for line in lines if line[0:3] != 'END'] # if header is None an empty FITSHDR is created hdr = fitsio.FITSHDR(header) for line in lines: hdr.add_record(line) # Nedd to fix the keyword for HIERARCH, as fitsio removes the # HIERARCH string from the keyword. Here we put it back index_map = copy.deepcopy(hdr._index_map) for keyword in index_map: rec = get_record(hdr, keyword) try: is_hierarch = check_hierarch(rec) except Exception: is_hierarch = False if is_hierarch: name_old = rec['name'] name_new = f"HIERARCH {rec['name']}" rec['name'] = name_new hdr._index_map[name_new] = hdr._index_map.pop(name_old) return hdr
def read_primary_header(fn): ''' Reads the FITS primary header (HDU 0) from the given filename. This is just a faster version of fitsio.read_header(fn). ''' import fitsio if fn.endswith('.gz'): return fitsio.read_header(fn) # Weirdly, this can be MUCH faster than letting fitsio do it... hdr = fitsio.FITSHDR() foundEnd = False ff = open(fn, 'rb') h = b'' while True: hnew = ff.read(32768) if len(hnew) == 0: # EOF ff.close() raise RuntimeError( 'Reached end-of-file in "%s" before finding end of FITS header.' % fn) h = h + hnew while True: line = h[:80] h = h[80:] #print('Header line "%s"' % line) # HACK -- fitsio apparently can't handle CONTINUE. # It also has issues with slightly malformed cards, like # KEYWORD = / no value if line[:8] != b'CONTINUE': try: hdr.add_record(line.decode()) except OSError as err: print('Warning: failed to parse FITS header line: ' + ('"%s"; error "%s"; skipped' % (line.strip(), str(err)))) if line == (b'END' + b' ' * 77): foundEnd = True break if len(h) < 80: break if foundEnd: break ff.close() return hdr
def read_image_primary_header(self, **kwargs): ''' Reads the FITS primary (HDU 0) header from self.imgfn. Returns ------- primary_header : fitsio header The FITS header ''' if self.imgfn.endswith('.gz'): return fitsio.read_header(self.imgfn) # Crazily, this can be MUCH faster than letting fitsio do it... hdr = fitsio.FITSHDR() foundEnd = False ff = open(self.imgfn, 'r') h = '' while True: h = h + ff.read(32768) while True: line = h[:80] h = h[80:] #print('Header line "%s"' % line) # HACK -- fitsio apparently can't handle CONTINUE. # It also has issues with slightly malformed cards, like # KEYWORD = / no value if line[:8] != 'CONTINUE': try: hdr.add_record(line) except: print('Warning: failed to parse FITS header line: ' + ('"%s"; skipped' % line.strip())) if line == ('END' + ' ' * 77): foundEnd = True break if len(h) < 80: break if foundEnd: break ff.close() return hdr
def save_pars(self, filename, clobber=False): """ """ hdr = fitsio.FITSHDR() hdr['NCOL'] = self.config.nmag - 1 hdr['MSTARSUR'] = self.config.mstar_survey hdr['MSTARBAN'] = self.config.mstar_band hdr['LIMMAG'] = self.config.limmag_catalog # Saved with arbitrary cushion that seems to work well hdr['ZRANGE0'] = np.clip(self.config.zrange[0] - 0.07, 0.01, None) hdr['ZRANGE1'] = self.config.zrange[1] + 0.07 hdr['ALPHA'] = self.config.calib_lumfunc_alpha hdr['ZBINFINE'] = self.config.zredc_binsize_fine hdr['ZBINCOAR'] = self.config.zredc_binsize_coarse hdr['LOWZMODE'] = 0 hdr['REF_IND'] = self.config.ref_ind for j, b in enumerate(self.config.b): hdr['BVALUE%d' % (j + 1)] = b self.pars.to_fits_file(filename, header=hdr, clobber=clobber)
def _get_wcs_header(): cards = [ "NAXIS = 2 / 2-dimensional binary table", "NAXIS1 = 2048 / length of data axix 1", "NAXIS2 = 4096 / length of data axix 2", "CRPIX1 = 6660. / Reference pixel on this axis", "CRPIX2 = -4341. / Reference pixel on this axis", "CCDBIN1 = 1 / Pixel binning, axis 1", "CCDBIN2 = 1 / Pixel binning, axis 2", "CUNIT1 = 'deg ' / Axis unit", "CD1_1 = 1.013141083499E-08 / Linear projection matrix", "CD1_2 = 7.285974030215E-05 / Linear projection matrix", "CUNIT2 = 'deg ' / Axis unit", "CD2_1 = -7.285598092499E-05 / Linear projection matrix", "CD2_2 = 1.572634539309E-08 / Linear projection matrix", "CTYPE2 = 'DEC--TPV' / WCS projection type for this axis", "CTYPE1 = 'RA---TPV' / WCS projection type for this axis", "CRVAL1 = 70.12751953531 / World coordinate on this axis", "CRVAL2 = -54.55415863979 / World coordinate on this axis", ] return fitsio.FITSHDR(cards)
def writeto(self, fn): from astrometry.util.fits import fits_table import fitsio T = fits_table() T.psf_mask = np.array([self.psfbases]) hdr = fitsio.FITSHDR() hdr['POLNAME1'] = 'X_IMAGE' hdr['POLNAME2'] = 'Y_IMAGE' hdr['POLGRP1'] = 1 hdr['POLGRP2'] = 1 hdr['POLNGRP'] = 1 # number of terms in polynomial ne = (self.degree + 1) * (self.degree + 2) / 2 hdr['PSFAXIS3'] = ne hdr['POLZERO1'] = self.x0 hdr['POLZERO2'] = self.y0 hdr['POLSCAL1'] = self.xscale hdr['POLSCAL2'] = self.yscale hdr['POLDEG1'] = self.degree hdr['PSF_SAMP'] = self.sampling T.writeto(fn, header=hdr)
def __init__(self, U, blocksize=DEFAULT_BLOCKSIZE, mask_value=DEFAULT_MASK_VALUE, invalid=DEFAULT_IGNORE.split(','), header=None, halfS7=True): """ :Parameters: `U`: 2d numpy array with shape (number of sky superpixels : number of pcs) """ self.U = np.array(U) self.blocksize = blocksize self.mask_value = mask_value self.invalid = set() if invalid is not None: for detpos in invalid: self.invalid.add(detpos.strip()) self.header = fitsio.FITSHDR(header) self.halfS7 = halfS7
def parse_head_file(fn): import fitsio f = open(fn, 'r') hdrs = [] #s = '' hdr = None for line in f.readlines(): #print('Read %i chars' % len(line), ': ' + line[:25]+'...') line = line.strip() #print('Stripped to %i' % len(line)) #line = line + ' ' * (80 - len(line)) #assert(len(line) == 80) #s += line if line.startswith('END'): #print('Found END') hdr = None continue if hdr is None: hdr = fitsio.FITSHDR() hdrs.append(hdr) #print('Started header number', len(hdrs)) hdr.add_record(line) return hdrs
def read_image_header(row, img_file): """Read some information from the image header and write into the df row. """ hdu = 0 # Note: The next line usually works, but fitsio doesn't support CONTINUE lines, which DES # image headers sometimes include. #h = fitsio.read_header(img_file, hdu) # I don't care about any of the lines the sometimes use CONITNUE (e.g. OBSERVER), so I # just remove them and make the header with the rest of the entries. f = fitsio.FITS(img_file) header_list = f[hdu].read_header_list() header_list = [ d for d in header_list if 'CONTINUE' not in d['name'] ] h = fitsio.FITSHDR(header_list) try: date = h['DATE-OBS'] date, time = date.strip().split('T',1) filter = h['FILTER'] filter = filter.split()[0] sat = h['SATURATE'] fwhm = h['FWHM'] ccdnum = int(h['CCDNUM']) detpos = h['DETPOS'].strip() telra = h['TELRA'] teldec = h['TELDEC'] telha = h['HA'] if galsim.__version__ >= '1.5.1': telra = galsim.Angle.from_hms(telra) / galsim.degrees teldec = galsim.Angle.from_dms(teldec) / galsim.degrees telha = galsim.Angle.from_hms(telha) / galsim.degrees else: telra = galsim.HMS_Angle(telra) / galsim.degrees teldec = galsim.DMS_Angle(teldec) / galsim.degrees telha = galsim.HMS_Angle(telha) / galsim.degrees airmass = float(h.get('AIRMASS',-999)) sky = float(h.get('SKYBRITE',-999)) sigsky = float(h.get('SKYSIGMA',-999)) tiling = int(h.get('TILING',0)) hex = int(h.get('HEX',0)) except Exception as e: logger.info("Caught %s",e) logger.info("Cannot read header information from %s", img_file) raise row['date'] = date row['time'] = time row['sat'] = sat row['fits_filter'] = filter row['fits_fwhm'] = fwhm row['fits_ccdnum'] = ccdnum row['telra'] = telra row['teldec'] = teldec row['telha'] = telha row['airmass'] = airmass row['sky'] = sky row['sigsky'] = sigsky row['tiling'] = tiling row['hex'] = hex